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/Core.h" 15#include "llvm-c/Target.h" 16#include "llvm-c/TargetMachine.h" 17#include "llvm/Target/TargetData.h" 18#include "llvm/Target/TargetMachine.h" 19#include "llvm/Support/TargetRegistry.h" 20#include "llvm/Support/raw_ostream.h" 21#include "llvm/Support/CodeGen.h" 22#include "llvm/Support/FormattedStream.h" 23#include "llvm/Module.h" 24#include "llvm/PassManager.h" 25#include <cassert> 26#include <cstdlib> 27#include <cstring> 28 29using namespace llvm; 30 31 32 33LLVMTargetRef LLVMGetFirstTarget() { 34 const Target* target = &*TargetRegistry::begin(); 35 return wrap(target); 36} 37LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) { 38 return wrap(unwrap(T)->getNext()); 39} 40 41const char * LLVMGetTargetName(LLVMTargetRef T) { 42 return unwrap(T)->getName(); 43} 44 45const char * LLVMGetTargetDescription(LLVMTargetRef T) { 46 return unwrap(T)->getShortDescription(); 47} 48 49LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) { 50 return unwrap(T)->hasJIT(); 51} 52 53LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) { 54 return unwrap(T)->hasTargetMachine(); 55} 56 57LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) { 58 return unwrap(T)->hasMCAsmBackend(); 59} 60 61LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T, char* Triple, 62 char* CPU, char* Features, LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, 63 LLVMCodeModel CodeModel) { 64 Reloc::Model RM; 65 switch (Reloc){ 66 case LLVMRelocStatic: 67 RM = Reloc::Static; 68 break; 69 case LLVMRelocPIC: 70 RM = Reloc::PIC_; 71 break; 72 case LLVMRelocDynamicNoPic: 73 RM = Reloc::DynamicNoPIC; 74 break; 75 default: 76 RM = Reloc::Default; 77 break; 78 } 79 80 CodeModel::Model CM; 81 switch (CodeModel) { 82 case LLVMCodeModelJITDefault: 83 CM = CodeModel::JITDefault; 84 break; 85 case LLVMCodeModelSmall: 86 CM = CodeModel::Small; 87 break; 88 case LLVMCodeModelKernel: 89 CM = CodeModel::Kernel; 90 break; 91 case LLVMCodeModelMedium: 92 CM = CodeModel::Medium; 93 break; 94 case LLVMCodeModelLarge: 95 CM = CodeModel::Large; 96 break; 97 default: 98 CM = CodeModel::Default; 99 break; 100 } 101 CodeGenOpt::Level OL; 102 103 switch (Level) { 104 case LLVMCodeGenLevelNone: 105 OL = CodeGenOpt::None; 106 break; 107 case LLVMCodeGenLevelLess: 108 OL = CodeGenOpt::Less; 109 break; 110 case LLVMCodeGenLevelAggressive: 111 OL = CodeGenOpt::Aggressive; 112 break; 113 default: 114 OL = CodeGenOpt::Default; 115 break; 116 } 117 118 TargetOptions opt; 119 return wrap(unwrap(T)->createTargetMachine(Triple, CPU, Features, opt, RM, 120 CM, OL)); 121} 122 123 124void LLVMDisposeTargetMachine(LLVMTargetMachineRef T) { 125 delete unwrap(T); 126} 127 128LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T) { 129 const Target* target = &(unwrap(T)->getTarget()); 130 return wrap(target); 131} 132 133char* LLVMGetTargetMachineTriple(LLVMTargetMachineRef T) { 134 std::string StringRep = unwrap(T)->getTargetTriple(); 135 return strdup(StringRep.c_str()); 136} 137 138char* LLVMGetTargetMachineCPU(LLVMTargetMachineRef T) { 139 std::string StringRep = unwrap(T)->getTargetCPU(); 140 return strdup(StringRep.c_str()); 141} 142 143char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) { 144 std::string StringRep = unwrap(T)->getTargetFeatureString(); 145 return strdup(StringRep.c_str()); 146} 147 148LLVMTargetDataRef LLVMGetTargetMachineData(LLVMTargetMachineRef T) { 149 return wrap(unwrap(T)->getTargetData()); 150} 151 152LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M, 153 char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) { 154 TargetMachine* TM = unwrap(T); 155 Module* Mod = unwrap(M); 156 157 PassManager pass; 158 159 std::string error; 160 161 const TargetData* td = TM->getTargetData(); 162 163 if (!td) { 164 error = "No TargetData in TargetMachine"; 165 *ErrorMessage = strdup(error.c_str()); 166 return true; 167 } 168 pass.add(new TargetData(*td)); 169 170 TargetMachine::CodeGenFileType ft; 171 switch (codegen) { 172 case LLVMAssemblyFile: 173 ft = TargetMachine::CGFT_AssemblyFile; 174 break; 175 default: 176 ft = TargetMachine::CGFT_ObjectFile; 177 break; 178 } 179 raw_fd_ostream dest(Filename, error, raw_fd_ostream::F_Binary); 180 formatted_raw_ostream destf(dest); 181 if (!error.empty()) { 182 *ErrorMessage = strdup(error.c_str()); 183 return true; 184 } 185 186 if (TM->addPassesToEmitFile(pass, destf, ft)) { 187 error = "No TargetData in TargetMachine"; 188 *ErrorMessage = strdup(error.c_str()); 189 return true; 190 } 191 192 pass.run(*Mod); 193 194 destf.flush(); 195 dest.flush(); 196 return false; 197} 198