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/FormattedStream.h"
  22 #include "llvm/Support/TargetRegistry.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/Target/TargetMachine.h"
  25 #include <cassert>
  26 #include <cstdlib>
  27 #include <cstring>
  28
  29 using namespace llvm;
  30
  31 inline DataLayout *unwrap(LLVMTargetDataRef P) {
  32   return reinterpret_cast<DataLayout*>(P);
  33 }
  34
  35 inline LLVMTargetDataRef wrap(const DataLayout *P) {
  36   return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout*>(P));
  37 }
  38
  39 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
  40   return reinterpret_cast<TargetLibraryInfo*>(P);
  41 }
  42
  43 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
  44   TargetLibraryInfo *X = const_cast<TargetLibraryInfo*>(P);
  45   return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
  46 }
  47
  48 inline TargetMachine *unwrap(LLVMTargetMachineRef P) {
  49   return reinterpret_cast<TargetMachine*>(P);
  50 }
  51 inline Target *unwrap(LLVMTargetRef P) {
  52   return reinterpret_cast<Target*>(P);
  53 }
  54 inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
  55   return
  56     reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
  57 }
  58 inline LLVMTargetRef wrap(const Target * P) {
  59   return reinterpret_cast<LLVMTargetRef>(const_cast<Target*>(P));
  60 }
  61
  62 LLVMTargetRef LLVMGetFirstTarget() {
  63   if(TargetRegistry::begin() == TargetRegistry::end()) {
  64     return NULL;
  65   }
  66
  67   const Target* target = &*TargetRegistry::begin();
  68   return wrap(target);
  69 }
  70 LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) {
  71   return wrap(unwrap(T)->getNext());
  72 }
  73
  74 const char * LLVMGetTargetName(LLVMTargetRef T) {
  75   return unwrap(T)->getName();
  76 }
  77
  78 const char * LLVMGetTargetDescription(LLVMTargetRef T) {
  79   return unwrap(T)->getShortDescription();
  80 }
  81
  82 LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) {
  83   return unwrap(T)->hasJIT();
  84 }
  85
  86 LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
  87   return unwrap(T)->hasTargetMachine();
  88 }
  89
  90 LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
  91   return unwrap(T)->hasMCAsmBackend();
  92 }
  93
  94 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T, char* Triple,
  95   char* CPU, char* Features, LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
  96   LLVMCodeModel CodeModel) {
  97   Reloc::Model RM;
  98   switch (Reloc){
  99     case LLVMRelocStatic:
 100       RM = Reloc::Static;
 101       break;
 102     case LLVMRelocPIC:
 103       RM = Reloc::PIC_;
 104       break;
 105     case LLVMRelocDynamicNoPic:
 106       RM = Reloc::DynamicNoPIC;
 107       break;
 108     default:
 109       RM = Reloc::Default;
 110       break;
 111   }
 112
 113   CodeModel::Model CM = unwrap(CodeModel);
 114
 115   CodeGenOpt::Level OL;
 116   switch (Level) {
 117     case LLVMCodeGenLevelNone:
 118       OL = CodeGenOpt::None;
 119       break;
 120     case LLVMCodeGenLevelLess:
 121       OL = CodeGenOpt::Less;
 122       break;
 123     case LLVMCodeGenLevelAggressive:
 124       OL = CodeGenOpt::Aggressive;
 125       break;
 126     default:
 127       OL = CodeGenOpt::Default;
 128       break;
 129   }
 130
 131   TargetOptions opt;
 132   return wrap(unwrap(T)->createTargetMachine(Triple, CPU, Features, opt, RM,
 133     CM, OL));
 134 }
 135
 136
 137 void LLVMDisposeTargetMachine(LLVMTargetMachineRef T) {
 138   delete unwrap(T);
 139 }
 140
 141 LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T) {
 142   const Target* target = &(unwrap(T)->getTarget());
 143   return wrap(target);
 144 }
 145
 146 char* LLVMGetTargetMachineTriple(LLVMTargetMachineRef T) {
 147   std::string StringRep = unwrap(T)->getTargetTriple();
 148   return strdup(StringRep.c_str());
 149 }
 150
 151 char* LLVMGetTargetMachineCPU(LLVMTargetMachineRef T) {
 152   std::string StringRep = unwrap(T)->getTargetCPU();
 153   return strdup(StringRep.c_str());
 154 }
 155
 156 char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) {
 157   std::string StringRep = unwrap(T)->getTargetFeatureString();
 158   return strdup(StringRep.c_str());
 159 }
 160
 161 LLVMTargetDataRef LLVMGetTargetMachineData(LLVMTargetMachineRef T) {
 162   return wrap(unwrap(T)->getDataLayout());
 163 }
 164
 165 static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
 166   formatted_raw_ostream &OS, LLVMCodeGenFileType codegen, char **ErrorMessage) {
 167   TargetMachine* TM = unwrap(T);
 168   Module* Mod = unwrap(M);
 169
 170   PassManager pass;
 171
 172   std::string error;
 173
 174   const DataLayout* td = TM->getDataLayout();
 175
 176   if (!td) {
 177     error = "No DataLayout in TargetMachine";
 178     *ErrorMessage = strdup(error.c_str());
 179     return true;
 180   }
 181   pass.add(new DataLayout(*td));
 182
 183   TargetMachine::CodeGenFileType ft;
 184   switch (codegen) {
 185     case LLVMAssemblyFile:
 186       ft = TargetMachine::CGFT_AssemblyFile;
 187       break;
 188     default:
 189       ft = TargetMachine::CGFT_ObjectFile;
 190       break;
 191   }
 192   if (TM->addPassesToEmitFile(pass, OS, ft)) {
 193     error = "TargetMachine can't emit a file of this type";
 194     *ErrorMessage = strdup(error.c_str());
 195     return true;
 196   }
 197
 198   pass.run(*Mod);
 199
 200   OS.flush();
 201   return false;
 202 }
 203
 204 LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
 205   char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) {
 206   std::string error;
 207   raw_fd_ostream dest(Filename, error, sys::fs::F_Binary);
 208   if (!error.empty()) {
 209     *ErrorMessage = strdup(error.c_str());
 210     return true;
 211   }
 212   formatted_raw_ostream destf(dest);
 213   bool Result = LLVMTargetMachineEmit(T, M, destf, codegen, ErrorMessage);
 214   dest.flush();
 215   return Result;
 216 }
 217
 218 LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
 219   LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
 220   LLVMMemoryBufferRef *OutMemBuf) {
 221   std::string CodeString;
 222   raw_string_ostream OStream(CodeString);
 223   formatted_raw_ostream Out(OStream);
 224   bool Result = LLVMTargetMachineEmit(T, M, Out, codegen, ErrorMessage);
 225   OStream.flush();
 226
 227   std::string &Data = OStream.str();
 228   *OutMemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.c_str(),
 229                                                      Data.length(), "");
 230   return Result;
 231 }