LCOV - code coverage report
Current view: top level - lib/CodeGen - LLVMTargetMachine.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 106 107 99.1 %
Date: 2018-07-13 00:08:38 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/Analysis/Passes.h"
      15             : #include "llvm/CodeGen/AsmPrinter.h"
      16             : #include "llvm/CodeGen/BasicTTIImpl.h"
      17             : #include "llvm/CodeGen/MachineModuleInfo.h"
      18             : #include "llvm/CodeGen/Passes.h"
      19             : #include "llvm/CodeGen/TargetPassConfig.h"
      20             : #include "llvm/IR/LegacyPassManager.h"
      21             : #include "llvm/MC/MCAsmBackend.h"
      22             : #include "llvm/MC/MCAsmInfo.h"
      23             : #include "llvm/MC/MCCodeEmitter.h"
      24             : #include "llvm/MC/MCContext.h"
      25             : #include "llvm/MC/MCInstrInfo.h"
      26             : #include "llvm/MC/MCObjectWriter.h"
      27             : #include "llvm/MC/MCStreamer.h"
      28             : #include "llvm/MC/MCSubtargetInfo.h"
      29             : #include "llvm/Support/CommandLine.h"
      30             : #include "llvm/Support/ErrorHandling.h"
      31             : #include "llvm/Support/FormattedStream.h"
      32             : #include "llvm/Support/TargetRegistry.h"
      33             : #include "llvm/Target/TargetLoweringObjectFile.h"
      34             : #include "llvm/Target/TargetMachine.h"
      35             : #include "llvm/Target/TargetOptions.h"
      36             : using namespace llvm;
      37             : 
      38       99743 : static cl::opt<bool> EnableTrapUnreachable("trap-unreachable",
      39      199486 :   cl::Hidden, cl::ZeroOrMore, cl::init(false),
      40      199486 :   cl::desc("Enable generating trap for unreachable"));
      41             : 
      42       35205 : void LLVMTargetMachine::initAsmInfo() {
      43       70410 :   MRI = TheTarget.createMCRegInfo(getTargetTriple().str());
      44       70410 :   MII = TheTarget.createMCInstrInfo();
      45             :   // FIXME: Having an MCSubtargetInfo on the target machine is a hack due
      46             :   // to some backends having subtarget feature dependent module level
      47             :   // code generation. This is similar to the hack in the AsmPrinter for
      48             :   // module level assembly etc.
      49       70410 :   STI = TheTarget.createMCSubtargetInfo(getTargetTriple().str(), getTargetCPU(),
      50             :                                         getTargetFeatureString());
      51             : 
      52             :   MCAsmInfo *TmpAsmInfo =
      53       70410 :       TheTarget.createMCAsmInfo(*MRI, getTargetTriple().str());
      54             :   // TargetSelect.h moved to a different directory between LLVM 2.9 and 3.0,
      55             :   // and if the old one gets included then MCAsmInfo will be NULL and
      56             :   // we'll crash later.
      57             :   // Provide the user with a useful error message about what's wrong.
      58             :   assert(TmpAsmInfo && "MCAsmInfo not initialized. "
      59             :          "Make sure you include the correct TargetSelect.h"
      60             :          "and that InitializeAllTargetMCs() is being invoked!");
      61             : 
      62       35205 :   if (Options.DisableIntegratedAS)
      63         186 :     TmpAsmInfo->setUseIntegratedAssembler(false);
      64             : 
      65       35205 :   TmpAsmInfo->setPreserveAsmComments(Options.MCOptions.PreserveAsmComments);
      66             : 
      67       35205 :   TmpAsmInfo->setCompressDebugSections(Options.CompressDebugSections);
      68             : 
      69       35205 :   TmpAsmInfo->setRelaxELFRelocations(Options.RelaxELFRelocations);
      70             : 
      71       35205 :   if (Options.ExceptionModel != ExceptionHandling::None)
      72             :     TmpAsmInfo->setExceptionsType(Options.ExceptionModel);
      73             : 
      74       35205 :   AsmInfo = TmpAsmInfo;
      75       35205 : }
      76             : 
      77       35219 : LLVMTargetMachine::LLVMTargetMachine(const Target &T,
      78             :                                      StringRef DataLayoutString,
      79             :                                      const Triple &TT, StringRef CPU,
      80             :                                      StringRef FS, const TargetOptions &Options,
      81             :                                      Reloc::Model RM, CodeModel::Model CM,
      82       35219 :                                      CodeGenOpt::Level OL)
      83       35219 :     : TargetMachine(T, DataLayoutString, TT, CPU, FS, Options) {
      84       35219 :   this->RM = RM;
      85       35219 :   this->CMModel = CM;
      86       35219 :   this->OptLevel = OL;
      87             : 
      88       35219 :   if (EnableTrapUnreachable)
      89           2 :     this->Options.TrapUnreachable = true;
      90       35219 : }
      91             : 
      92             : TargetTransformInfo
      93       11335 : LLVMTargetMachine::getTargetTransformInfo(const Function &F) {
      94       22670 :   return TargetTransformInfo(BasicTTIImpl(this, F));
      95             : }
      96             : 
      97             : /// addPassesToX helper drives creation and initialization of TargetPassConfig.
      98             : static MCContext *
      99       22238 : addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM,
     100             :                         bool DisableVerify, bool &WillCompleteCodeGenPipeline,
     101             :                         raw_pwrite_stream &Out, MachineModuleInfo *MMI) {
     102             :   // Targets may override createPassConfig to provide a target-specific
     103             :   // subclass.
     104       22238 :   TargetPassConfig *PassConfig = TM->createPassConfig(PM);
     105             :   // Set PassConfig options provided by TargetMachine.
     106       22232 :   PassConfig->setDisableVerify(DisableVerify);
     107       22232 :   WillCompleteCodeGenPipeline = PassConfig->willCompleteCodeGenPipeline();
     108       22232 :   PM.add(PassConfig);
     109       22232 :   if (!MMI)
     110        2855 :     MMI = new MachineModuleInfo(TM);
     111       22232 :   PM.add(MMI);
     112             : 
     113       22232 :   if (PassConfig->addISelPasses())
     114             :     return nullptr;
     115       22232 :   PassConfig->addMachinePasses();
     116             :   PassConfig->setInitialized();
     117       22232 :   if (!WillCompleteCodeGenPipeline)
     118         178 :     PM.add(createPrintMIRPass(Out));
     119             : 
     120       22232 :   return &MMI->getContext();
     121             : }
     122             : 
     123       21782 : bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
     124             :                                       raw_pwrite_stream &Out,
     125             :                                       raw_pwrite_stream *DwoOut,
     126             :                                       CodeGenFileType FileType,
     127             :                                       MCContext &Context) {
     128       21782 :   if (Options.MCOptions.MCSaveTempLabels)
     129             :     Context.setAllowTemporaryLabels(false);
     130             : 
     131       21782 :   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
     132       21782 :   const MCAsmInfo &MAI = *getMCAsmInfo();
     133       21782 :   const MCRegisterInfo &MRI = *getMCRegisterInfo();
     134       21782 :   const MCInstrInfo &MII = *getMCInstrInfo();
     135             : 
     136       21782 :   std::unique_ptr<MCStreamer> AsmStreamer;
     137             : 
     138       21782 :   switch (FileType) {
     139       18379 :   case CGFT_AssemblyFile: {
     140       18379 :     MCInstPrinter *InstPrinter = getTarget().createMCInstPrinter(
     141       18379 :         getTargetTriple(), MAI.getAssemblerDialect(), MAI, MII, MRI);
     142             : 
     143             :     // Create a code emitter if asked to show the encoding.
     144       18379 :     std::unique_ptr<MCCodeEmitter> MCE;
     145       18379 :     if (Options.MCOptions.ShowMCEncoding)
     146         346 :       MCE.reset(getTarget().createMCCodeEmitter(MII, MRI, Context));
     147             : 
     148             :     std::unique_ptr<MCAsmBackend> MAB(
     149       18379 :         getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions));
     150       18379 :     auto FOut = llvm::make_unique<formatted_raw_ostream>(Out);
     151       91895 :     MCStreamer *S = getTarget().createAsmStreamer(
     152       18379 :         Context, std::move(FOut), Options.MCOptions.AsmVerbose,
     153       18379 :         Options.MCOptions.MCUseDwarfDirectory, InstPrinter, std::move(MCE),
     154       36758 :         std::move(MAB), Options.MCOptions.ShowMCInst);
     155             :     AsmStreamer.reset(S);
     156             :     break;
     157             :   }
     158        3390 :   case CGFT_ObjectFile: {
     159             :     // Create the code emitter for the target if it exists.  If not, .o file
     160             :     // emission fails.
     161        3390 :     MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(MII, MRI, Context);
     162             :     MCAsmBackend *MAB =
     163        3390 :         getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);
     164        3390 :     if (!MCE || !MAB)
     165           0 :       return true;
     166             : 
     167             :     // Don't waste memory on names of temp labels.
     168             :     Context.setUseNamesOnTempLabels(false);
     169             : 
     170        3390 :     Triple T(getTargetTriple().str());
     171       13560 :     AsmStreamer.reset(getTarget().createMCObjectStreamer(
     172        3390 :         T, Context, std::unique_ptr<MCAsmBackend>(MAB),
     173        6780 :         DwoOut ? MAB->createDwoObjectWriter(Out, *DwoOut)
     174             :                : MAB->createObjectWriter(Out),
     175        6780 :         std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
     176        3390 :         Options.MCOptions.MCIncrementalLinkerCompatible,
     177             :         /*DWARFMustBeAtTheEnd*/ true));
     178             :     break;
     179             :   }
     180          13 :   case CGFT_Null:
     181             :     // The Null output is intended for use for performance analysis and testing,
     182             :     // not real users.
     183          13 :     AsmStreamer.reset(getTarget().createNullStreamer(Context));
     184             :     break;
     185             :   }
     186             : 
     187             :   // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
     188             :   FunctionPass *Printer =
     189       21782 :       getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
     190       21782 :   if (!Printer)
     191             :     return true;
     192             : 
     193       21782 :   PM.add(Printer);
     194       21782 :   return false;
     195             : }
     196             : 
     197       21966 : bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
     198             :                                             raw_pwrite_stream &Out,
     199             :                                             raw_pwrite_stream *DwoOut,
     200             :                                             CodeGenFileType FileType,
     201             :                                             bool DisableVerify,
     202             :                                             MachineModuleInfo *MMI) {
     203             :   // Add common CodeGen passes.
     204       21966 :   bool WillCompleteCodeGenPipeline = true;
     205       21966 :   MCContext *Context = addPassesToGenerateCode(
     206       21966 :       this, PM, DisableVerify, WillCompleteCodeGenPipeline, Out, MMI);
     207       21960 :   if (!Context)
     208             :     return true;
     209             : 
     210       43742 :   if (WillCompleteCodeGenPipeline &&
     211       21782 :       addAsmPrinter(PM, Out, DwoOut, FileType, *Context))
     212             :     return true;
     213             : 
     214       21960 :   PM.add(createFreeMachineFunctionPass());
     215       21960 :   return false;
     216             : }
     217             : 
     218             : /// addPassesToEmitMC - Add passes to the specified pass manager to get
     219             : /// machine code emitted with the MCJIT. This method returns true if machine
     220             : /// code is not supported. It fills the MCContext Ctx pointer which can be
     221             : /// used to build custom MCStreamer.
     222             : ///
     223         272 : bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
     224             :                                           raw_pwrite_stream &Out,
     225             :                                           bool DisableVerify) {
     226             :   // Add common CodeGen passes.
     227         272 :   bool WillCompleteCodeGenPipeline = true;
     228         272 :   Ctx = addPassesToGenerateCode(this, PM, DisableVerify,
     229             :                                 WillCompleteCodeGenPipeline, Out,
     230             :                                 /*MachineModuleInfo*/ nullptr);
     231         272 :   if (!Ctx)
     232             :     return true;
     233             :   assert(WillCompleteCodeGenPipeline && "CodeGen pipeline has been altered");
     234             : 
     235         272 :   if (Options.MCOptions.MCSaveTempLabels)
     236             :     Ctx->setAllowTemporaryLabels(false);
     237             : 
     238             :   // Create the code emitter for the target if it exists.  If not, .o file
     239             :   // emission fails.
     240         272 :   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
     241         272 :   const MCRegisterInfo &MRI = *getMCRegisterInfo();
     242             :   MCCodeEmitter *MCE =
     243         272 :       getTarget().createMCCodeEmitter(*getMCInstrInfo(), MRI, *Ctx);
     244             :   MCAsmBackend *MAB =
     245         272 :       getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);
     246         272 :   if (!MCE || !MAB)
     247             :     return true;
     248             : 
     249             :   const Triple &T = getTargetTriple();
     250         272 :   std::unique_ptr<MCStreamer> AsmStreamer(getTarget().createMCObjectStreamer(
     251         816 :       T, *Ctx, std::unique_ptr<MCAsmBackend>(MAB), MAB->createObjectWriter(Out),
     252         544 :       std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
     253         272 :       Options.MCOptions.MCIncrementalLinkerCompatible,
     254         816 :       /*DWARFMustBeAtTheEnd*/ true));
     255             : 
     256             :   // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
     257             :   FunctionPass *Printer =
     258         272 :       getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
     259         272 :   if (!Printer)
     260             :     return true;
     261             : 
     262         272 :   PM.add(Printer);
     263         272 :   PM.add(createFreeMachineFunctionPass());
     264             : 
     265         272 :   return false; // success!
     266      299229 : }

Generated by: LCOV version 1.13