lib/Target/TargetMachineC.cpp

   1 //===-- TargetMachine.cpp -------------------------------------------------===//
   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 file implements the LLVM-C part of TargetMachine.h
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm-c/TargetMachine.h"
  15 #include "llvm-c/Core.h"
  16 #include "llvm-c/Target.h"
  17 #include "llvm/IR/DataLayout.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/PassManager.h"
  20 #include "llvm/Support/CodeGen.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/TargetMachine.h"
  27 #include <cassert>
  28 #include <cstdlib>
  29 #include <cstring>
  30
  31 using namespace llvm;
  32
  33 inline DataLayout *unwrap(LLVMTargetDataRef P) {
  34   return reinterpret_cast<DataLayout*>(P);
  35 }
  36
  37 inline LLVMTargetDataRef wrap(const DataLayout *P) {
  38   return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
  39 }
  40
  41 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
  42   return reinterpret_cast<TargetLibraryInfo*>(P);
  43 }
  44
  45 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
  46   TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
  47   return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
  48 }
  49
  50 inline TargetMachine *unwrap(LLVMTargetMachineRef P) {
  51   return reinterpret_cast<TargetMachine*>(P);
  52 }
  53 inline Target *unwrap(LLVMTargetRef P) {
  54   return reinterpret_cast<Target*>(P);
  55 }
  56 inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
  57   return
  58     reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
  59 }
  60 inline LLVMTargetRef wrap(const Target * P) {
  61   return reinterpret_cast<LLVMTargetRef>(const_cast<Target*>(P));
  62 }
  63
  64 LLVMTargetRef LLVMGetFirstTarget() {
  65   if(TargetRegistry::begin() == TargetRegistry::end()) {
  66     return nullptr;
  67   }
  68
  69   const Target* target = &*TargetRegistry::begin();
  70   return wrap(target);
  71 }
  72 LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) {
  73   return wrap(unwrap(T)->getNext());
  74 }
  75
  76 LLVMTargetRef LLVMGetTargetFromName(const char *Name) {
  77   StringRef NameRef = Name;
  78   for (TargetRegistry::iterator IT = TargetRegistry::begin(),
  79                                 IE = TargetRegistry::end(); IT != IE; ++IT) {
  80     if (IT->getName() == NameRef)
  81       return wrap(&*IT);
  82   }
  83
  84   return nullptr;
  85 }
  86
  87 LLVMBool LLVMGetTargetFromTriple(const char* TripleStr, LLVMTargetRef *T,
  88                                  char **ErrorMessage) {
  89   std::string Error;
  90
  91   *T = wrap(TargetRegistry::lookupTarget(TripleStr, Error));
  92
  93   if (!*T) {
  94     if (ErrorMessage)
  95       *ErrorMessage = strdup(Error.c_str());
  96
  97     return 1;
  98   }
  99
 100   return 0;
 101 }
 102
 103 const char * LLVMGetTargetName(LLVMTargetRef T) {
 104   return unwrap(T)->getName();
 105 }
 106
 107 const char * LLVMGetTargetDescription(LLVMTargetRef T) {
 108   return unwrap(T)->getShortDescription();
 109 }
 110
 111 LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) {
 112   return unwrap(T)->hasJIT();
 113 }
 114
 115 LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
 116   return unwrap(T)->hasTargetMachine();
 117 }
 118
 119 LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
 120   return unwrap(T)->hasMCAsmBackend();
 121 }
 122
 123 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
 124         const char* Triple, const char* CPU, const char* Features,
 125         LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
 126         LLVMCodeModel CodeModel) {
 127   Reloc::Model RM;
 128   switch (Reloc){
 129     case LLVMRelocStatic:
 130       RM = Reloc::Static;
 131       break;
 132     case LLVMRelocPIC:
 133       RM = Reloc::PIC_;
 134       break;
 135     case LLVMRelocDynamicNoPic:
 136       RM = Reloc::DynamicNoPIC;
 137       break;
 138     default:
 139       RM = Reloc::Default;
 140       break;
 141   }
 142
 143   CodeModel::Model CM = unwrap(CodeModel);
 144
 145   CodeGenOpt::Level OL;
 146   switch (Level) {
 147     case LLVMCodeGenLevelNone:
 148       OL = CodeGenOpt::None;
 149       break;
 150     case LLVMCodeGenLevelLess:
 151       OL = CodeGenOpt::Less;
 152       break;
 153     case LLVMCodeGenLevelAggressive:
 154       OL = CodeGenOpt::Aggressive;
 155       break;
 156     default:
 157       OL = CodeGenOpt::Default;
 158       break;
 159   }
 160
 161   TargetOptions opt;
 162   return wrap(unwrap(T)->createTargetMachine(Triple, CPU, Features, opt, RM,
 163     CM, OL));
 164 }
 165
 166
 167 void LLVMDisposeTargetMachine(LLVMTargetMachineRef T) {
 168   delete unwrap(T);
 169 }
 170
 171 LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T) {
 172   const Target* target = &(unwrap(T)->getTarget());
 173   return wrap(target);
 174 }
 175
 176 char* LLVMGetTargetMachineTriple(LLVMTargetMachineRef T) {
 177   std::string StringRep = unwrap(T)->getTargetTriple();
 178   return strdup(StringRep.c_str());
 179 }
 180
 181 char* LLVMGetTargetMachineCPU(LLVMTargetMachineRef T) {
 182   std::string StringRep = unwrap(T)->getTargetCPU();
 183   return strdup(StringRep.c_str());
 184 }
 185
 186 char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) {
 187   std::string StringRep = unwrap(T)->getTargetFeatureString();
 188   return strdup(StringRep.c_str());
 189 }
 190
 191 LLVMTargetDataRef LLVMGetTargetMachineData(LLVMTargetMachineRef T) {
 192   return wrap(unwrap(T)->getDataLayout());
 193 }
 194
 195 void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
 196                                       LLVMBool VerboseAsm) {
 197   unwrap(T)->setAsmVerbosityDefault(VerboseAsm);
 198 }
 199
 200 static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
 201   formatted_raw_ostream &OS, LLVMCodeGenFileType codegen, char **ErrorMessage) {
 202   TargetMachine* TM = unwrap(T);
 203   Module* Mod = unwrap(M);
 204
 205   PassManager pass;
 206
 207   std::string error;
 208
 209   const DataLayout* td = TM->getDataLayout();
 210
 211   if (!td) {
 212     error = "No DataLayout in TargetMachine";
 213     *ErrorMessage = strdup(error.c_str());
 214     return true;
 215   }
 216   Mod->setDataLayout(td);
 217   pass.add(new DataLayoutPass(Mod));
 218
 219   TargetMachine::CodeGenFileType ft;
 220   switch (codegen) {
 221     case LLVMAssemblyFile:
 222       ft = TargetMachine::CGFT_AssemblyFile;
 223       break;
 224     default:
 225       ft = TargetMachine::CGFT_ObjectFile;
 226       break;
 227   }
 228   if (TM->addPassesToEmitFile(pass, OS, ft)) {
 229     error = "TargetMachine can't emit a file of this type";
 230     *ErrorMessage = strdup(error.c_str());
 231     return true;
 232   }
 233
 234   pass.run(*Mod);
 235
 236   OS.flush();
 237   return false;
 238 }
 239
 240 LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
 241   char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) {
 242   std::string error;
 243   raw_fd_ostream dest(Filename, error, sys::fs::F_None);
 244   if (!error.empty()) {
 245     *ErrorMessage = strdup(error.c_str());
 246     return true;
 247   }
 248   formatted_raw_ostream destf(dest);
 249   bool Result = LLVMTargetMachineEmit(T, M, destf, codegen, ErrorMessage);
 250   dest.flush();
 251   return Result;
 252 }
 253
 254 LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
 255   LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
 256   LLVMMemoryBufferRef *OutMemBuf) {
 257   std::string CodeString;
 258   raw_string_ostream OStream(CodeString);
 259   formatted_raw_ostream Out(OStream);
 260   bool Result = LLVMTargetMachineEmit(T, M, Out, codegen, ErrorMessage);
 261   OStream.flush();
 262
 263   std::string &Data = OStream.str();
 264   *OutMemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.c_str(),
 265                                                      Data.length(), "");
 266   return Result;
 267 }
 268
 269 char *LLVMGetDefaultTargetTriple(void) {
 270   return strdup(sys::getDefaultTargetTriple().c_str());
 271 }
 272
 273 void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM) {
 274   unwrap(T)->addAnalysisPasses(*unwrap(PM));
 275 }