1 //===-- LLVMTargetMachine.cpp - Implement the LLVMTargetMachine class -----===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the LLVMTargetMachine class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Analysis/Passes.h" 14 #include "llvm/CodeGen/AsmPrinter.h" 15 #include "llvm/CodeGen/BasicTTIImpl.h" 16 #include "llvm/CodeGen/MachineModuleInfo.h" 17 #include "llvm/CodeGen/Passes.h" 18 #include "llvm/CodeGen/TargetPassConfig.h" 19 #include "llvm/IR/LegacyPassManager.h" 20 #include "llvm/MC/MCAsmBackend.h" 21 #include "llvm/MC/MCAsmInfo.h" 22 #include "llvm/MC/MCCodeEmitter.h" 23 #include "llvm/MC/MCContext.h" 24 #include "llvm/MC/MCInstrInfo.h" 25 #include "llvm/MC/MCObjectWriter.h" 26 #include "llvm/MC/MCRegisterInfo.h" 27 #include "llvm/MC/MCStreamer.h" 28 #include "llvm/MC/MCSubtargetInfo.h" 29 #include "llvm/MC/TargetRegistry.h" 30 #include "llvm/Support/CommandLine.h" 31 #include "llvm/Support/FormattedStream.h" 32 #include "llvm/Target/TargetMachine.h" 33 #include "llvm/Target/TargetOptions.h" 34 using namespace llvm; 35 36 static cl::opt<bool> 37 EnableTrapUnreachable("trap-unreachable", cl::Hidden, 38 cl::desc("Enable generating trap for unreachable")); 39 40 static cl::opt<bool> EnableNoTrapAfterNoreturn( 41 "no-trap-after-noreturn", cl::Hidden, 42 cl::desc("Do not emit a trap instruction for 'unreachable' IR instructions " 43 "after noreturn calls, even if --trap-unreachable is set.")); 44 45 void LLVMTargetMachine::initAsmInfo() { 46 MRI.reset(TheTarget.createMCRegInfo(getTargetTriple().str())); 47 assert(MRI && "Unable to create reg info"); 48 MII.reset(TheTarget.createMCInstrInfo()); 49 assert(MII && "Unable to create instruction info"); 50 // FIXME: Having an MCSubtargetInfo on the target machine is a hack due 51 // to some backends having subtarget feature dependent module level 52 // code generation. This is similar to the hack in the AsmPrinter for 53 // module level assembly etc. 54 STI.reset(TheTarget.createMCSubtargetInfo( 55 getTargetTriple().str(), getTargetCPU(), getTargetFeatureString())); 56 assert(STI && "Unable to create subtarget info"); 57 58 MCAsmInfo *TmpAsmInfo = TheTarget.createMCAsmInfo( 59 *MRI, getTargetTriple().str(), Options.MCOptions); 60 // TargetSelect.h moved to a different directory between LLVM 2.9 and 3.0, 61 // and if the old one gets included then MCAsmInfo will be NULL and 62 // we'll crash later. 63 // Provide the user with a useful error message about what's wrong. 64 assert(TmpAsmInfo && "MCAsmInfo not initialized. " 65 "Make sure you include the correct TargetSelect.h" 66 "and that InitializeAllTargetMCs() is being invoked!"); 67 68 if (Options.BinutilsVersion.first > 0) 69 TmpAsmInfo->setBinutilsVersion(Options.BinutilsVersion); 70 71 if (Options.DisableIntegratedAS) { 72 TmpAsmInfo->setUseIntegratedAssembler(false); 73 // If there is explict option disable integratedAS, we can't use it for 74 // inlineasm either. 75 TmpAsmInfo->setParseInlineAsmUsingAsmParser(false); 76 } 77 78 TmpAsmInfo->setPreserveAsmComments(Options.MCOptions.PreserveAsmComments); 79 80 TmpAsmInfo->setCompressDebugSections(Options.CompressDebugSections); 81 82 TmpAsmInfo->setRelaxELFRelocations(Options.RelaxELFRelocations); 83 84 TmpAsmInfo->setFullRegisterNames(Options.MCOptions.PPCUseFullRegisterNames); 85 86 if (Options.ExceptionModel != ExceptionHandling::None) 87 TmpAsmInfo->setExceptionsType(Options.ExceptionModel); 88 89 AsmInfo.reset(TmpAsmInfo); 90 } 91 92 LLVMTargetMachine::LLVMTargetMachine(const Target &T, 93 StringRef DataLayoutString, 94 const Triple &TT, StringRef CPU, 95 StringRef FS, const TargetOptions &Options, 96 Reloc::Model RM, CodeModel::Model CM, 97 CodeGenOptLevel OL) 98 : TargetMachine(T, DataLayoutString, TT, CPU, FS, Options) { 99 this->RM = RM; 100 this->CMModel = CM; 101 this->OptLevel = OL; 102 103 if (EnableTrapUnreachable) 104 this->Options.TrapUnreachable = true; 105 if (EnableNoTrapAfterNoreturn) 106 this->Options.NoTrapAfterNoreturn = true; 107 } 108 109 TargetTransformInfo 110 LLVMTargetMachine::getTargetTransformInfo(const Function &F) const { 111 return TargetTransformInfo(BasicTTIImpl(this, F)); 112 } 113 114 /// addPassesToX helper drives creation and initialization of TargetPassConfig. 115 static TargetPassConfig * 116 addPassesToGenerateCode(LLVMTargetMachine &TM, PassManagerBase &PM, 117 bool DisableVerify, 118 MachineModuleInfoWrapperPass &MMIWP) { 119 // Targets may override createPassConfig to provide a target-specific 120 // subclass. 121 TargetPassConfig *PassConfig = TM.createPassConfig(PM); 122 // Set PassConfig options provided by TargetMachine. 123 PassConfig->setDisableVerify(DisableVerify); 124 PM.add(PassConfig); 125 PM.add(&MMIWP); 126 127 if (PassConfig->addISelPasses()) 128 return nullptr; 129 PassConfig->addMachinePasses(); 130 PassConfig->setInitialized(); 131 return PassConfig; 132 } 133 134 bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM, 135 raw_pwrite_stream &Out, 136 raw_pwrite_stream *DwoOut, 137 CodeGenFileType FileType, 138 MCContext &Context) { 139 Expected<std::unique_ptr<MCStreamer>> MCStreamerOrErr = 140 createMCStreamer(Out, DwoOut, FileType, Context); 141 if (auto Err = MCStreamerOrErr.takeError()) 142 return true; 143 144 // Create the AsmPrinter, which takes ownership of AsmStreamer if successful. 145 FunctionPass *Printer = 146 getTarget().createAsmPrinter(*this, std::move(*MCStreamerOrErr)); 147 if (!Printer) 148 return true; 149 150 PM.add(Printer); 151 return false; 152 } 153 154 Expected<std::unique_ptr<MCStreamer>> LLVMTargetMachine::createMCStreamer( 155 raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, 156 MCContext &Context) { 157 if (Options.MCOptions.MCSaveTempLabels) 158 Context.setAllowTemporaryLabels(false); 159 160 const MCSubtargetInfo &STI = *getMCSubtargetInfo(); 161 const MCAsmInfo &MAI = *getMCAsmInfo(); 162 const MCRegisterInfo &MRI = *getMCRegisterInfo(); 163 const MCInstrInfo &MII = *getMCInstrInfo(); 164 165 std::unique_ptr<MCStreamer> AsmStreamer; 166 167 switch (FileType) { 168 case CodeGenFileType::AssemblyFile: { 169 MCInstPrinter *InstPrinter = getTarget().createMCInstPrinter( 170 getTargetTriple(), MAI.getAssemblerDialect(), MAI, MII, MRI); 171 172 // Create a code emitter if asked to show the encoding. 173 std::unique_ptr<MCCodeEmitter> MCE; 174 if (Options.MCOptions.ShowMCEncoding) 175 MCE.reset(getTarget().createMCCodeEmitter(MII, Context)); 176 177 bool UseDwarfDirectory = false; 178 switch (Options.MCOptions.MCUseDwarfDirectory) { 179 case MCTargetOptions::DisableDwarfDirectory: 180 UseDwarfDirectory = false; 181 break; 182 case MCTargetOptions::EnableDwarfDirectory: 183 UseDwarfDirectory = true; 184 break; 185 case MCTargetOptions::DefaultDwarfDirectory: 186 UseDwarfDirectory = MAI.enableDwarfFileDirectoryDefault(); 187 break; 188 } 189 190 std::unique_ptr<MCAsmBackend> MAB( 191 getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions)); 192 auto FOut = std::make_unique<formatted_raw_ostream>(Out); 193 MCStreamer *S = getTarget().createAsmStreamer( 194 Context, std::move(FOut), Options.MCOptions.AsmVerbose, 195 UseDwarfDirectory, InstPrinter, std::move(MCE), std::move(MAB), 196 Options.MCOptions.ShowMCInst); 197 AsmStreamer.reset(S); 198 break; 199 } 200 case CodeGenFileType::ObjectFile: { 201 // Create the code emitter for the target if it exists. If not, .o file 202 // emission fails. 203 MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(MII, Context); 204 if (!MCE) 205 return make_error<StringError>("createMCCodeEmitter failed", 206 inconvertibleErrorCode()); 207 MCAsmBackend *MAB = 208 getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions); 209 if (!MAB) 210 return make_error<StringError>("createMCAsmBackend failed", 211 inconvertibleErrorCode()); 212 213 Triple T(getTargetTriple().str()); 214 AsmStreamer.reset(getTarget().createMCObjectStreamer( 215 T, Context, std::unique_ptr<MCAsmBackend>(MAB), 216 DwoOut ? MAB->createDwoObjectWriter(Out, *DwoOut) 217 : MAB->createObjectWriter(Out), 218 std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll, 219 Options.MCOptions.MCIncrementalLinkerCompatible, 220 /*DWARFMustBeAtTheEnd*/ true)); 221 break; 222 } 223 case CodeGenFileType::Null: 224 // The Null output is intended for use for performance analysis and testing, 225 // not real users. 226 AsmStreamer.reset(getTarget().createNullStreamer(Context)); 227 break; 228 } 229 230 return std::move(AsmStreamer); 231 } 232 233 bool LLVMTargetMachine::addPassesToEmitFile( 234 PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, 235 CodeGenFileType FileType, bool DisableVerify, 236 MachineModuleInfoWrapperPass *MMIWP) { 237 // Add common CodeGen passes. 238 if (!MMIWP) 239 MMIWP = new MachineModuleInfoWrapperPass(this); 240 TargetPassConfig *PassConfig = 241 addPassesToGenerateCode(*this, PM, DisableVerify, *MMIWP); 242 if (!PassConfig) 243 return true; 244 245 if (TargetPassConfig::willCompleteCodeGenPipeline()) { 246 if (addAsmPrinter(PM, Out, DwoOut, FileType, MMIWP->getMMI().getContext())) 247 return true; 248 } else { 249 // MIR printing is redundant with -filetype=null. 250 if (FileType != CodeGenFileType::Null) 251 PM.add(createPrintMIRPass(Out)); 252 } 253 254 PM.add(createFreeMachineFunctionPass()); 255 return false; 256 } 257 258 /// addPassesToEmitMC - Add passes to the specified pass manager to get 259 /// machine code emitted with the MCJIT. This method returns true if machine 260 /// code is not supported. It fills the MCContext Ctx pointer which can be 261 /// used to build custom MCStreamer. 262 /// 263 bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx, 264 raw_pwrite_stream &Out, 265 bool DisableVerify) { 266 // Add common CodeGen passes. 267 MachineModuleInfoWrapperPass *MMIWP = new MachineModuleInfoWrapperPass(this); 268 TargetPassConfig *PassConfig = 269 addPassesToGenerateCode(*this, PM, DisableVerify, *MMIWP); 270 if (!PassConfig) 271 return true; 272 assert(TargetPassConfig::willCompleteCodeGenPipeline() && 273 "Cannot emit MC with limited codegen pipeline"); 274 275 Ctx = &MMIWP->getMMI().getContext(); 276 // libunwind is unable to load compact unwind dynamically, so we must generate 277 // DWARF unwind info for the JIT. 278 Options.MCOptions.EmitDwarfUnwind = EmitDwarfUnwindType::Always; 279 if (Options.MCOptions.MCSaveTempLabels) 280 Ctx->setAllowTemporaryLabels(false); 281 282 // Create the code emitter for the target if it exists. If not, .o file 283 // emission fails. 284 const MCSubtargetInfo &STI = *getMCSubtargetInfo(); 285 const MCRegisterInfo &MRI = *getMCRegisterInfo(); 286 std::unique_ptr<MCCodeEmitter> MCE( 287 getTarget().createMCCodeEmitter(*getMCInstrInfo(), *Ctx)); 288 std::unique_ptr<MCAsmBackend> MAB( 289 getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions)); 290 if (!MCE || !MAB) 291 return true; 292 293 const Triple &T = getTargetTriple(); 294 std::unique_ptr<MCStreamer> AsmStreamer(getTarget().createMCObjectStreamer( 295 T, *Ctx, std::move(MAB), MAB->createObjectWriter(Out), std::move(MCE), 296 STI, Options.MCOptions.MCRelaxAll, 297 Options.MCOptions.MCIncrementalLinkerCompatible, 298 /*DWARFMustBeAtTheEnd*/ true)); 299 300 // Create the AsmPrinter, which takes ownership of AsmStreamer if successful. 301 FunctionPass *Printer = 302 getTarget().createAsmPrinter(*this, std::move(AsmStreamer)); 303 if (!Printer) 304 return true; 305 306 PM.add(Printer); 307 PM.add(createFreeMachineFunctionPass()); 308 309 return false; // success! 310 } 311