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 }
232