llvm/include/llvm-c/TargetMachine.h

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