contrib/llvm/tools/clang/lib/CodeGen/BackendUtil.cpp

   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
 224   PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
 225   PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
 226   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
 227
 228   // In ObjC ARC mode, add the main ARC optimization passes.
 229   if (LangOpts.ObjCAutoRefCount) {
 230     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 231                            addObjCARCExpandPass);
 232     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
 233                            addObjCARCAPElimPass);
 234     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 235                            addObjCARCOptPass);
 236   }
 237
 238   if (LangOpts.Sanitize.Bounds) {
 239     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 240                            addBoundsCheckingPass);
 241     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 242                            addBoundsCheckingPass);
 243   }
 244
 245   if (LangOpts.Sanitize.Address) {
 246     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 247                            addAddressSanitizerPasses);
 248     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 249                            addAddressSanitizerPasses);
 250   }
 251
 252   if (LangOpts.Sanitize.Memory) {
 253     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 254                            addMemorySanitizerPass);
 255     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 256                            addMemorySanitizerPass);
 257   }
 258
 259   if (LangOpts.Sanitize.Thread) {
 260     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 261                            addThreadSanitizerPass);
 262     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 263                            addThreadSanitizerPass);
 264   }
 265
 266   // Figure out TargetLibraryInfo.
 267   Triple TargetTriple(TheModule->getTargetTriple());
 268   PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
 269   if (!CodeGenOpts.SimplifyLibCalls)
 270     PMBuilder.LibraryInfo->disableAllFunctions();
 271
 272   switch (Inlining) {
 273   case CodeGenOptions::NoInlining: break;
 274   case CodeGenOptions::NormalInlining: {
 275     // FIXME: Derive these constants in a principled fashion.
 276     unsigned Threshold = 225;
 277     if (CodeGenOpts.OptimizeSize == 1)      // -Os
 278       Threshold = 75;
 279     else if (CodeGenOpts.OptimizeSize == 2) // -Oz
 280       Threshold = 25;
 281     else if (OptLevel > 2)
 282       Threshold = 275;
 283     PMBuilder.Inliner = createFunctionInliningPass(Threshold);
 284     break;
 285   }
 286   case CodeGenOptions::OnlyAlwaysInlining:
 287     // Respect always_inline.
 288     if (OptLevel == 0)
 289       // Do not insert lifetime intrinsics at -O0.
 290       PMBuilder.Inliner = createAlwaysInlinerPass(false);
 291     else
 292       PMBuilder.Inliner = createAlwaysInlinerPass();
 293     break;
 294   }
 295
 296   // Set up the per-function pass manager.
 297   FunctionPassManager *FPM = getPerFunctionPasses(TM);
 298   if (CodeGenOpts.VerifyModule)
 299     FPM->add(createVerifierPass());
 300   PMBuilder.populateFunctionPassManager(*FPM);
 301
 302   // Set up the per-module pass manager.
 303   PassManager *MPM = getPerModulePasses(TM);
 304
 305   if (!CodeGenOpts.DisableGCov &&
 306       (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
 307     // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
 308     // LLVM's -default-gcov-version flag is set to something invalid.
 309     GCOVOptions Options;
 310     Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
 311     Options.EmitData = CodeGenOpts.EmitGcovArcs;
 312     memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
 313     Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
 314     Options.NoRedZone = CodeGenOpts.DisableRedZone;
 315     Options.FunctionNamesInData =
 316         !CodeGenOpts.CoverageNoFunctionNamesInData;
 317     MPM->add(createGCOVProfilerPass(Options));
 318     if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
 319       MPM->add(createStripSymbolsPass(true));
 320   }
 321
 322   PMBuilder.populateModulePassManager(*MPM);
 323 }
 324
 325 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 326   // Create the TargetMachine for generating code.
 327   std::string Error;
 328   std::string Triple = TheModule->getTargetTriple();
 329   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
 330   if (!TheTarget) {
 331     if (MustCreateTM)
 332       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
 333     return 0;
 334   }
 335
 336   // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
 337   // being gross, this is also totally broken if we ever care about
 338   // concurrency.
 339
 340   TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
 341
 342   TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
 343   TargetMachine::setDataSections    (CodeGenOpts.DataSections);
 344
 345   // FIXME: Parse this earlier.
 346   llvm::CodeModel::Model CM;
 347   if (CodeGenOpts.CodeModel == "small") {
 348     CM = llvm::CodeModel::Small;
 349   } else if (CodeGenOpts.CodeModel == "kernel") {
 350     CM = llvm::CodeModel::Kernel;
 351   } else if (CodeGenOpts.CodeModel == "medium") {
 352     CM = llvm::CodeModel::Medium;
 353   } else if (CodeGenOpts.CodeModel == "large") {
 354     CM = llvm::CodeModel::Large;
 355   } else {
 356     assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
 357     CM = llvm::CodeModel::Default;
 358   }
 359
 360   SmallVector<const char *, 16> BackendArgs;
 361   BackendArgs.push_back("clang"); // Fake program name.
 362   if (!CodeGenOpts.DebugPass.empty()) {
 363     BackendArgs.push_back("-debug-pass");
 364     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
 365   }
 366   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
 367     BackendArgs.push_back("-limit-float-precision");
 368     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
 369   }
 370   if (llvm::TimePassesIsEnabled)
 371     BackendArgs.push_back("-time-passes");
 372   for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
 373     BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
 374   if (CodeGenOpts.NoGlobalMerge)
 375     BackendArgs.push_back("-global-merge=false");
 376   BackendArgs.push_back(0);
 377   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
 378                                     BackendArgs.data());
 379
 380   std::string FeaturesStr;
 381   if (TargetOpts.Features.size()) {
 382     SubtargetFeatures Features;
 383     for (std::vector<std::string>::const_iterator
 384            it = TargetOpts.Features.begin(),
 385            ie = TargetOpts.Features.end(); it != ie; ++it)
 386       Features.AddFeature(*it);
 387     FeaturesStr = Features.getString();
 388   }
 389
 390   llvm::Reloc::Model RM = llvm::Reloc::Default;
 391   if (CodeGenOpts.RelocationModel == "static") {
 392     RM = llvm::Reloc::Static;
 393   } else if (CodeGenOpts.RelocationModel == "pic") {
 394     RM = llvm::Reloc::PIC_;
 395   } else {
 396     assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
 397            "Invalid PIC model!");
 398     RM = llvm::Reloc::DynamicNoPIC;
 399   }
 400
 401   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
 402   switch (CodeGenOpts.OptimizationLevel) {
 403   default: break;
 404   case 0: OptLevel = CodeGenOpt::None; break;
 405   case 3: OptLevel = CodeGenOpt::Aggressive; break;
 406   }
 407
 408   llvm::TargetOptions Options;
 409
 410   // Set frame pointer elimination mode.
 411   if (!CodeGenOpts.DisableFPElim) {
 412     Options.NoFramePointerElim = false;
 413     Options.NoFramePointerElimNonLeaf = false;
 414   } else if (CodeGenOpts.OmitLeafFramePointer) {
 415     Options.NoFramePointerElim = false;
 416     Options.NoFramePointerElimNonLeaf = true;
 417   } else {
 418     Options.NoFramePointerElim = true;
 419     Options.NoFramePointerElimNonLeaf = true;
 420   }
 421
 422   if (CodeGenOpts.UseInitArray)
 423     Options.UseInitArray = true;
 424
 425   // Set float ABI type.
 426   if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
 427     Options.FloatABIType = llvm::FloatABI::Soft;
 428   else if (CodeGenOpts.FloatABI == "hard")
 429     Options.FloatABIType = llvm::FloatABI::Hard;
 430   else {
 431     assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
 432     Options.FloatABIType = llvm::FloatABI::Default;
 433   }
 434
 435   // Set FP fusion mode.
 436   switch (CodeGenOpts.getFPContractMode()) {
 437   case CodeGenOptions::FPC_Off:
 438     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
 439     break;
 440   case CodeGenOptions::FPC_On:
 441     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
 442     break;
 443   case CodeGenOptions::FPC_Fast:
 444     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
 445     break;
 446   }
 447
 448   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
 449   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
 450   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
 451   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
 452   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
 453   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
 454   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
 455   Options.RealignStack = CodeGenOpts.StackRealignment;
 456   Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
 457   Options.TrapFuncName = CodeGenOpts.TrapFuncName;
 458   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
 459   Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
 460   Options.EnableSegmentedStacks = CodeGenOpts.EnableSegmentedStacks;
 461
 462   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
 463                                                      FeaturesStr, Options,
 464                                                      RM, CM, OptLevel);
 465
 466   if (CodeGenOpts.RelaxAll)
 467     TM->setMCRelaxAll(true);
 468   if (CodeGenOpts.SaveTempLabels)
 469     TM->setMCSaveTempLabels(true);
 470   if (CodeGenOpts.NoDwarf2CFIAsm)
 471     TM->setMCUseCFI(false);
 472   if (!CodeGenOpts.NoDwarfDirectoryAsm)
 473     TM->setMCUseDwarfDirectory(true);
 474   if (CodeGenOpts.NoExecStack)
 475     TM->setMCNoExecStack(true);
 476
 477   return TM;
 478 }
 479
 480 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
 481                                        formatted_raw_ostream &OS,
 482                                        TargetMachine *TM) {
 483
 484   // Create the code generator passes.
 485   PassManager *PM = getCodeGenPasses(TM);
 486
 487   // Add LibraryInfo.
 488   llvm::Triple TargetTriple(TheModule->getTargetTriple());
 489   TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
 490   if (!CodeGenOpts.SimplifyLibCalls)
 491     TLI->disableAllFunctions();
 492   PM->add(TLI);
 493
 494   // Add Target specific analysis passes.
 495   TM->addAnalysisPasses(*PM);
 496
 497   // Normal mode, emit a .s or .o file by running the code generator. Note,
 498   // this also adds codegenerator level optimization passes.
 499   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
 500   if (Action == Backend_EmitObj)
 501     CGFT = TargetMachine::CGFT_ObjectFile;
 502   else if (Action == Backend_EmitMCNull)
 503     CGFT = TargetMachine::CGFT_Null;
 504   else
 505     assert(Action == Backend_EmitAssembly && "Invalid action!");
 506
 507   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
 508   // "codegen" passes so that it isn't run multiple times when there is
 509   // inlining happening.
 510   if (LangOpts.ObjCAutoRefCount &&
 511       CodeGenOpts.OptimizationLevel > 0)
 512     PM->add(createObjCARCContractPass());
 513
 514   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
 515                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
 516     Diags.Report(diag::err_fe_unable_to_interface_with_target);
 517     return false;
 518   }
 519
 520   return true;
 521 }
 522
 523 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
 524   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
 525   llvm::formatted_raw_ostream FormattedOS;
 526
 527   bool UsesCodeGen = (Action != Backend_EmitNothing &&
 528                       Action != Backend_EmitBC &&
 529                       Action != Backend_EmitLL);
 530   TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
 531   if (UsesCodeGen && !TM) return;
 532   CreatePasses(TM);
 533
 534   switch (Action) {
 535   case Backend_EmitNothing:
 536     break;
 537
 538   case Backend_EmitBC:
 539     getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
 540     break;
 541
 542   case Backend_EmitLL:
 543     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
 544     getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
 545     break;
 546
 547   default:
 548     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
 549     if (!AddEmitPasses(Action, FormattedOS, TM))
 550       return;
 551   }
 552
 553   // Before executing passes, print the final values of the LLVM options.
 554   cl::PrintOptionValues();
 555
 556   // Run passes. For now we do all passes at once, but eventually we
 557   // would like to have the option of streaming code generation.
 558
 559   if (PerFunctionPasses) {
 560     PrettyStackTraceString CrashInfo("Per-function optimization");
 561
 562     PerFunctionPasses->doInitialization();
 563     for (Module::iterator I = TheModule->begin(),
 564            E = TheModule->end(); I != E; ++I)
 565       if (!I->isDeclaration())
 566         PerFunctionPasses->run(*I);
 567     PerFunctionPasses->doFinalization();
 568   }
 569
 570   if (PerModulePasses) {
 571     PrettyStackTraceString CrashInfo("Per-module optimization passes");
 572     PerModulePasses->run(*TheModule);
 573   }
 574
 575   if (CodeGenPasses) {
 576     PrettyStackTraceString CrashInfo("Code generation");
 577     CodeGenPasses->run(*TheModule);
 578   }
 579 }
 580
 581 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
 582                               const CodeGenOptions &CGOpts,
 583                               const clang::TargetOptions &TOpts,
 584                               const LangOptions &LOpts,
 585                               Module *M,
 586                               BackendAction Action, raw_ostream *OS) {
 587   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
 588
 589   AsmHelper.EmitAssembly(Action, OS);
 590 }