lib/Target/TargetMachineC.cpp

   1 //===-- TargetMachine.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the LLVM-C part of TargetMachine.h
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm-c/Core.h"
  14 #include "llvm-c/Target.h"
  15 #include "llvm-c/TargetMachine.h"
  16 #include "llvm/Analysis/TargetTransformInfo.h"
  17 #include "llvm/IR/DataLayout.h"
  18 #include "llvm/IR/LegacyPassManager.h"
  19 #include "llvm/IR/Module.h"
  20 #include "llvm/MC/SubtargetFeature.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/FormattedStream.h"
  23 #include "llvm/Support/Host.h"
  24 #include "llvm/Support/TargetRegistry.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "llvm/Target/CodeGenCWrappers.h"
  27 #include "llvm/Target/TargetMachine.h"
  28 #include <cassert>
  29 #include <cstdlib>
  30 #include <cstring>
  31
  32 using namespace llvm;
  33
  34 static TargetMachine *unwrap(LLVMTargetMachineRef P) {
  35   return reinterpret_cast<TargetMachine *>(P);
  36 }
  37 static Target *unwrap(LLVMTargetRef P) {
  38   return reinterpret_cast<Target*>(P);
  39 }
  40 static LLVMTargetMachineRef wrap(const TargetMachine *P) {
  41   return reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine *>(P));
  42 }
  43 static LLVMTargetRef wrap(const Target * P) {
  44   return reinterpret_cast<LLVMTargetRef>(const_cast<Target*>(P));
  45 }
  46
  47 LLVMTargetRef LLVMGetFirstTarget() {
  48   if (TargetRegistry::targets().begin() == TargetRegistry::targets().end()) {
  49     return nullptr;
  50   }
  51
  52   const Target *target = &*TargetRegistry::targets().begin();
  53   return wrap(target);
  54 }
  55 LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) {
  56   return wrap(unwrap(T)->getNext());
  57 }
  58
  59 LLVMTargetRef LLVMGetTargetFromName(const char *Name) {
  60   StringRef NameRef = Name;
  61   auto I = find_if(TargetRegistry::targets(),
  62                    [&](const Target &T) { return T.getName() == NameRef; });
  63   return I != TargetRegistry::targets().end() ? wrap(&*I) : nullptr;
  64 }
  65
  66 LLVMBool LLVMGetTargetFromTriple(const char* TripleStr, LLVMTargetRef *T,
  67                                  char **ErrorMessage) {
  68   std::string Error;
  69
  70   *T = wrap(TargetRegistry::lookupTarget(TripleStr, Error));
  71
  72   if (!*T) {
  73     if (ErrorMessage)
  74       *ErrorMessage = strdup(Error.c_str());
  75
  76     return 1;
  77   }
  78
  79   return 0;
  80 }
  81
  82 const char * LLVMGetTargetName(LLVMTargetRef T) {
  83   return unwrap(T)->getName();
  84 }
  85
  86 const char * LLVMGetTargetDescription(LLVMTargetRef T) {
  87   return unwrap(T)->getShortDescription();
  88 }
  89
  90 LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) {
  91   return unwrap(T)->hasJIT();
  92 }
  93
  94 LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
  95   return unwrap(T)->hasTargetMachine();
  96 }
  97
  98 LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
  99   return unwrap(T)->hasMCAsmBackend();
 100 }
 101
 102 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
 103         const char *Triple, const char *CPU, const char *Features,
 104         LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
 105         LLVMCodeModel CodeModel) {
 106   Optional<Reloc::Model> RM;
 107   switch (Reloc){
 108     case LLVMRelocStatic:
 109       RM = Reloc::Static;
 110       break;
 111     case LLVMRelocPIC:
 112       RM = Reloc::PIC_;
 113       break;
 114     case LLVMRelocDynamicNoPic:
 115       RM = Reloc::DynamicNoPIC;
 116       break;
 117     case LLVMRelocROPI:
 118       RM = Reloc::ROPI;
 119       break;
 120     case LLVMRelocRWPI:
 121       RM = Reloc::RWPI;
 122       break;
 123     case LLVMRelocROPI_RWPI:
 124       RM = Reloc::ROPI_RWPI;
 125       break;
 126     default:
 127       break;
 128   }
 129
 130   bool JIT;
 131   Optional<CodeModel::Model> CM = unwrap(CodeModel, JIT);
 132
 133   CodeGenOpt::Level OL;
 134   switch (Level) {
 135     case LLVMCodeGenLevelNone:
 136       OL = CodeGenOpt::None;
 137       break;
 138     case LLVMCodeGenLevelLess:
 139       OL = CodeGenOpt::Less;
 140       break;
 141     case LLVMCodeGenLevelAggressive:
 142       OL = CodeGenOpt::Aggressive;
 143       break;
 144     default:
 145       OL = CodeGenOpt::Default;
 146       break;
 147   }
 148
 149   TargetOptions opt;
 150   return wrap(unwrap(T)->createTargetMachine(Triple, CPU, Features, opt, RM, CM,
 151                                              OL, JIT));
 152 }
 153
 154 void LLVMDisposeTargetMachine(LLVMTargetMachineRef T) { delete unwrap(T); }
 155
 156 LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T) {
 157   const Target* target = &(unwrap(T)->getTarget());
 158   return wrap(target);
 159 }
 160
 161 char* LLVMGetTargetMachineTriple(LLVMTargetMachineRef T) {
 162   std::string StringRep = unwrap(T)->getTargetTriple().str();
 163   return strdup(StringRep.c_str());
 164 }
 165
 166 char* LLVMGetTargetMachineCPU(LLVMTargetMachineRef T) {
 167   std::string StringRep = unwrap(T)->getTargetCPU();
 168   return strdup(StringRep.c_str());
 169 }
 170
 171 char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) {
 172   std::string StringRep = unwrap(T)->getTargetFeatureString();
 173   return strdup(StringRep.c_str());
 174 }
 175
 176 void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
 177                                       LLVMBool VerboseAsm) {
 178   unwrap(T)->Options.MCOptions.AsmVerbose = VerboseAsm;
 179 }
 180
 181 LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T) {
 182   return wrap(new DataLayout(unwrap(T)->createDataLayout()));
 183 }
 184
 185 static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
 186                                       raw_pwrite_stream &OS,
 187                                       LLVMCodeGenFileType codegen,
 188                                       char **ErrorMessage) {
 189   TargetMachine* TM = unwrap(T);
 190   Module* Mod = unwrap(M);
 191
 192   legacy::PassManager pass;
 193
 194   std::string error;
 195
 196   Mod->setDataLayout(TM->createDataLayout());
 197
 198   TargetMachine::CodeGenFileType ft;
 199   switch (codegen) {
 200     case LLVMAssemblyFile:
 201       ft = TargetMachine::CGFT_AssemblyFile;
 202       break;
 203     default:
 204       ft = TargetMachine::CGFT_ObjectFile;
 205       break;
 206   }
 207   if (TM->addPassesToEmitFile(pass, OS, nullptr, ft)) {
 208     error = "TargetMachine can't emit a file of this type";
 209     *ErrorMessage = strdup(error.c_str());
 210     return true;
 211   }
 212
 213   pass.run(*Mod);
 214
 215   OS.flush();
 216   return false;
 217 }
 218
 219 LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
 220   char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) {
 221   std::error_code EC;
 222   raw_fd_ostream dest(Filename, EC, sys::fs::F_None);
 223   if (EC) {
 224     *ErrorMessage = strdup(EC.message().c_str());
 225     return true;
 226   }
 227   bool Result = LLVMTargetMachineEmit(T, M, dest, codegen, ErrorMessage);
 228   dest.flush();
 229   return Result;
 230 }
 231
 232 LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
 233   LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
 234   LLVMMemoryBufferRef *OutMemBuf) {
 235   SmallString<0> CodeString;
 236   raw_svector_ostream OStream(CodeString);
 237   bool Result = LLVMTargetMachineEmit(T, M, OStream, codegen, ErrorMessage);
 238
 239   StringRef Data = OStream.str();
 240   *OutMemBuf =
 241       LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.data(), Data.size(), "");
 242   return Result;
 243 }
 244
 245 char *LLVMGetDefaultTargetTriple(void) {
 246   return strdup(sys::getDefaultTargetTriple().c_str());
 247 }
 248
 249 char *LLVMNormalizeTargetTriple(const char* triple) {
 250   return strdup(Triple::normalize(StringRef(triple)).c_str());
 251 }
 252
 253 char *LLVMGetHostCPUName(void) {
 254   return strdup(sys::getHostCPUName().data());
 255 }
 256
 257 char *LLVMGetHostCPUFeatures(void) {
 258   SubtargetFeatures Features;
 259   StringMap<bool> HostFeatures;
 260
 261   if (sys::getHostCPUFeatures(HostFeatures))
 262     for (auto &F : HostFeatures)
 263       Features.AddFeature(F.first(), F.second);
 264
 265   return strdup(Features.getString().c_str());
 266 }
 267
 268 void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM) {
 269   unwrap(PM)->add(
 270       createTargetTransformInfoWrapperPass(unwrap(T)->getTargetIRAnalysis()));
 271 }