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 "clang/Frontend/Utils.h"
  17 #include "llvm/ADT/StringExtras.h"
  18 #include "llvm/ADT/StringSwitch.h"
  19 #include "llvm/Analysis/TargetLibraryInfo.h"
  20 #include "llvm/Analysis/TargetTransformInfo.h"
  21 #include "llvm/Bitcode/BitcodeWriterPass.h"
  22 #include "llvm/CodeGen/RegAllocRegistry.h"
  23 #include "llvm/CodeGen/SchedulerRegistry.h"
  24 #include "llvm/IR/DataLayout.h"
  25 #include "llvm/IR/FunctionInfo.h"
  26 #include "llvm/IR/IRPrintingPasses.h"
  27 #include "llvm/IR/LegacyPassManager.h"
  28 #include "llvm/IR/Module.h"
  29 #include "llvm/IR/Verifier.h"
  30 #include "llvm/MC/SubtargetFeature.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Support/PrettyStackTrace.h"
  33 #include "llvm/Support/TargetRegistry.h"
  34 #include "llvm/Support/Timer.h"
  35 #include "llvm/Support/raw_ostream.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Target/TargetOptions.h"
  38 #include "llvm/Target/TargetSubtargetInfo.h"
  39 #include "llvm/Transforms/IPO.h"
  40 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
  41 #include "llvm/Transforms/Instrumentation.h"
  42 #include "llvm/Transforms/ObjCARC.h"
  43 #include "llvm/Transforms/Scalar.h"
  44 #include "llvm/Transforms/Utils/SymbolRewriter.h"
  45 #include <memory>
  46 using namespace clang;
  47 using namespace llvm;
  48
  49 namespace {
  50
  51 class EmitAssemblyHelper {
  52   DiagnosticsEngine &Diags;
  53   const CodeGenOptions &CodeGenOpts;
  54   const clang::TargetOptions &TargetOpts;
  55   const LangOptions &LangOpts;
  56   Module *TheModule;
  57   std::unique_ptr<FunctionInfoIndex> FunctionIndex;
  58
  59   Timer CodeGenerationTime;
  60
  61   mutable legacy::PassManager *CodeGenPasses;
  62   mutable legacy::PassManager *PerModulePasses;
  63   mutable legacy::FunctionPassManager *PerFunctionPasses;
  64
  65 private:
  66   TargetIRAnalysis getTargetIRAnalysis() const {
  67     if (TM)
  68       return TM->getTargetIRAnalysis();
  69
  70     return TargetIRAnalysis();
  71   }
  72
  73   legacy::PassManager *getCodeGenPasses() const {
  74     if (!CodeGenPasses) {
  75       CodeGenPasses = new legacy::PassManager();
  76       CodeGenPasses->add(
  77           createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
  78     }
  79     return CodeGenPasses;
  80   }
  81
  82   legacy::PassManager *getPerModulePasses() const {
  83     if (!PerModulePasses) {
  84       PerModulePasses = new legacy::PassManager();
  85       PerModulePasses->add(
  86           createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
  87     }
  88     return PerModulePasses;
  89   }
  90
  91   legacy::FunctionPassManager *getPerFunctionPasses() const {
  92     if (!PerFunctionPasses) {
  93       PerFunctionPasses = new legacy::FunctionPassManager(TheModule);
  94       PerFunctionPasses->add(
  95           createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
  96     }
  97     return PerFunctionPasses;
  98   }
  99
 100   void CreatePasses();
 101
 102   /// Generates the TargetMachine.
 103   /// Returns Null if it is unable to create the target machine.
 104   /// Some of our clang tests specify triples which are not built
 105   /// into clang. This is okay because these tests check the generated
 106   /// IR, and they require DataLayout which depends on the triple.
 107   /// In this case, we allow this method to fail and not report an error.
 108   /// When MustCreateTM is used, we print an error if we are unable to load
 109   /// the requested target.
 110   TargetMachine *CreateTargetMachine(bool MustCreateTM);
 111
 112   /// Add passes necessary to emit assembly or LLVM IR.
 113   ///
 114   /// \return True on success.
 115   bool AddEmitPasses(BackendAction Action, raw_pwrite_stream &OS);
 116
 117 public:
 118   EmitAssemblyHelper(DiagnosticsEngine &_Diags, const CodeGenOptions &CGOpts,
 119                      const clang::TargetOptions &TOpts,
 120                      const LangOptions &LOpts, Module *M,
 121                      std::unique_ptr<FunctionInfoIndex> Index)
 122       : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
 123         TheModule(M), FunctionIndex(std::move(Index)),
 124         CodeGenerationTime("Code Generation Time"), CodeGenPasses(nullptr),
 125         PerModulePasses(nullptr), PerFunctionPasses(nullptr) {}
 126
 127   ~EmitAssemblyHelper() {
 128     delete CodeGenPasses;
 129     delete PerModulePasses;
 130     delete PerFunctionPasses;
 131     if (CodeGenOpts.DisableFree)
 132       BuryPointer(std::move(TM));
 133   }
 134
 135   std::unique_ptr<TargetMachine> TM;
 136
 137   void EmitAssembly(BackendAction Action, raw_pwrite_stream *OS);
 138 };
 139
 140 // We need this wrapper to access LangOpts and CGOpts from extension functions
 141 // that we add to the PassManagerBuilder.
 142 class PassManagerBuilderWrapper : public PassManagerBuilder {
 143 public:
 144   PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
 145                             const LangOptions &LangOpts)
 146       : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
 147   const CodeGenOptions &getCGOpts() const { return CGOpts; }
 148   const LangOptions &getLangOpts() const { return LangOpts; }
 149 private:
 150   const CodeGenOptions &CGOpts;
 151   const LangOptions &LangOpts;
 152 };
 153
 154 }
 155
 156 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 157   if (Builder.OptLevel > 0)
 158     PM.add(createObjCARCAPElimPass());
 159 }
 160
 161 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 162   if (Builder.OptLevel > 0)
 163     PM.add(createObjCARCExpandPass());
 164 }
 165
 166 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 167   if (Builder.OptLevel > 0)
 168     PM.add(createObjCARCOptPass());
 169 }
 170
 171 static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder,
 172                                      legacy::PassManagerBase &PM) {
 173   PM.add(createAddDiscriminatorsPass());
 174 }
 175
 176 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
 177                                     legacy::PassManagerBase &PM) {
 178   PM.add(createBoundsCheckingPass());
 179 }
 180
 181 static void addSanitizerCoveragePass(const PassManagerBuilder &Builder,
 182                                      legacy::PassManagerBase &PM) {
 183   const PassManagerBuilderWrapper &BuilderWrapper =
 184       static_cast<const PassManagerBuilderWrapper&>(Builder);
 185   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 186   SanitizerCoverageOptions Opts;
 187   Opts.CoverageType =
 188       static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
 189   Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
 190   Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
 191   Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
 192   Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
 193   PM.add(createSanitizerCoverageModulePass(Opts));
 194 }
 195
 196 static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
 197                                       legacy::PassManagerBase &PM) {
 198   const PassManagerBuilderWrapper &BuilderWrapper =
 199       static_cast<const PassManagerBuilderWrapper&>(Builder);
 200   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 201   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Address);
 202   PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/false, Recover));
 203   PM.add(createAddressSanitizerModulePass(/*CompileKernel*/false, Recover));
 204 }
 205
 206 static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder,
 207                                             legacy::PassManagerBase &PM) {
 208   PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/true,
 209                                             /*Recover*/true));
 210   PM.add(createAddressSanitizerModulePass(/*CompileKernel*/true,
 211                                           /*Recover*/true));
 212 }
 213
 214 static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
 215                                    legacy::PassManagerBase &PM) {
 216   const PassManagerBuilderWrapper &BuilderWrapper =
 217       static_cast<const PassManagerBuilderWrapper&>(Builder);
 218   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 219   PM.add(createMemorySanitizerPass(CGOpts.SanitizeMemoryTrackOrigins));
 220
 221   // MemorySanitizer inserts complex instrumentation that mostly follows
 222   // the logic of the original code, but operates on "shadow" values.
 223   // It can benefit from re-running some general purpose optimization passes.
 224   if (Builder.OptLevel > 0) {
 225     PM.add(createEarlyCSEPass());
 226     PM.add(createReassociatePass());
 227     PM.add(createLICMPass());
 228     PM.add(createGVNPass());
 229     PM.add(createInstructionCombiningPass());
 230     PM.add(createDeadStoreEliminationPass());
 231   }
 232 }
 233
 234 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
 235                                    legacy::PassManagerBase &PM) {
 236   PM.add(createThreadSanitizerPass());
 237 }
 238
 239 static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
 240                                      legacy::PassManagerBase &PM) {
 241   const PassManagerBuilderWrapper &BuilderWrapper =
 242       static_cast<const PassManagerBuilderWrapper&>(Builder);
 243   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
 244   PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
 245 }
 246
 247 static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
 248                                          const CodeGenOptions &CodeGenOpts) {
 249   TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);
 250   if (!CodeGenOpts.SimplifyLibCalls)
 251     TLII->disableAllFunctions();
 252
 253   switch (CodeGenOpts.getVecLib()) {
 254   case CodeGenOptions::Accelerate:
 255     TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
 256     break;
 257   default:
 258     break;
 259   }
 260   return TLII;
 261 }
 262
 263 static void addSymbolRewriterPass(const CodeGenOptions &Opts,
 264                                   legacy::PassManager *MPM) {
 265   llvm::SymbolRewriter::RewriteDescriptorList DL;
 266
 267   llvm::SymbolRewriter::RewriteMapParser MapParser;
 268   for (const auto &MapFile : Opts.RewriteMapFiles)
 269     MapParser.parse(MapFile, &DL);
 270
 271   MPM->add(createRewriteSymbolsPass(DL));
 272 }
 273
 274 void EmitAssemblyHelper::CreatePasses() {
 275   if (CodeGenOpts.DisableLLVMPasses)
 276     return;
 277
 278   unsigned OptLevel = CodeGenOpts.OptimizationLevel;
 279   CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
 280
 281   // Handle disabling of LLVM optimization, where we want to preserve the
 282   // internal module before any optimization.
 283   if (CodeGenOpts.DisableLLVMOpts) {
 284     OptLevel = 0;
 285     Inlining = CodeGenOpts.NoInlining;
 286   }
 287
 288   PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
 289
 290   // Figure out TargetLibraryInfo.
 291   Triple TargetTriple(TheModule->getTargetTriple());
 292   PMBuilder.LibraryInfo = createTLII(TargetTriple, CodeGenOpts);
 293
 294   switch (Inlining) {
 295   case CodeGenOptions::NoInlining:
 296     break;
 297   case CodeGenOptions::NormalInlining: {
 298     PMBuilder.Inliner =
 299         createFunctionInliningPass(OptLevel, CodeGenOpts.OptimizeSize);
 300     break;
 301   }
 302   case CodeGenOptions::OnlyAlwaysInlining:
 303     // Respect always_inline.
 304     if (OptLevel == 0)
 305       // Do not insert lifetime intrinsics at -O0.
 306       PMBuilder.Inliner = createAlwaysInlinerPass(false);
 307     else
 308       PMBuilder.Inliner = createAlwaysInlinerPass();
 309     break;
 310   }
 311
 312   PMBuilder.OptLevel = OptLevel;
 313   PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
 314   PMBuilder.BBVectorize = CodeGenOpts.VectorizeBB;
 315   PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
 316   PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
 317
 318   PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
 319   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
 320   PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
 321   PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
 322   PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;
 323
 324   legacy::PassManager *MPM = getPerModulePasses();
 325
 326   // If we are performing a ThinLTO importing compile, invoke the LTO
 327   // pipeline and pass down the in-memory function index.
 328   if (!CodeGenOpts.ThinLTOIndexFile.empty()) {
 329     assert(FunctionIndex && "Expected non-empty function index");
 330     PMBuilder.FunctionIndex = FunctionIndex.get();
 331     PMBuilder.populateLTOPassManager(*MPM);
 332     return;
 333   }
 334
 335   PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 336                          addAddDiscriminatorsPass);
 337
 338   // In ObjC ARC mode, add the main ARC optimization passes.
 339   if (LangOpts.ObjCAutoRefCount) {
 340     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 341                            addObjCARCExpandPass);
 342     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
 343                            addObjCARCAPElimPass);
 344     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 345                            addObjCARCOptPass);
 346   }
 347
 348   if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
 349     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 350                            addBoundsCheckingPass);
 351     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 352                            addBoundsCheckingPass);
 353   }
 354
 355   if (CodeGenOpts.SanitizeCoverageType ||
 356       CodeGenOpts.SanitizeCoverageIndirectCalls ||
 357       CodeGenOpts.SanitizeCoverageTraceCmp) {
 358     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 359                            addSanitizerCoveragePass);
 360     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 361                            addSanitizerCoveragePass);
 362   }
 363
 364   if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
 365     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 366                            addAddressSanitizerPasses);
 367     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 368                            addAddressSanitizerPasses);
 369   }
 370
 371   if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
 372     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 373                            addKernelAddressSanitizerPasses);
 374     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 375                            addKernelAddressSanitizerPasses);
 376   }
 377
 378   if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
 379     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 380                            addMemorySanitizerPass);
 381     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 382                            addMemorySanitizerPass);
 383   }
 384
 385   if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
 386     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 387                            addThreadSanitizerPass);
 388     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 389                            addThreadSanitizerPass);
 390   }
 391
 392   if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
 393     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 394                            addDataFlowSanitizerPass);
 395     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 396                            addDataFlowSanitizerPass);
 397   }
 398
 399   // Set up the per-function pass manager.
 400   legacy::FunctionPassManager *FPM = getPerFunctionPasses();
 401   if (CodeGenOpts.VerifyModule)
 402     FPM->add(createVerifierPass());
 403   PMBuilder.populateFunctionPassManager(*FPM);
 404
 405   // Set up the per-module pass manager.
 406   if (!CodeGenOpts.RewriteMapFiles.empty())
 407     addSymbolRewriterPass(CodeGenOpts, MPM);
 408
 409   if (!CodeGenOpts.DisableGCov &&
 410       (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
 411     // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
 412     // LLVM's -default-gcov-version flag is set to something invalid.
 413     GCOVOptions Options;
 414     Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
 415     Options.EmitData = CodeGenOpts.EmitGcovArcs;
 416     memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
 417     Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
 418     Options.NoRedZone = CodeGenOpts.DisableRedZone;
 419     Options.FunctionNamesInData =
 420         !CodeGenOpts.CoverageNoFunctionNamesInData;
 421     Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
 422     MPM->add(createGCOVProfilerPass(Options));
 423     if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
 424       MPM->add(createStripSymbolsPass(true));
 425   }
 426
 427   if (CodeGenOpts.ProfileInstrGenerate) {
 428     InstrProfOptions Options;
 429     Options.NoRedZone = CodeGenOpts.DisableRedZone;
 430     Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
 431     MPM->add(createInstrProfilingPass(Options));
 432   }
 433
 434   if (!CodeGenOpts.SampleProfileFile.empty())
 435     MPM->add(createSampleProfileLoaderPass(CodeGenOpts.SampleProfileFile));
 436
 437   PMBuilder.populateModulePassManager(*MPM);
 438 }
 439
 440 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 441   // Create the TargetMachine for generating code.
 442   std::string Error;
 443   std::string Triple = TheModule->getTargetTriple();
 444   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
 445   if (!TheTarget) {
 446     if (MustCreateTM)
 447       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
 448     return nullptr;
 449   }
 450
 451   unsigned CodeModel =
 452     llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
 453       .Case("small", llvm::CodeModel::Small)
 454       .Case("kernel", llvm::CodeModel::Kernel)
 455       .Case("medium", llvm::CodeModel::Medium)
 456       .Case("large", llvm::CodeModel::Large)
 457       .Case("default", llvm::CodeModel::Default)
 458       .Default(~0u);
 459   assert(CodeModel != ~0u && "invalid code model!");
 460   llvm::CodeModel::Model CM = static_cast<llvm::CodeModel::Model>(CodeModel);
 461
 462   SmallVector<const char *, 16> BackendArgs;
 463   BackendArgs.push_back("clang"); // Fake program name.
 464   if (!CodeGenOpts.DebugPass.empty()) {
 465     BackendArgs.push_back("-debug-pass");
 466     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
 467   }
 468   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
 469     BackendArgs.push_back("-limit-float-precision");
 470     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
 471   }
 472   for (const std::string &BackendOption : CodeGenOpts.BackendOptions)
 473     BackendArgs.push_back(BackendOption.c_str());
 474   BackendArgs.push_back(nullptr);
 475   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
 476                                     BackendArgs.data());
 477
 478   std::string FeaturesStr =
 479       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
 480
 481   // Keep this synced with the equivalent code in tools/driver/cc1as_main.cpp.
 482   llvm::Reloc::Model RM = llvm::Reloc::Default;
 483   if (CodeGenOpts.RelocationModel == "static") {
 484     RM = llvm::Reloc::Static;
 485   } else if (CodeGenOpts.RelocationModel == "pic") {
 486     RM = llvm::Reloc::PIC_;
 487   } else {
 488     assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
 489            "Invalid PIC model!");
 490     RM = llvm::Reloc::DynamicNoPIC;
 491   }
 492
 493   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
 494   switch (CodeGenOpts.OptimizationLevel) {
 495   default: break;
 496   case 0: OptLevel = CodeGenOpt::None; break;
 497   case 3: OptLevel = CodeGenOpt::Aggressive; break;
 498   }
 499
 500   llvm::TargetOptions Options;
 501
 502   if (!TargetOpts.Reciprocals.empty())
 503     Options.Reciprocals = TargetRecip(TargetOpts.Reciprocals);
 504
 505   Options.ThreadModel =
 506     llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
 507       .Case("posix", llvm::ThreadModel::POSIX)
 508       .Case("single", llvm::ThreadModel::Single);
 509
 510   // Set float ABI type.
 511   assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
 512           CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
 513          "Invalid Floating Point ABI!");
 514   Options.FloatABIType =
 515       llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
 516           .Case("soft", llvm::FloatABI::Soft)
 517           .Case("softfp", llvm::FloatABI::Soft)
 518           .Case("hard", llvm::FloatABI::Hard)
 519           .Default(llvm::FloatABI::Default);
 520
 521   // Set FP fusion mode.
 522   switch (CodeGenOpts.getFPContractMode()) {
 523   case CodeGenOptions::FPC_Off:
 524     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
 525     break;
 526   case CodeGenOptions::FPC_On:
 527     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
 528     break;
 529   case CodeGenOptions::FPC_Fast:
 530     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
 531     break;
 532   }
 533
 534   Options.UseInitArray = CodeGenOpts.UseInitArray;
 535   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
 536   Options.CompressDebugSections = CodeGenOpts.CompressDebugSections;
 537
 538   // Set EABI version.
 539   Options.EABIVersion = llvm::StringSwitch<llvm::EABI>(CodeGenOpts.EABIVersion)
 540                             .Case("4", llvm::EABI::EABI4)
 541                             .Case("5", llvm::EABI::EABI5)
 542                             .Case("gnu", llvm::EABI::GNU)
 543                             .Default(llvm::EABI::Default);
 544
 545   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
 546   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
 547   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
 548   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
 549   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
 550   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
 551   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
 552   Options.FunctionSections = CodeGenOpts.FunctionSections;
 553   Options.DataSections = CodeGenOpts.DataSections;
 554   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
 555   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
 556   switch (CodeGenOpts.getDebuggerTuning()) {
 557   case CodeGenOptions::DebuggerKindGDB:
 558     Options.DebuggerTuning = llvm::DebuggerKind::GDB;
 559     break;
 560   case CodeGenOptions::DebuggerKindLLDB:
 561     Options.DebuggerTuning = llvm::DebuggerKind::LLDB;
 562     break;
 563   case CodeGenOptions::DebuggerKindSCE:
 564     Options.DebuggerTuning = llvm::DebuggerKind::SCE;
 565     break;
 566   default:
 567     break;
 568   }
 569
 570   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
 571   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
 572   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
 573   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
 574   Options.MCOptions.MCIncrementalLinkerCompatible =
 575       CodeGenOpts.IncrementalLinkerCompatible;
 576   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
 577   Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
 578   Options.MCOptions.ABIName = TargetOpts.ABI;
 579
 580   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
 581                                                      FeaturesStr, Options,
 582                                                      RM, CM, OptLevel);
 583
 584   return TM;
 585 }
 586
 587 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
 588                                        raw_pwrite_stream &OS) {
 589
 590   // Create the code generator passes.
 591   legacy::PassManager *PM = getCodeGenPasses();
 592
 593   // Add LibraryInfo.
 594   llvm::Triple TargetTriple(TheModule->getTargetTriple());
 595   std::unique_ptr<TargetLibraryInfoImpl> TLII(
 596       createTLII(TargetTriple, CodeGenOpts));
 597   PM->add(new TargetLibraryInfoWrapperPass(*TLII));
 598
 599   // Normal mode, emit a .s or .o file by running the code generator. Note,
 600   // this also adds codegenerator level optimization passes.
 601   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
 602   if (Action == Backend_EmitObj)
 603     CGFT = TargetMachine::CGFT_ObjectFile;
 604   else if (Action == Backend_EmitMCNull)
 605     CGFT = TargetMachine::CGFT_Null;
 606   else
 607     assert(Action == Backend_EmitAssembly && "Invalid action!");
 608
 609   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
 610   // "codegen" passes so that it isn't run multiple times when there is
 611   // inlining happening.
 612   if (CodeGenOpts.OptimizationLevel > 0)
 613     PM->add(createObjCARCContractPass());
 614
 615   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
 616                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
 617     Diags.Report(diag::err_fe_unable_to_interface_with_target);
 618     return false;
 619   }
 620
 621   return true;
 622 }
 623
 624 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
 625                                       raw_pwrite_stream *OS) {
 626   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
 627
 628   bool UsesCodeGen = (Action != Backend_EmitNothing &&
 629                       Action != Backend_EmitBC &&
 630                       Action != Backend_EmitLL);
 631   if (!TM)
 632     TM.reset(CreateTargetMachine(UsesCodeGen));
 633
 634   if (UsesCodeGen && !TM)
 635     return;
 636   if (TM)
 637     TheModule->setDataLayout(TM->createDataLayout());
 638   CreatePasses();
 639
 640   switch (Action) {
 641   case Backend_EmitNothing:
 642     break;
 643
 644   case Backend_EmitBC:
 645     getPerModulePasses()->add(createBitcodeWriterPass(
 646         *OS, CodeGenOpts.EmitLLVMUseLists, CodeGenOpts.EmitFunctionSummary));
 647     break;
 648
 649   case Backend_EmitLL:
 650     getPerModulePasses()->add(
 651         createPrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
 652     break;
 653
 654   default:
 655     if (!AddEmitPasses(Action, *OS))
 656       return;
 657   }
 658
 659   // Before executing passes, print the final values of the LLVM options.
 660   cl::PrintOptionValues();
 661
 662   // Run passes. For now we do all passes at once, but eventually we
 663   // would like to have the option of streaming code generation.
 664
 665   if (PerFunctionPasses) {
 666     PrettyStackTraceString CrashInfo("Per-function optimization");
 667
 668     PerFunctionPasses->doInitialization();
 669     for (Function &F : *TheModule)
 670       if (!F.isDeclaration())
 671         PerFunctionPasses->run(F);
 672     PerFunctionPasses->doFinalization();
 673   }
 674
 675   if (PerModulePasses) {
 676     PrettyStackTraceString CrashInfo("Per-module optimization passes");
 677     PerModulePasses->run(*TheModule);
 678   }
 679
 680   if (CodeGenPasses) {
 681     PrettyStackTraceString CrashInfo("Code generation");
 682     CodeGenPasses->run(*TheModule);
 683   }
 684 }
 685
 686 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
 687                               const CodeGenOptions &CGOpts,
 688                               const clang::TargetOptions &TOpts,
 689                               const LangOptions &LOpts, StringRef TDesc,
 690                               Module *M, BackendAction Action,
 691                               raw_pwrite_stream *OS,
 692                               std::unique_ptr<FunctionInfoIndex> Index) {
 693   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M,
 694                                std::move(Index));
 695
 696   AsmHelper.EmitAssembly(Action, OS);
 697
 698   // If an optional clang TargetInfo description string was passed in, use it to
 699   // verify the LLVM TargetMachine's DataLayout.
 700   if (AsmHelper.TM && !TDesc.empty()) {
 701     std::string DLDesc = M->getDataLayout().getStringRepresentation();
 702     if (DLDesc != TDesc) {
 703       unsigned DiagID = Diags.getCustomDiagID(
 704           DiagnosticsEngine::Error, "backend data layout '%0' does not match "
 705                                     "expected target description '%1'");
 706       Diags.Report(DiagID) << DLDesc << TDesc;
 707     }
 708   }
 709 }