1 /*===-- llvm-c/TargetMachine.h - Target Machine Library C Interface - 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 the Target and TargetMachine *| 11 |* classes, which can be used to generate assembly or object files. *| 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_TARGETMACHINE_H 20 #define LLVM_C_TARGETMACHINE_H 21 22 #include "llvm-c/ExternC.h" 23 #include "llvm-c/Target.h" 24 #include "llvm-c/Types.h" 25 #include "llvm-c/Visibility.h" 26 27 LLVM_C_EXTERN_C_BEGIN 28 29 /** 30 * @addtogroup LLVMCTarget 31 * 32 * @{ 33 */ 34 35 typedef struct LLVMOpaqueTargetMachineOptions *LLVMTargetMachineOptionsRef; 36 typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef; 37 typedef struct LLVMTarget *LLVMTargetRef; 38 39 typedef enum { 40 LLVMCodeGenLevelNone, 41 LLVMCodeGenLevelLess, 42 LLVMCodeGenLevelDefault, 43 LLVMCodeGenLevelAggressive 44 } LLVMCodeGenOptLevel; 45 46 typedef enum { 47 LLVMRelocDefault, 48 LLVMRelocStatic, 49 LLVMRelocPIC, 50 LLVMRelocDynamicNoPic, 51 LLVMRelocROPI, 52 LLVMRelocRWPI, 53 LLVMRelocROPI_RWPI 54 } LLVMRelocMode; 55 56 typedef enum { 57 LLVMCodeModelDefault, 58 LLVMCodeModelJITDefault, 59 LLVMCodeModelTiny, 60 LLVMCodeModelSmall, 61 LLVMCodeModelKernel, 62 LLVMCodeModelMedium, 63 LLVMCodeModelLarge 64 } LLVMCodeModel; 65 66 typedef enum { 67 LLVMAssemblyFile, 68 LLVMObjectFile 69 } LLVMCodeGenFileType; 70 71 typedef enum { 72 LLVMGlobalISelAbortEnable, 73 LLVMGlobalISelAbortDisable, 74 LLVMGlobalISelAbortDisableWithDiag, 75 } LLVMGlobalISelAbortMode; 76 77 /** Returns the first llvm::Target in the registered targets list. */ 78 LLVM_C_ABI LLVMTargetRef LLVMGetFirstTarget(void); 79 /** Returns the next llvm::Target given a previous one (or null if there's none) */ 80 LLVM_C_ABI LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T); 81 82 /*===-- Target ------------------------------------------------------------===*/ 83 /** Finds the target corresponding to the given name and stores it in \p T. 84 Returns 0 on success. */ 85 LLVM_C_ABI LLVMTargetRef LLVMGetTargetFromName(const char *Name); 86 87 /** Finds the target corresponding to the given triple and stores it in \p T. 88 Returns 0 on success. Optionally returns any error in ErrorMessage. 89 Use LLVMDisposeMessage to dispose the message. */ 90 LLVM_C_ABI LLVMBool LLVMGetTargetFromTriple(const char *Triple, 91 LLVMTargetRef *T, 92 char **ErrorMessage); 93 94 /** Returns the name of a target. See llvm::Target::getName */ 95 LLVM_C_ABI const char *LLVMGetTargetName(LLVMTargetRef T); 96 97 /** Returns the description of a target. See llvm::Target::getDescription */ 98 LLVM_C_ABI const char *LLVMGetTargetDescription(LLVMTargetRef T); 99 100 /** Returns if the target has a JIT */ 101 LLVM_C_ABI LLVMBool LLVMTargetHasJIT(LLVMTargetRef T); 102 103 /** Returns if the target has a TargetMachine associated */ 104 LLVM_C_ABI LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T); 105 106 /** Returns if the target as an ASM backend (required for emitting output) */ 107 LLVM_C_ABI LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T); 108 109 /*===-- Target Machine ----------------------------------------------------===*/ 110 /** 111 * Create a new set of options for an llvm::TargetMachine. 112 * 113 * The returned option structure must be released with 114 * LLVMDisposeTargetMachineOptions() after the call to 115 * LLVMCreateTargetMachineWithOptions(). 116 */ 117 LLVM_C_ABI LLVMTargetMachineOptionsRef LLVMCreateTargetMachineOptions(void); 118 119 /** 120 * Dispose of an LLVMTargetMachineOptionsRef instance. 121 */ 122 LLVM_C_ABI void 123 LLVMDisposeTargetMachineOptions(LLVMTargetMachineOptionsRef Options); 124 125 LLVM_C_ABI void 126 LLVMTargetMachineOptionsSetCPU(LLVMTargetMachineOptionsRef Options, 127 const char *CPU); 128 129 /** 130 * Set the list of features for the target machine. 131 * 132 * \param Features a comma-separated list of features. 133 */ 134 LLVM_C_ABI void 135 LLVMTargetMachineOptionsSetFeatures(LLVMTargetMachineOptionsRef Options, 136 const char *Features); 137 138 LLVM_C_ABI void 139 LLVMTargetMachineOptionsSetABI(LLVMTargetMachineOptionsRef Options, 140 const char *ABI); 141 142 LLVM_C_ABI void 143 LLVMTargetMachineOptionsSetCodeGenOptLevel(LLVMTargetMachineOptionsRef Options, 144 LLVMCodeGenOptLevel Level); 145 146 LLVM_C_ABI void 147 LLVMTargetMachineOptionsSetRelocMode(LLVMTargetMachineOptionsRef Options, 148 LLVMRelocMode Reloc); 149 150 LLVM_C_ABI void 151 LLVMTargetMachineOptionsSetCodeModel(LLVMTargetMachineOptionsRef Options, 152 LLVMCodeModel CodeModel); 153 154 /** 155 * Create a new llvm::TargetMachine. 156 * 157 * \param T the target to create a machine for. 158 * \param Triple a triple describing the target machine. 159 * \param Options additional configuration (see 160 * LLVMCreateTargetMachineOptions()). 161 */ 162 LLVM_C_ABI LLVMTargetMachineRef LLVMCreateTargetMachineWithOptions( 163 LLVMTargetRef T, const char *Triple, LLVMTargetMachineOptionsRef Options); 164 165 /** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */ 166 LLVM_C_ABI LLVMTargetMachineRef LLVMCreateTargetMachine( 167 LLVMTargetRef T, const char *Triple, const char *CPU, const char *Features, 168 LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel); 169 170 /** Dispose the LLVMTargetMachineRef instance generated by 171 LLVMCreateTargetMachine. */ 172 LLVM_C_ABI void LLVMDisposeTargetMachine(LLVMTargetMachineRef T); 173 174 /** Returns the Target used in a TargetMachine */ 175 LLVM_C_ABI LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T); 176 177 /** Returns the triple used creating this target machine. See 178 llvm::TargetMachine::getTriple. The result needs to be disposed with 179 LLVMDisposeMessage. */ 180 LLVM_C_ABI char *LLVMGetTargetMachineTriple(LLVMTargetMachineRef T); 181 182 /** Returns the cpu used creating this target machine. See 183 llvm::TargetMachine::getCPU. The result needs to be disposed with 184 LLVMDisposeMessage. */ 185 LLVM_C_ABI char *LLVMGetTargetMachineCPU(LLVMTargetMachineRef T); 186 187 /** Returns the feature string used creating this target machine. See 188 llvm::TargetMachine::getFeatureString. The result needs to be disposed with 189 LLVMDisposeMessage. */ 190 LLVM_C_ABI char *LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T); 191 192 /** Create a DataLayout based on the targetMachine. */ 193 LLVM_C_ABI LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T); 194 195 /** Set the target machine's ASM verbosity. */ 196 LLVM_C_ABI void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T, 197 LLVMBool VerboseAsm); 198 199 /** Enable fast-path instruction selection. */ 200 LLVM_C_ABI void LLVMSetTargetMachineFastISel(LLVMTargetMachineRef T, 201 LLVMBool Enable); 202 203 /** Enable global instruction selection. */ 204 LLVM_C_ABI void LLVMSetTargetMachineGlobalISel(LLVMTargetMachineRef T, 205 LLVMBool Enable); 206 207 /** Set abort behaviour when global instruction selection fails to lower/select 208 * an instruction. */ 209 LLVM_C_ABI void 210 LLVMSetTargetMachineGlobalISelAbort(LLVMTargetMachineRef T, 211 LLVMGlobalISelAbortMode Mode); 212 213 /** Enable the MachineOutliner pass. */ 214 LLVM_C_ABI void LLVMSetTargetMachineMachineOutliner(LLVMTargetMachineRef T, 215 LLVMBool Enable); 216 217 /** Emits an asm or object file for the given module to the filename. This 218 wraps several c++ only classes (among them a file stream). Returns any 219 error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */ 220 LLVM_C_ABI LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, 221 LLVMModuleRef M, 222 const char *Filename, 223 LLVMCodeGenFileType codegen, 224 char **ErrorMessage); 225 226 /** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */ 227 LLVM_C_ABI LLVMBool LLVMTargetMachineEmitToMemoryBuffer( 228 LLVMTargetMachineRef T, LLVMModuleRef M, LLVMCodeGenFileType codegen, 229 char **ErrorMessage, LLVMMemoryBufferRef *OutMemBuf); 230 231 /*===-- Triple ------------------------------------------------------------===*/ 232 /** Get a triple for the host machine as a string. The result needs to be 233 disposed with LLVMDisposeMessage. */ 234 LLVM_C_ABI char *LLVMGetDefaultTargetTriple(void); 235 236 /** Normalize a target triple. The result needs to be disposed with 237 LLVMDisposeMessage. */ 238 LLVM_C_ABI char *LLVMNormalizeTargetTriple(const char *triple); 239 240 /** Get the host CPU as a string. The result needs to be disposed with 241 LLVMDisposeMessage. */ 242 LLVM_C_ABI char *LLVMGetHostCPUName(void); 243 244 /** Get the host CPU's features as a string. The result needs to be disposed 245 with LLVMDisposeMessage. */ 246 LLVM_C_ABI char *LLVMGetHostCPUFeatures(void); 247 248 /** Adds the target-specific analysis passes to the pass manager. */ 249 LLVM_C_ABI void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, 250 LLVMPassManagerRef PM); 251 252 /** 253 * @} 254 */ 255 256 LLVM_C_EXTERN_C_END 257 258 #endif 259