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