1 //===-- LLVMTargetMachine.cpp - Implement the LLVMTargetMachine class -----===// 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 LLVMTargetMachine class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Transforms/Scalar.h" 15 #include "llvm/PassManager.h" 16 #include "llvm/CodeGen/AsmPrinter.h" 17 #include "llvm/CodeGen/Passes.h" 18 #include "llvm/CodeGen/MachineFunctionAnalysis.h" 19 #include "llvm/CodeGen/MachineModuleInfo.h" 20 #include "llvm/Target/TargetInstrInfo.h" 21 #include "llvm/Target/TargetLowering.h" 22 #include "llvm/Target/TargetLoweringObjectFile.h" 23 #include "llvm/Target/TargetMachine.h" 24 #include "llvm/Target/TargetOptions.h" 25 #include "llvm/Target/TargetSubtargetInfo.h" 26 #include "llvm/Target/TargetRegisterInfo.h" 27 #include "llvm/MC/MCAsmInfo.h" 28 #include "llvm/MC/MCContext.h" 29 #include "llvm/MC/MCInstrInfo.h" 30 #include "llvm/MC/MCStreamer.h" 31 #include "llvm/MC/MCSubtargetInfo.h" 32 #include "llvm/ADT/OwningPtr.h" 33 #include "llvm/Support/CommandLine.h" 34 #include "llvm/Support/FormattedStream.h" 35 #include "llvm/Support/ErrorHandling.h" 36 #include "llvm/Support/TargetRegistry.h" 37 using namespace llvm; 38 39 // Enable or disable FastISel. Both options are needed, because 40 // FastISel is enabled by default with -fast, and we wish to be 41 // able to enable or disable fast-isel independently from -O0. 42 static cl::opt<cl::boolOrDefault> 43 EnableFastISelOption("fast-isel", cl::Hidden, 44 cl::desc("Enable the \"fast\" instruction selector")); 45 46 static cl::opt<bool> ShowMCEncoding("show-mc-encoding", cl::Hidden, 47 cl::desc("Show encoding in .s output")); 48 static cl::opt<bool> ShowMCInst("show-mc-inst", cl::Hidden, 49 cl::desc("Show instruction structure in .s output")); 50 51 static cl::opt<cl::boolOrDefault> 52 AsmVerbose("asm-verbose", cl::desc("Add comments to directives."), 53 cl::init(cl::BOU_UNSET)); 54 55 static bool getVerboseAsm() { 56 switch (AsmVerbose) { 57 case cl::BOU_UNSET: return TargetMachine::getAsmVerbosityDefault(); 58 case cl::BOU_TRUE: return true; 59 case cl::BOU_FALSE: return false; 60 } 61 llvm_unreachable("Invalid verbose asm state"); 62 } 63 64 LLVMTargetMachine::LLVMTargetMachine(const Target &T, StringRef Triple, 65 StringRef CPU, StringRef FS, 66 TargetOptions Options, 67 Reloc::Model RM, CodeModel::Model CM, 68 CodeGenOpt::Level OL) 69 : TargetMachine(T, Triple, CPU, FS, Options) { 70 CodeGenInfo = T.createMCCodeGenInfo(Triple, RM, CM, OL); 71 AsmInfo = T.createMCAsmInfo(Triple); 72 // TargetSelect.h moved to a different directory between LLVM 2.9 and 3.0, 73 // and if the old one gets included then MCAsmInfo will be NULL and 74 // we'll crash later. 75 // Provide the user with a useful error message about what's wrong. 76 assert(AsmInfo && "MCAsmInfo not initialized." 77 "Make sure you include the correct TargetSelect.h" 78 "and that InitializeAllTargetMCs() is being invoked!"); 79 } 80 81 /// Turn exception handling constructs into something the code generators can 82 /// handle. 83 static void addPassesToHandleExceptions(TargetMachine *TM, 84 PassManagerBase &PM) { 85 switch (TM->getMCAsmInfo()->getExceptionHandlingType()) { 86 case ExceptionHandling::SjLj: 87 // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both 88 // Dwarf EH prepare needs to be run after SjLj prepare. Otherwise, 89 // catch info can get misplaced when a selector ends up more than one block 90 // removed from the parent invoke(s). This could happen when a landing 91 // pad is shared by multiple invokes and is also a target of a normal 92 // edge from elsewhere. 93 PM.add(createSjLjEHPreparePass(TM->getTargetLowering())); 94 // FALLTHROUGH 95 case ExceptionHandling::DwarfCFI: 96 case ExceptionHandling::ARM: 97 case ExceptionHandling::Win64: 98 PM.add(createDwarfEHPass(TM)); 99 break; 100 case ExceptionHandling::None: 101 PM.add(createLowerInvokePass(TM->getTargetLowering())); 102 103 // The lower invoke pass may create unreachable code. Remove it. 104 PM.add(createUnreachableBlockEliminationPass()); 105 break; 106 } 107 } 108 109 /// addPassesToX helper drives creation and initialization of TargetPassConfig. 110 static MCContext *addPassesToGenerateCode(LLVMTargetMachine *TM, 111 PassManagerBase &PM, 112 bool DisableVerify) { 113 // Targets may override createPassConfig to provide a target-specific sublass. 114 TargetPassConfig *PassConfig = TM->createPassConfig(PM); 115 116 // Set PassConfig options provided by TargetMachine. 117 PassConfig->setDisableVerify(DisableVerify); 118 119 PM.add(PassConfig); 120 121 PassConfig->addIRPasses(); 122 123 addPassesToHandleExceptions(TM, PM); 124 125 PassConfig->addISelPrepare(); 126 127 // Install a MachineModuleInfo class, which is an immutable pass that holds 128 // all the per-module stuff we're generating, including MCContext. 129 MachineModuleInfo *MMI = 130 new MachineModuleInfo(*TM->getMCAsmInfo(), *TM->getRegisterInfo(), 131 &TM->getTargetLowering()->getObjFileLowering()); 132 PM.add(MMI); 133 MCContext *Context = &MMI->getContext(); // Return the MCContext by-ref. 134 135 // Set up a MachineFunction for the rest of CodeGen to work on. 136 PM.add(new MachineFunctionAnalysis(*TM)); 137 138 // Enable FastISel with -fast, but allow that to be overridden. 139 if (EnableFastISelOption == cl::BOU_TRUE || 140 (TM->getOptLevel() == CodeGenOpt::None && 141 EnableFastISelOption != cl::BOU_FALSE)) 142 TM->setFastISel(true); 143 144 // Ask the target for an isel. 145 if (PassConfig->addInstSelector()) 146 return NULL; 147 148 PassConfig->addMachinePasses(); 149 150 PassConfig->setInitialized(); 151 152 return Context; 153 } 154 155 bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM, 156 formatted_raw_ostream &Out, 157 CodeGenFileType FileType, 158 bool DisableVerify) { 159 // Add common CodeGen passes. 160 MCContext *Context = addPassesToGenerateCode(this, PM, DisableVerify); 161 if (!Context) 162 return true; 163 164 if (hasMCSaveTempLabels()) 165 Context->setAllowTemporaryLabels(false); 166 167 const MCAsmInfo &MAI = *getMCAsmInfo(); 168 const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); 169 OwningPtr<MCStreamer> AsmStreamer; 170 171 switch (FileType) { 172 case CGFT_AssemblyFile: { 173 MCInstPrinter *InstPrinter = 174 getTarget().createMCInstPrinter(MAI.getAssemblerDialect(), MAI, 175 *getInstrInfo(), 176 Context->getRegisterInfo(), STI); 177 178 // Create a code emitter if asked to show the encoding. 179 MCCodeEmitter *MCE = 0; 180 MCAsmBackend *MAB = 0; 181 if (ShowMCEncoding) { 182 const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); 183 MCE = getTarget().createMCCodeEmitter(*getInstrInfo(), STI, *Context); 184 MAB = getTarget().createMCAsmBackend(getTargetTriple()); 185 } 186 187 MCStreamer *S = getTarget().createAsmStreamer(*Context, Out, 188 getVerboseAsm(), 189 hasMCUseLoc(), 190 hasMCUseCFI(), 191 hasMCUseDwarfDirectory(), 192 InstPrinter, 193 MCE, MAB, 194 ShowMCInst); 195 AsmStreamer.reset(S); 196 break; 197 } 198 case CGFT_ObjectFile: { 199 // Create the code emitter for the target if it exists. If not, .o file 200 // emission fails. 201 MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(*getInstrInfo(), STI, 202 *Context); 203 MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple()); 204 if (MCE == 0 || MAB == 0) 205 return true; 206 207 AsmStreamer.reset(getTarget().createMCObjectStreamer(getTargetTriple(), 208 *Context, *MAB, Out, 209 MCE, hasMCRelaxAll(), 210 hasMCNoExecStack())); 211 AsmStreamer.get()->InitSections(); 212 break; 213 } 214 case CGFT_Null: 215 // The Null output is intended for use for performance analysis and testing, 216 // not real users. 217 AsmStreamer.reset(createNullStreamer(*Context)); 218 break; 219 } 220 221 // Create the AsmPrinter, which takes ownership of AsmStreamer if successful. 222 FunctionPass *Printer = getTarget().createAsmPrinter(*this, *AsmStreamer); 223 if (Printer == 0) 224 return true; 225 226 // If successful, createAsmPrinter took ownership of AsmStreamer. 227 AsmStreamer.take(); 228 229 PM.add(Printer); 230 231 PM.add(createGCInfoDeleter()); 232 return false; 233 } 234 235 /// addPassesToEmitMachineCode - Add passes to the specified pass manager to 236 /// get machine code emitted. This uses a JITCodeEmitter object to handle 237 /// actually outputting the machine code and resolving things like the address 238 /// of functions. This method should returns true if machine code emission is 239 /// not supported. 240 /// 241 bool LLVMTargetMachine::addPassesToEmitMachineCode(PassManagerBase &PM, 242 JITCodeEmitter &JCE, 243 bool DisableVerify) { 244 // Add common CodeGen passes. 245 MCContext *Context = addPassesToGenerateCode(this, PM, DisableVerify); 246 if (!Context) 247 return true; 248 249 addCodeEmitter(PM, JCE); 250 PM.add(createGCInfoDeleter()); 251 252 return false; // success! 253 } 254 255 /// addPassesToEmitMC - Add passes to the specified pass manager to get 256 /// machine code emitted with the MCJIT. This method returns true if machine 257 /// code is not supported. It fills the MCContext Ctx pointer which can be 258 /// used to build custom MCStreamer. 259 /// 260 bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, 261 MCContext *&Ctx, 262 raw_ostream &Out, 263 bool DisableVerify) { 264 // Add common CodeGen passes. 265 Ctx = addPassesToGenerateCode(this, PM, DisableVerify); 266 if (!Ctx) 267 return true; 268 269 if (hasMCSaveTempLabels()) 270 Ctx->setAllowTemporaryLabels(false); 271 272 // Create the code emitter for the target if it exists. If not, .o file 273 // emission fails. 274 const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); 275 MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(*getInstrInfo(),STI, 276 *Ctx); 277 MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple()); 278 if (MCE == 0 || MAB == 0) 279 return true; 280 281 OwningPtr<MCStreamer> AsmStreamer; 282 AsmStreamer.reset(getTarget().createMCObjectStreamer(getTargetTriple(), *Ctx, 283 *MAB, Out, MCE, 284 hasMCRelaxAll(), 285 hasMCNoExecStack())); 286 AsmStreamer.get()->InitSections(); 287 288 // Create the AsmPrinter, which takes ownership of AsmStreamer if successful. 289 FunctionPass *Printer = getTarget().createAsmPrinter(*this, *AsmStreamer); 290 if (Printer == 0) 291 return true; 292 293 // If successful, createAsmPrinter took ownership of AsmStreamer. 294 AsmStreamer.take(); 295 296 PM.add(Printer); 297 298 return false; // success! 299 } 300
