Home | History | Annotate | Download | only in CodeGen 
      1 //===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
      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 #include "clang/CodeGen/BackendUtil.h"
     11 #include "clang/Basic/Diagnostic.h"
     12 #include "clang/Basic/LangOptions.h"
     13 #include "clang/Basic/TargetOptions.h"
     14 #include "clang/Frontend/CodeGenOptions.h"
     15 #include "clang/Frontend/FrontendDiagnostic.h"
     16 #include "llvm/Analysis/Verifier.h"
     17 #include "llvm/Assembly/PrintModulePass.h"
     18 #include "llvm/Bitcode/ReaderWriter.h"
     19 #include "llvm/CodeGen/RegAllocRegistry.h"
     20 #include "llvm/CodeGen/SchedulerRegistry.h"
     21 #include "llvm/IR/DataLayout.h"
     22 #include "llvm/IR/Module.h"
     23 #include "llvm/MC/SubtargetFeature.h"
     24 #include "llvm/PassManager.h"
     25 #include "llvm/Support/CommandLine.h"
     26 #include "llvm/Support/FormattedStream.h"
     27 #include "llvm/Support/PrettyStackTrace.h"
     28 #include "llvm/Support/TargetRegistry.h"
     29 #include "llvm/Support/Timer.h"
     30 #include "llvm/Support/raw_ostream.h"
     31 #include "llvm/Target/TargetLibraryInfo.h"
     32 #include "llvm/Target/TargetMachine.h"
     33 #include "llvm/Target/TargetOptions.h"
     34 #include "llvm/Transforms/IPO.h"
     35 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
     36 #include "llvm/Transforms/Instrumentation.h"
     37 #include "llvm/Transforms/ObjCARC.h"
     38 #include "llvm/Transforms/Scalar.h"
     39 using namespace clang;
     40 using namespace llvm;
     41 
     42 namespace {
     43 
     44 class EmitAssemblyHelper {
     45   DiagnosticsEngine &Diags;
     46   const CodeGenOptions &CodeGenOpts;
     47   const clang::TargetOptions &TargetOpts;
     48   const LangOptions &LangOpts;
     49   Module *TheModule;
     50 
     51   Timer CodeGenerationTime;
     52 
     53   mutable PassManager *CodeGenPasses;
     54   mutable PassManager *PerModulePasses;
     55   mutable FunctionPassManager *PerFunctionPasses;
     56 
     57 private:
     58   PassManager *getCodeGenPasses(TargetMachine *TM) const {
     59     if (!CodeGenPasses) {
     60       CodeGenPasses = new PassManager();
     61       CodeGenPasses->add(new DataLayout(TheModule));
     62       if (TM)
     63         TM->addAnalysisPasses(*CodeGenPasses);
     64     }
     65     return CodeGenPasses;
     66   }
     67 
     68   PassManager *getPerModulePasses(TargetMachine *TM) const {
     69     if (!PerModulePasses) {
     70       PerModulePasses = new PassManager();
     71       PerModulePasses->add(new DataLayout(TheModule));
     72       if (TM)
     73         TM->addAnalysisPasses(*PerModulePasses);
     74     }
     75     return PerModulePasses;
     76   }
     77 
     78   FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const {
     79     if (!PerFunctionPasses) {
     80       PerFunctionPasses = new FunctionPassManager(TheModule);
     81       PerFunctionPasses->add(new DataLayout(TheModule));
     82       if (TM)
     83         TM->addAnalysisPasses(*PerFunctionPasses);
     84     }
     85     return PerFunctionPasses;
     86   }
     87 
     88 
     89   void CreatePasses(TargetMachine *TM);
     90 
     91   /// CreateTargetMachine - Generates the TargetMachine.
     92   /// Returns Null if it is unable to create the target machine.
     93   /// Some of our clang tests specify triples which are not built
     94   /// into clang. This is okay because these tests check the generated
     95   /// IR, and they require DataLayout which depends on the triple.
     96   /// In this case, we allow this method to fail and not report an error.
     97   /// When MustCreateTM is used, we print an error if we are unable to load
     98   /// the requested target.
     99   TargetMachine *CreateTargetMachine(bool MustCreateTM);
    100 
    101   /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
    102   ///
    103   /// \return True on success.
    104   bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS,
    105                      TargetMachine *TM);
    106 
    107 public:
    108   EmitAssemblyHelper(DiagnosticsEngine &_Diags,
    109                      const CodeGenOptions &CGOpts,
    110                      const clang::TargetOptions &TOpts,
    111                      const LangOptions &LOpts,
    112                      Module *M)
    113     : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
    114       TheModule(M), CodeGenerationTime("Code Generation Time"),
    115       CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
    116 
    117   ~EmitAssemblyHelper() {
    118     delete CodeGenPasses;
    119     delete PerModulePasses;
    120     delete PerFunctionPasses;
    121   }
    122 
    123   void EmitAssembly(BackendAction Action, raw_ostream *OS);
    124 };
    125 
    126 // We need this wrapper to access LangOpts and CGOpts from extension functions
    127 // that we add to the PassManagerBuilder.
    128 class PassManagerBuilderWrapper : public PassManagerBuilder {
    129 public:
    130   PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
    131                             const LangOptions &LangOpts)
    132       : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
    133   const CodeGenOptions &getCGOpts() const { return CGOpts; }
    134   const LangOptions &getLangOpts() const { return LangOpts; }
    135 private:
    136   const CodeGenOptions &CGOpts;
    137   const LangOptions &LangOpts;
    138 };
    139 
    140 }
    141 
    142 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
    143   if (Builder.OptLevel > 0)
    144     PM.add(createObjCARCAPElimPass());
    145 }
    146 
    147 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
    148   if (Builder.OptLevel > 0)
    149     PM.add(createObjCARCExpandPass());
    150 }
    151 
    152 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
    153   if (Builder.OptLevel > 0)
    154     PM.add(createObjCARCOptPass());
    155 }
    156 
    157 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
    158                                     PassManagerBase &PM) {
    159   PM.add(createBoundsCheckingPass());
    160 }
    161 
    162 static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
    163                                       PassManagerBase &PM) {
    164   const PassManagerBuilderWrapper &BuilderWrapper =
    165       static_cast<const PassManagerBuilderWrapper&>(Builder);
    166   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
    167   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
    168   PM.add(createAddressSanitizerFunctionPass(
    169       LangOpts.Sanitize.InitOrder,
    170       LangOpts.Sanitize.UseAfterReturn,
    171       LangOpts.Sanitize.UseAfterScope,
    172       CGOpts.SanitizerBlacklistFile,
    173       CGOpts.SanitizeAddressZeroBaseShadow));
    174   PM.add(createAddressSanitizerModulePass(
    175       LangOpts.Sanitize.InitOrder,
    176       CGOpts.SanitizerBlacklistFile,
    177       CGOpts.SanitizeAddressZeroBaseShadow));
    178 }
    179 
    180 static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
    181                                    PassManagerBase &PM) {
    182   const PassManagerBuilderWrapper &BuilderWrapper =
    183       static_cast<const PassManagerBuilderWrapper&>(Builder);
    184   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
    185   PM.add(createMemorySanitizerPass(CGOpts.SanitizeMemoryTrackOrigins,
    186                                    CGOpts.SanitizerBlacklistFile));
    187 
    188   // MemorySanitizer inserts complex instrumentation that mostly follows
    189   // the logic of the original code, but operates on "shadow" values.
    190   // It can benefit from re-running some general purpose optimization passes.
    191   if (Builder.OptLevel > 0) {
    192     PM.add(createEarlyCSEPass());
    193     PM.add(createReassociatePass());
    194     PM.add(createLICMPass());
    195     PM.add(createGVNPass());
    196     PM.add(createInstructionCombiningPass());
    197     PM.add(createDeadStoreEliminationPass());
    198   }
    199 }
    200 
    201 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
    202                                    PassManagerBase &PM) {
    203   const PassManagerBuilderWrapper &BuilderWrapper =
    204       static_cast<const PassManagerBuilderWrapper&>(Builder);
    205   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
    206   PM.add(createThreadSanitizerPass(CGOpts.SanitizerBlacklistFile));
    207 }
    208 
    209 void EmitAssemblyHelper::CreatePasses(TargetMachine *TM) {
    210   unsigned OptLevel = CodeGenOpts.OptimizationLevel;
    211   CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
    212 
    213   // Handle disabling of LLVM optimization, where we want to preserve the
    214   // internal module before any optimization.
    215   if (CodeGenOpts.DisableLLVMOpts) {
    216     OptLevel = 0;
    217     Inlining = CodeGenOpts.NoInlining;
    218   }
    219 
    220   PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
    221   PMBuilder.OptLevel = OptLevel;
    222   PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
    223   PMBuilder.BBVectorize = CodeGenOpts.VectorizeBB;
    224   PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
    225   PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
    226 
    227   PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
    228   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
    229 
    230   // In ObjC ARC mode, add the main ARC optimization passes.
    231   if (LangOpts.ObjCAutoRefCount) {
    232     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
    233                            addObjCARCExpandPass);
    234     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
    235                            addObjCARCAPElimPass);
    236     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
    237                            addObjCARCOptPass);
    238   }
    239 
    240   if (LangOpts.Sanitize.Bounds) {
    241     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
    242                            addBoundsCheckingPass);
    243     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
    244                            addBoundsCheckingPass);
    245   }
    246 
    247   if (LangOpts.Sanitize.Address) {
    248     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
    249                            addAddressSanitizerPasses);
    250     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
    251                            addAddressSanitizerPasses);
    252   }
    253 
    254   if (LangOpts.Sanitize.Memory) {
    255     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
    256                            addMemorySanitizerPass);
    257     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
    258                            addMemorySanitizerPass);
    259   }
    260 
    261   if (LangOpts.Sanitize.Thread) {
    262     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
    263                            addThreadSanitizerPass);
    264     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
    265                            addThreadSanitizerPass);
    266   }
    267 
    268   // Figure out TargetLibraryInfo.
    269   Triple TargetTriple(TheModule->getTargetTriple());
    270   PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
    271   if (!CodeGenOpts.SimplifyLibCalls)
    272     PMBuilder.LibraryInfo->disableAllFunctions();
    273 
    274   switch (Inlining) {
    275   case CodeGenOptions::NoInlining: break;
    276   case CodeGenOptions::NormalInlining: {
    277     // FIXME: Derive these constants in a principled fashion.
    278     unsigned Threshold = 225;
    279     if (CodeGenOpts.OptimizeSize == 1)      // -Os
    280       Threshold = 75;
    281     else if (CodeGenOpts.OptimizeSize == 2) // -Oz
    282       Threshold = 25;
    283     else if (OptLevel > 2)
    284       Threshold = 275;
    285     PMBuilder.Inliner = createFunctionInliningPass(Threshold);
    286     break;
    287   }
    288   case CodeGenOptions::OnlyAlwaysInlining:
    289     // Respect always_inline.
    290     if (OptLevel == 0)
    291       // Do not insert lifetime intrinsics at -O0.
    292       PMBuilder.Inliner = createAlwaysInlinerPass(false);
    293     else
    294       PMBuilder.Inliner = createAlwaysInlinerPass();
    295     break;
    296   }
    297 
    298   // Set up the per-function pass manager.
    299   FunctionPassManager *FPM = getPerFunctionPasses(TM);
    300   if (CodeGenOpts.VerifyModule)
    301     FPM->add(createVerifierPass());
    302   PMBuilder.populateFunctionPassManager(*FPM);
    303 
    304   // Set up the per-module pass manager.
    305   PassManager *MPM = getPerModulePasses(TM);
    306 
    307   if (!CodeGenOpts.DisableGCov &&
    308       (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
    309     // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
    310     // LLVM's -default-gcov-version flag is set to something invalid.
    311     GCOVOptions Options;
    312     Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
    313     Options.EmitData = CodeGenOpts.EmitGcovArcs;
    314     memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
    315     Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
    316     Options.NoRedZone = CodeGenOpts.DisableRedZone;
    317     Options.FunctionNamesInData =
    318         !CodeGenOpts.CoverageNoFunctionNamesInData;
    319     MPM->add(createGCOVProfilerPass(Options));
    320     if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
    321       MPM->add(createStripSymbolsPass(true));
    322   }
    323 
    324   PMBuilder.populateModulePassManager(*MPM);
    325 }
    326 
    327 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
    328   // Create the TargetMachine for generating code.
    329   std::string Error;
    330   std::string Triple = TheModule->getTargetTriple();
    331   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
    332   if (!TheTarget) {
    333     if (MustCreateTM)
    334       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
    335     return 0;
    336   }
    337 
    338   // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
    339   // being gross, this is also totally broken if we ever care about
    340   // concurrency.
    341 
    342   TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
    343 
    344   TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
    345   TargetMachine::setDataSections    (CodeGenOpts.DataSections);
    346 
    347   // FIXME: Parse this earlier.
    348   llvm::CodeModel::Model CM;
    349   if (CodeGenOpts.CodeModel == "small") {
    350     CM = llvm::CodeModel::Small;
    351   } else if (CodeGenOpts.CodeModel == "kernel") {
    352     CM = llvm::CodeModel::Kernel;
    353   } else if (CodeGenOpts.CodeModel == "medium") {
    354     CM = llvm::CodeModel::Medium;
    355   } else if (CodeGenOpts.CodeModel == "large") {
    356     CM = llvm::CodeModel::Large;
    357   } else {
    358     assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
    359     CM = llvm::CodeModel::Default;
    360   }
    361 
    362   SmallVector<const char *, 16> BackendArgs;
    363   BackendArgs.push_back("clang"); // Fake program name.
    364   if (!CodeGenOpts.DebugPass.empty()) {
    365     BackendArgs.push_back("-debug-pass");
    366     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
    367   }
    368   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
    369     BackendArgs.push_back("-limit-float-precision");
    370     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
    371   }
    372   if (llvm::TimePassesIsEnabled)
    373     BackendArgs.push_back("-time-passes");
    374   for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
    375     BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
    376   if (CodeGenOpts.NoGlobalMerge)
    377     BackendArgs.push_back("-global-merge=false");
    378   BackendArgs.push_back(0);
    379   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
    380                                     BackendArgs.data());
    381 
    382   std::string FeaturesStr;
    383   if (TargetOpts.Features.size()) {
    384     SubtargetFeatures Features;
    385     for (std::vector<std::string>::const_iterator
    386            it = TargetOpts.Features.begin(),
    387            ie = TargetOpts.Features.end(); it != ie; ++it)
    388       Features.AddFeature(*it);
    389     FeaturesStr = Features.getString();
    390   }
    391 
    392   llvm::Reloc::Model RM = llvm::Reloc::Default;
    393   if (CodeGenOpts.RelocationModel == "static") {
    394     RM = llvm::Reloc::Static;
    395   } else if (CodeGenOpts.RelocationModel == "pic") {
    396     RM = llvm::Reloc::PIC_;
    397   } else {
    398     assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
    399            "Invalid PIC model!");
    400     RM = llvm::Reloc::DynamicNoPIC;
    401   }
    402 
    403   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
    404   switch (CodeGenOpts.OptimizationLevel) {
    405   default: break;
    406   case 0: OptLevel = CodeGenOpt::None; break;
    407   case 3: OptLevel = CodeGenOpt::Aggressive; break;
    408   }
    409 
    410   llvm::TargetOptions Options;
    411 
    412   // Set frame pointer elimination mode.
    413   if (!CodeGenOpts.DisableFPElim) {
    414     Options.NoFramePointerElim = false;
    415   } else if (CodeGenOpts.OmitLeafFramePointer) {
    416     Options.NoFramePointerElim = false;
    417   } else {
    418     Options.NoFramePointerElim = true;
    419   }
    420 
    421   if (CodeGenOpts.UseInitArray)
    422     Options.UseInitArray = true;
    423 
    424   // Set float ABI type.
    425   if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
    426     Options.FloatABIType = llvm::FloatABI::Soft;
    427   else if (CodeGenOpts.FloatABI == "hard")
    428     Options.FloatABIType = llvm::FloatABI::Hard;
    429   else {
    430     assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
    431     Options.FloatABIType = llvm::FloatABI::Default;
    432   }
    433 
    434   // Set FP fusion mode.
    435   switch (CodeGenOpts.getFPContractMode()) {
    436   case CodeGenOptions::FPC_Off:
    437     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
    438     break;
    439   case CodeGenOptions::FPC_On:
    440     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
    441     break;
    442   case CodeGenOptions::FPC_Fast:
    443     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
    444     break;
    445   }
    446 
    447   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
    448   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
    449   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
    450   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
    451   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
    452   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
    453   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
    454   Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
    455   Options.TrapFuncName = CodeGenOpts.TrapFuncName;
    456   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
    457   Options.EnableSegmentedStacks = CodeGenOpts.EnableSegmentedStacks;
    458 
    459   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
    460                                                      FeaturesStr, Options,
    461                                                      RM, CM, OptLevel);
    462 
    463   if (CodeGenOpts.RelaxAll)
    464     TM->setMCRelaxAll(true);
    465   if (CodeGenOpts.SaveTempLabels)
    466     TM->setMCSaveTempLabels(true);
    467   if (CodeGenOpts.NoDwarf2CFIAsm)
    468     TM->setMCUseCFI(false);
    469   if (!CodeGenOpts.NoDwarfDirectoryAsm)
    470     TM->setMCUseDwarfDirectory(true);
    471   if (CodeGenOpts.NoExecStack)
    472     TM->setMCNoExecStack(true);
    473 
    474   return TM;
    475 }
    476 
    477 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
    478                                        formatted_raw_ostream &OS,
    479                                        TargetMachine *TM) {
    480 
    481   // Create the code generator passes.
    482   PassManager *PM = getCodeGenPasses(TM);
    483 
    484   // Add LibraryInfo.
    485   llvm::Triple TargetTriple(TheModule->getTargetTriple());
    486   TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
    487   if (!CodeGenOpts.SimplifyLibCalls)
    488     TLI->disableAllFunctions();
    489   PM->add(TLI);
    490 
    491   // Add Target specific analysis passes.
    492   TM->addAnalysisPasses(*PM);
    493 
    494   // Normal mode, emit a .s or .o file by running the code generator. Note,
    495   // this also adds codegenerator level optimization passes.
    496   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
    497   if (Action == Backend_EmitObj)
    498     CGFT = TargetMachine::CGFT_ObjectFile;
    499   else if (Action == Backend_EmitMCNull)
    500     CGFT = TargetMachine::CGFT_Null;
    501   else
    502     assert(Action == Backend_EmitAssembly && "Invalid action!");
    503 
    504   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
    505   // "codegen" passes so that it isn't run multiple times when there is
    506   // inlining happening.
    507   if (LangOpts.ObjCAutoRefCount &&
    508       CodeGenOpts.OptimizationLevel > 0)
    509     PM->add(createObjCARCContractPass());
    510 
    511   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
    512                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
    513     Diags.Report(diag::err_fe_unable_to_interface_with_target);
    514     return false;
    515   }
    516 
    517   return true;
    518 }
    519 
    520 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
    521   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
    522   llvm::formatted_raw_ostream FormattedOS;
    523 
    524   bool UsesCodeGen = (Action != Backend_EmitNothing &&
    525                       Action != Backend_EmitBC &&
    526                       Action != Backend_EmitLL);
    527   TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
    528   if (UsesCodeGen && !TM) return;
    529   llvm::OwningPtr<TargetMachine> TMOwner(CodeGenOpts.DisableFree ? 0 : TM);
    530   CreatePasses(TM);
    531 
    532   switch (Action) {
    533   case Backend_EmitNothing:
    534     break;
    535 
    536   case Backend_EmitBC:
    537     getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
    538     break;
    539 
    540   case Backend_EmitLL:
    541     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
    542     getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
    543     break;
    544 
    545   default:
    546     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
    547     if (!AddEmitPasses(Action, FormattedOS, TM))
    548       return;
    549   }
    550 
    551   // Before executing passes, print the final values of the LLVM options.
    552   cl::PrintOptionValues();
    553 
    554   // Run passes. For now we do all passes at once, but eventually we
    555   // would like to have the option of streaming code generation.
    556 
    557   if (PerFunctionPasses) {
    558     PrettyStackTraceString CrashInfo("Per-function optimization");
    559 
    560     PerFunctionPasses->doInitialization();
    561     for (Module::iterator I = TheModule->begin(),
    562            E = TheModule->end(); I != E; ++I)
    563       if (!I->isDeclaration())
    564         PerFunctionPasses->run(*I);
    565     PerFunctionPasses->doFinalization();
    566   }
    567 
    568   if (PerModulePasses) {
    569     PrettyStackTraceString CrashInfo("Per-module optimization passes");
    570     PerModulePasses->run(*TheModule);
    571   }
    572 
    573   if (CodeGenPasses) {
    574     PrettyStackTraceString CrashInfo("Code generation");
    575     CodeGenPasses->run(*TheModule);
    576   }
    577 }
    578 
    579 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
    580                               const CodeGenOptions &CGOpts,
    581                               const clang::TargetOptions &TOpts,
    582                               const LangOptions &LOpts,
    583                               Module *M,
    584                               BackendAction Action, raw_ostream *OS) {
    585   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
    586 
    587   AsmHelper.EmitAssembly(Action, OS);
    588 }
    589