[rustc.git] / src / llvm / include / llvm-c / Target.h

/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*/
/*                                                                            */
/*                     The LLVM Compiler Infrastructure                       */
/*                                                                            */
/* This file is distributed under the University of Illinois Open Source      */
/* License. See LICENSE.TXT for details.                                      */
/*                                                                            */
/*===----------------------------------------------------------------------===*/
/*                                                                            */
/* This header declares the C interface to libLLVMTarget.a, which             */
/* implements target information.                                             */
/*                                                                            */
/* Many exotic languages can interoperate with C code but have a harder time  */
/* with C++ due to name mangling. So in addition to C, this interface enables */
/* tools written in such languages.                                           */
/*                                                                            */
/*===----------------------------------------------------------------------===*/

#ifndef LLVM_C_TARGET_H
#define LLVM_C_TARGET_H

#include "llvm-c/Core.h"
#include "llvm/Config/llvm-config.h"

#if defined(_MSC_VER) && !defined(inline)
#define inline __inline
#endif

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @defgroup LLVMCTarget Target information
 * @ingroup LLVMC
 *
 * @{
 */

enum LLVMByteOrdering { LLVMBigEndian, LLVMLittleEndian };

typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef;

/* Declare all of the target-initialization functions that are available. */
#define LLVM_TARGET(TargetName) \
  void LLVMInitialize##TargetName##TargetInfo(void);
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */

#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void);
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */

#define LLVM_TARGET(TargetName) \
  void LLVMInitialize##TargetName##TargetMC(void);
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */

/* Declare all of the available assembly printer initialization functions. */
#define LLVM_ASM_PRINTER(TargetName) \
  void LLVMInitialize##TargetName##AsmPrinter(void);
#include "llvm/Config/AsmPrinters.def"
#undef LLVM_ASM_PRINTER  /* Explicit undef to make SWIG happier */

/* Declare all of the available assembly parser initialization functions. */
#define LLVM_ASM_PARSER(TargetName) \
  void LLVMInitialize##TargetName##AsmParser(void);
#include "llvm/Config/AsmParsers.def"
#undef LLVM_ASM_PARSER  /* Explicit undef to make SWIG happier */

/* Declare all of the available disassembler initialization functions. */
#define LLVM_DISASSEMBLER(TargetName) \
  void LLVMInitialize##TargetName##Disassembler(void);
#include "llvm/Config/Disassemblers.def"
#undef LLVM_DISASSEMBLER  /* Explicit undef to make SWIG happier */

/** LLVMInitializeAllTargetInfos - The main program should call this function if
    it wants access to all available targets that LLVM is configured to
    support. */
static inline void LLVMInitializeAllTargetInfos(void) {
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeAllTargets - The main program should call this function if it
    wants to link in all available targets that LLVM is configured to
    support. */
static inline void LLVMInitializeAllTargets(void) {
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeAllTargetMCs - The main program should call this function if
    it wants access to all available target MC that LLVM is configured to
    support. */
static inline void LLVMInitializeAllTargetMCs(void) {
#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC();
#include "llvm/Config/Targets.def"
#undef LLVM_TARGET  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeAllAsmPrinters - The main program should call this function if
    it wants all asm printers that LLVM is configured to support, to make them
    available via the TargetRegistry. */
static inline void LLVMInitializeAllAsmPrinters(void) {
#define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter();
#include "llvm/Config/AsmPrinters.def"
#undef LLVM_ASM_PRINTER  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeAllAsmParsers - The main program should call this function if
    it wants all asm parsers that LLVM is configured to support, to make them
    available via the TargetRegistry. */
static inline void LLVMInitializeAllAsmParsers(void) {
#define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser();
#include "llvm/Config/AsmParsers.def"
#undef LLVM_ASM_PARSER  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeAllDisassemblers - The main program should call this function
    if it wants all disassemblers that LLVM is configured to support, to make
    them available via the TargetRegistry. */
static inline void LLVMInitializeAllDisassemblers(void) {
#define LLVM_DISASSEMBLER(TargetName) \
  LLVMInitialize##TargetName##Disassembler();
#include "llvm/Config/Disassemblers.def"
#undef LLVM_DISASSEMBLER  /* Explicit undef to make SWIG happier */
}

/** LLVMInitializeNativeTarget - The main program should call this function to
    initialize the native target corresponding to the host.  This is useful
    for JIT applications to ensure that the target gets linked in correctly. */
static inline LLVMBool LLVMInitializeNativeTarget(void) {
  /* If we have a native target, initialize it to ensure it is linked in. */
#ifdef LLVM_NATIVE_TARGET
  LLVM_NATIVE_TARGETINFO();
  LLVM_NATIVE_TARGET();
  LLVM_NATIVE_TARGETMC();
  return 0;
#else
  return 1;
#endif
}

/** LLVMInitializeNativeTargetAsmParser - The main program should call this
    function to initialize the parser for the native target corresponding to the
    host. */
static inline LLVMBool LLVMInitializeNativeAsmParser(void) {
#ifdef LLVM_NATIVE_ASMPARSER
  LLVM_NATIVE_ASMPARSER();
  return 0;
#else
  return 1;
#endif
}

/** LLVMInitializeNativeTargetAsmPrinter - The main program should call this
    function to initialize the printer for the native target corresponding to
    the host. */
static inline LLVMBool LLVMInitializeNativeAsmPrinter(void) {
#ifdef LLVM_NATIVE_ASMPRINTER
  LLVM_NATIVE_ASMPRINTER();
  return 0;
#else
  return 1;
#endif
}

/** LLVMInitializeNativeTargetDisassembler - The main program should call this
    function to initialize the disassembler for the native target corresponding
    to the host. */
static inline LLVMBool LLVMInitializeNativeDisassembler(void) {
#ifdef LLVM_NATIVE_DISASSEMBLER
  LLVM_NATIVE_DISASSEMBLER();
  return 0;
#else
  return 1;
#endif
}

/*===-- Target Data -------------------------------------------------------===*/

/** Creates target data from a target layout string.
    See the constructor llvm::DataLayout::DataLayout. */
LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);

/** Adds target data information to a pass manager. This does not take ownership
    of the target data.
    See the method llvm::PassManagerBase::add. */
void LLVMAddTargetData(LLVMTargetDataRef TD, LLVMPassManagerRef PM);

/** Adds target library information to a pass manager. This does not take
    ownership of the target library info.
    See the method llvm::PassManagerBase::add. */
void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef TLI,
                              LLVMPassManagerRef PM);

/** Converts target data to a target layout string. The string must be disposed
    with LLVMDisposeMessage.
    See the constructor llvm::DataLayout::DataLayout. */
char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef TD);

/** Returns the byte order of a target, either LLVMBigEndian or
    LLVMLittleEndian.
    See the method llvm::DataLayout::isLittleEndian. */
enum LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef TD);

/** Returns the pointer size in bytes for a target.
    See the method llvm::DataLayout::getPointerSize. */
unsigned LLVMPointerSize(LLVMTargetDataRef TD);

/** Returns the pointer size in bytes for a target for a specified
    address space.
    See the method llvm::DataLayout::getPointerSize. */
unsigned LLVMPointerSizeForAS(LLVMTargetDataRef TD, unsigned AS);

/** Returns the integer type that is the same size as a pointer on a target.
    See the method llvm::DataLayout::getIntPtrType. */
LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef TD);

/** Returns the integer type that is the same size as a pointer on a target.
    This version allows the address space to be specified.
    See the method llvm::DataLayout::getIntPtrType. */
LLVMTypeRef LLVMIntPtrTypeForAS(LLVMTargetDataRef TD, unsigned AS);

/** Returns the integer type that is the same size as a pointer on a target.
    See the method llvm::DataLayout::getIntPtrType. */
LLVMTypeRef LLVMIntPtrTypeInContext(LLVMContextRef C, LLVMTargetDataRef TD);

/** Returns the integer type that is the same size as a pointer on a target.
    This version allows the address space to be specified.
    See the method llvm::DataLayout::getIntPtrType. */
LLVMTypeRef LLVMIntPtrTypeForASInContext(LLVMContextRef C, LLVMTargetDataRef TD,
                                         unsigned AS);

/** Computes the size of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeSizeInBits. */
unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the storage size of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeStoreSize. */
unsigned long long LLVMStoreSizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the ABI size of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeAllocSize. */
unsigned long long LLVMABISizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the ABI alignment of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeABISize. */
unsigned LLVMABIAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the call frame alignment of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeABISize. */
unsigned LLVMCallFrameAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the preferred alignment of a type in bytes for a target.
    See the method llvm::DataLayout::getTypeABISize. */
unsigned LLVMPreferredAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);

/** Computes the preferred alignment of a global variable in bytes for a target.
    See the method llvm::DataLayout::getPreferredAlignment. */
unsigned LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef TD,
                                        LLVMValueRef GlobalVar);

/** Computes the structure element that contains the byte offset for a target.
    See the method llvm::StructLayout::getElementContainingOffset. */
unsigned LLVMElementAtOffset(LLVMTargetDataRef TD, LLVMTypeRef StructTy,
                             unsigned long long Offset);

/** Computes the byte offset of the indexed struct element for a target.
    See the method llvm::StructLayout::getElementContainingOffset. */
unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef TD,
                                       LLVMTypeRef StructTy, unsigned Element);

/** Deallocates a TargetData.
    See the destructor llvm::DataLayout::~DataLayout. */
void LLVMDisposeTargetData(LLVMTargetDataRef TD);

/**
 * @}
 */

#ifdef __cplusplus
}
#endif /* defined(__cplusplus) */

#endif
Commit	Line	Data
223e47cc LB	1	/===-- llvm-c/Target.h - Target Lib C Iface --------------------- C++ --===/
	2	/* */
	3	/* The LLVM Compiler Infrastructure */
	4	/* */
	5	/* This file is distributed under the University of Illinois Open Source */
	6	/* License. See LICENSE.TXT for details. */
	7	/* */
	8	/===----------------------------------------------------------------------===/
	9	/* */
	10	/* This header declares the C interface to libLLVMTarget.a, which */
	11	/* implements target information. */
	12	/* */
	13	/* Many exotic languages can interoperate with C code but have a harder time */
	14	/* with C++ due to name mangling. So in addition to C, this interface enables */
	15	/* tools written in such languages. */
	16	/* */
	17	/===----------------------------------------------------------------------===/
	18
	19	#ifndef LLVM_C_TARGET_H
	20	#define LLVM_C_TARGET_H
	21
	22	#include "llvm-c/Core.h"
	23	#include "llvm/Config/llvm-config.h"
	24
1a4d82fc JJ	25	#if defined(_MSC_VER) && !defined(inline)
	26	#define inline __inline
	27	#endif
	28
223e47cc LB	29	#ifdef __cplusplus
	30	extern "C" {
	31	#endif
	32
	33	/**
	34	* @defgroup LLVMCTarget Target information
	35	* @ingroup LLVMC
	36	*
	37	* @{
	38	*/
	39
	40	enum LLVMByteOrdering { LLVMBigEndian, LLVMLittleEndian };
	41
	42	typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
	43	typedef struct LLVMOpaqueTargetLibraryInfotData *LLVMTargetLibraryInfoRef;
223e47cc LB	44
	45	/* Declare all of the target-initialization functions that are available. */
	46	#define LLVM_TARGET(TargetName) \
	47	void LLVMInitialize##TargetName##TargetInfo(void);
	48	#include "llvm/Config/Targets.def"
	49	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
1a4d82fc	50
223e47cc LB	51	#define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target(void);
	52	#include "llvm/Config/Targets.def"
	53	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
	54
	55	#define LLVM_TARGET(TargetName) \
	56	void LLVMInitialize##TargetName##TargetMC(void);
	57	#include "llvm/Config/Targets.def"
	58	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
1a4d82fc	59
223e47cc LB	60	/* Declare all of the available assembly printer initialization functions. */
	61	#define LLVM_ASM_PRINTER(TargetName) \
	62	void LLVMInitialize##TargetName##AsmPrinter(void);
	63	#include "llvm/Config/AsmPrinters.def"
	64	#undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */
	65
	66	/* Declare all of the available assembly parser initialization functions. */
	67	#define LLVM_ASM_PARSER(TargetName) \
	68	void LLVMInitialize##TargetName##AsmParser(void);
	69	#include "llvm/Config/AsmParsers.def"
	70	#undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */
	71
	72	/* Declare all of the available disassembler initialization functions. */
	73	#define LLVM_DISASSEMBLER(TargetName) \
	74	void LLVMInitialize##TargetName##Disassembler(void);
	75	#include "llvm/Config/Disassemblers.def"
	76	#undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */
1a4d82fc	77
223e47cc LB	78	/** LLVMInitializeAllTargetInfos - The main program should call this function if
	79	it wants access to all available targets that LLVM is configured to
	80	support. */
	81	static inline void LLVMInitializeAllTargetInfos(void) {
	82	#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
	83	#include "llvm/Config/Targets.def"
	84	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
	85	}
	86
	87	/** LLVMInitializeAllTargets - The main program should call this function if it
	88	wants to link in all available targets that LLVM is configured to
	89	support. */
	90	static inline void LLVMInitializeAllTargets(void) {
	91	#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
	92	#include "llvm/Config/Targets.def"
	93	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
	94	}
	95
	96	/** LLVMInitializeAllTargetMCs - The main program should call this function if
	97	it wants access to all available target MC that LLVM is configured to
	98	support. */
	99	static inline void LLVMInitializeAllTargetMCs(void) {
	100	#define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC();
	101	#include "llvm/Config/Targets.def"
	102	#undef LLVM_TARGET /* Explicit undef to make SWIG happier */
	103	}
1a4d82fc	104
223e47cc LB	105	/** LLVMInitializeAllAsmPrinters - The main program should call this function if
	106	it wants all asm printers that LLVM is configured to support, to make them
	107	available via the TargetRegistry. */
	108	static inline void LLVMInitializeAllAsmPrinters(void) {
	109	#define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter();
	110	#include "llvm/Config/AsmPrinters.def"
	111	#undef LLVM_ASM_PRINTER /* Explicit undef to make SWIG happier */
	112	}
1a4d82fc	113
223e47cc LB	114	/** LLVMInitializeAllAsmParsers - The main program should call this function if
	115	it wants all asm parsers that LLVM is configured to support, to make them
	116	available via the TargetRegistry. */
	117	static inline void LLVMInitializeAllAsmParsers(void) {
	118	#define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser();
	119	#include "llvm/Config/AsmParsers.def"
	120	#undef LLVM_ASM_PARSER /* Explicit undef to make SWIG happier */
	121	}
1a4d82fc	122
223e47cc LB	123	/** LLVMInitializeAllDisassemblers - The main program should call this function
	124	if it wants all disassemblers that LLVM is configured to support, to make
	125	them available via the TargetRegistry. */
	126	static inline void LLVMInitializeAllDisassemblers(void) {
	127	#define LLVM_DISASSEMBLER(TargetName) \
	128	LLVMInitialize##TargetName##Disassembler();
	129	#include "llvm/Config/Disassemblers.def"
	130	#undef LLVM_DISASSEMBLER /* Explicit undef to make SWIG happier */
	131	}
1a4d82fc	132
223e47cc	133	/** LLVMInitializeNativeTarget - The main program should call this function to
1a4d82fc	134	initialize the native target corresponding to the host. This is useful
223e47cc LB	135	for JIT applications to ensure that the target gets linked in correctly. */
	136	static inline LLVMBool LLVMInitializeNativeTarget(void) {
	137	/* If we have a native target, initialize it to ensure it is linked in. */
	138	#ifdef LLVM_NATIVE_TARGET
	139	LLVM_NATIVE_TARGETINFO();
	140	LLVM_NATIVE_TARGET();
	141	LLVM_NATIVE_TARGETMC();
	142	return 0;
	143	#else
	144	return 1;
	145	#endif
1a4d82fc JJ	146	}
	147
	148	/** LLVMInitializeNativeTargetAsmParser - The main program should call this
	149	function to initialize the parser for the native target corresponding to the
	150	host. */
	151	static inline LLVMBool LLVMInitializeNativeAsmParser(void) {
	152	#ifdef LLVM_NATIVE_ASMPARSER
	153	LLVM_NATIVE_ASMPARSER();
	154	return 0;
	155	#else
	156	return 1;
	157	#endif
	158	}
	159
	160	/** LLVMInitializeNativeTargetAsmPrinter - The main program should call this
	161	function to initialize the printer for the native target corresponding to
	162	the host. */
	163	static inline LLVMBool LLVMInitializeNativeAsmPrinter(void) {
	164	#ifdef LLVM_NATIVE_ASMPRINTER
	165	LLVM_NATIVE_ASMPRINTER();
	166	return 0;
	167	#else
	168	return 1;
	169	#endif
	170	}
	171
	172	/** LLVMInitializeNativeTargetDisassembler - The main program should call this
	173	function to initialize the disassembler for the native target corresponding
	174	to the host. */
	175	static inline LLVMBool LLVMInitializeNativeDisassembler(void) {
	176	#ifdef LLVM_NATIVE_DISASSEMBLER
	177	LLVM_NATIVE_DISASSEMBLER();
	178	return 0;
	179	#else
	180	return 1;
	181	#endif
	182	}
223e47cc LB	183
	184	/===-- Target Data -------------------------------------------------------===/
	185
	186	/** Creates target data from a target layout string.
970d7e83	187	See the constructor llvm::DataLayout::DataLayout. */
223e47cc LB	188	LLVMTargetDataRef LLVMCreateTargetData(const char *StringRep);
	189
	190	/** Adds target data information to a pass manager. This does not take ownership
	191	of the target data.
	192	See the method llvm::PassManagerBase::add. */
1a4d82fc	193	void LLVMAddTargetData(LLVMTargetDataRef TD, LLVMPassManagerRef PM);
223e47cc LB	194
	195	/** Adds target library information to a pass manager. This does not take
	196	ownership of the target library info.
	197	See the method llvm::PassManagerBase::add. */
1a4d82fc JJ	198	void LLVMAddTargetLibraryInfo(LLVMTargetLibraryInfoRef TLI,
1a4d82fc JJ	199	LLVMPassManagerRef PM);
223e47cc LB	200
	201	/** Converts target data to a target layout string. The string must be disposed
	202	with LLVMDisposeMessage.
970d7e83	203	See the constructor llvm::DataLayout::DataLayout. */
1a4d82fc	204	char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef TD);
223e47cc LB	205
	206	/** Returns the byte order of a target, either LLVMBigEndian or
	207	LLVMLittleEndian.
970d7e83	208	See the method llvm::DataLayout::isLittleEndian. */
1a4d82fc	209	enum LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef TD);
223e47cc LB	210
223e47cc LB	211	/** Returns the pointer size in bytes for a target.
970d7e83	212	See the method llvm::DataLayout::getPointerSize. */
1a4d82fc	213	unsigned LLVMPointerSize(LLVMTargetDataRef TD);
223e47cc	214
970d7e83 LB	215	/** Returns the pointer size in bytes for a target for a specified
	216	address space.
	217	See the method llvm::DataLayout::getPointerSize. */
1a4d82fc	218	unsigned LLVMPointerSizeForAS(LLVMTargetDataRef TD, unsigned AS);
970d7e83	219
223e47cc	220	/** Returns the integer type that is the same size as a pointer on a target.
970d7e83	221	See the method llvm::DataLayout::getIntPtrType. */
1a4d82fc	222	LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef TD);
223e47cc	223
970d7e83 LB	224	/** Returns the integer type that is the same size as a pointer on a target.
	225	This version allows the address space to be specified.
	226	See the method llvm::DataLayout::getIntPtrType. */
1a4d82fc JJ	227	LLVMTypeRef LLVMIntPtrTypeForAS(LLVMTargetDataRef TD, unsigned AS);
	228
	229	/** Returns the integer type that is the same size as a pointer on a target.
	230	See the method llvm::DataLayout::getIntPtrType. */
	231	LLVMTypeRef LLVMIntPtrTypeInContext(LLVMContextRef C, LLVMTargetDataRef TD);
	232
	233	/** Returns the integer type that is the same size as a pointer on a target.
	234	This version allows the address space to be specified.
	235	See the method llvm::DataLayout::getIntPtrType. */
	236	LLVMTypeRef LLVMIntPtrTypeForASInContext(LLVMContextRef C, LLVMTargetDataRef TD,
	237	unsigned AS);
970d7e83	238
223e47cc	239	/** Computes the size of a type in bytes for a target.
970d7e83	240	See the method llvm::DataLayout::getTypeSizeInBits. */
1a4d82fc	241	unsigned long long LLVMSizeOfTypeInBits(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	242
223e47cc LB	243	/** Computes the storage size of a type in bytes for a target.
970d7e83	244	See the method llvm::DataLayout::getTypeStoreSize. */
1a4d82fc	245	unsigned long long LLVMStoreSizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	246
223e47cc LB	247	/** Computes the ABI size of a type in bytes for a target.
970d7e83	248	See the method llvm::DataLayout::getTypeAllocSize. */
1a4d82fc	249	unsigned long long LLVMABISizeOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	250
223e47cc LB	251	/** Computes the ABI alignment of a type in bytes for a target.
970d7e83	252	See the method llvm::DataLayout::getTypeABISize. */
1a4d82fc	253	unsigned LLVMABIAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	254
223e47cc LB	255	/** Computes the call frame alignment of a type in bytes for a target.
970d7e83	256	See the method llvm::DataLayout::getTypeABISize. */
1a4d82fc	257	unsigned LLVMCallFrameAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	258
223e47cc LB	259	/** Computes the preferred alignment of a type in bytes for a target.
970d7e83	260	See the method llvm::DataLayout::getTypeABISize. */
1a4d82fc	261	unsigned LLVMPreferredAlignmentOfType(LLVMTargetDataRef TD, LLVMTypeRef Ty);
223e47cc LB	262
223e47cc LB	263	/** Computes the preferred alignment of a global variable in bytes for a target.
970d7e83	264	See the method llvm::DataLayout::getPreferredAlignment. */
1a4d82fc	265	unsigned LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef TD,
223e47cc LB	266	LLVMValueRef GlobalVar);
	267
	268	/** Computes the structure element that contains the byte offset for a target.
	269	See the method llvm::StructLayout::getElementContainingOffset. */
1a4d82fc	270	unsigned LLVMElementAtOffset(LLVMTargetDataRef TD, LLVMTypeRef StructTy,
223e47cc LB	271	unsigned long long Offset);
	272
	273	/** Computes the byte offset of the indexed struct element for a target.
	274	See the method llvm::StructLayout::getElementContainingOffset. */
1a4d82fc JJ	275	unsigned long long LLVMOffsetOfElement(LLVMTargetDataRef TD,
1a4d82fc JJ	276	LLVMTypeRef StructTy, unsigned Element);
223e47cc LB	277
223e47cc LB	278	/** Deallocates a TargetData.
970d7e83	279	See the destructor llvm::DataLayout::~DataLayout. */
1a4d82fc	280	void LLVMDisposeTargetData(LLVMTargetDataRef TD);
223e47cc LB	281
	282	/**
	283	* @}
	284	*/
	285
	286	#ifdef __cplusplus
	287	}
223e47cc LB	288	#endif /* defined(__cplusplus) */
	289
	290	#endif