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 "clang/Lex/HeaderSearchOptions.h"
  18 #include "llvm/ADT/SmallSet.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/ADT/StringSwitch.h"
  21 #include "llvm/ADT/Triple.h"
  22 #include "llvm/Analysis/TargetLibraryInfo.h"
  23 #include "llvm/Analysis/TargetTransformInfo.h"
  24 #include "llvm/Bitcode/BitcodeReader.h"
  25 #include "llvm/Bitcode/BitcodeWriter.h"
  26 #include "llvm/Bitcode/BitcodeWriterPass.h"
  27 #include "llvm/CodeGen/RegAllocRegistry.h"
  28 #include "llvm/CodeGen/SchedulerRegistry.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/IRPrintingPasses.h"
  31 #include "llvm/IR/LegacyPassManager.h"
  32 #include "llvm/IR/Module.h"
  33 #include "llvm/IR/ModuleSummaryIndex.h"
  34 #include "llvm/IR/Verifier.h"
  35 #include "llvm/LTO/LTOBackend.h"
  36 #include "llvm/MC/MCAsmInfo.h"
  37 #include "llvm/MC/SubtargetFeature.h"
  38 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
  39 #include "llvm/Passes/PassBuilder.h"
  40 #include "llvm/Support/CommandLine.h"
  41 #include "llvm/Support/MemoryBuffer.h"
  42 #include "llvm/Support/PrettyStackTrace.h"
  43 #include "llvm/Support/TargetRegistry.h"
  44 #include "llvm/Support/Timer.h"
  45 #include "llvm/Support/raw_ostream.h"
  46 #include "llvm/Target/TargetMachine.h"
  47 #include "llvm/Target/TargetOptions.h"
  48 #include "llvm/Target/TargetSubtargetInfo.h"
  49 #include "llvm/Transforms/Coroutines.h"
  50 #include "llvm/Transforms/IPO.h"
  51 #include "llvm/Transforms/IPO/AlwaysInliner.h"
  52 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
  53 #include "llvm/Transforms/Instrumentation.h"
  54 #include "llvm/Transforms/ObjCARC.h"
  55 #include "llvm/Transforms/Scalar.h"
  56 #include "llvm/Transforms/Scalar/GVN.h"
  57 #include "llvm/Transforms/Utils/SymbolRewriter.h"
  58 #include <memory>
  59 using namespace clang;
  60 using namespace llvm;
  61
  62 namespace {
  63
  64 class EmitAssemblyHelper {
  65   DiagnosticsEngine &Diags;
  66   const HeaderSearchOptions &HSOpts;
  67   const CodeGenOptions &CodeGenOpts;
  68   const clang::TargetOptions &TargetOpts;
  69   const LangOptions &LangOpts;
  70   Module *TheModule;
  71
  72   Timer CodeGenerationTime;
  73
  74   std::unique_ptr<raw_pwrite_stream> OS;
  75
  76 private:
  77   TargetIRAnalysis getTargetIRAnalysis() const {
  78     if (TM)
  79       return TM->getTargetIRAnalysis();
  80
  81     return TargetIRAnalysis();
  82   }
  83
  84   /// Set LLVM command line options passed through -backend-option.
  85   void setCommandLineOpts();
  86
  87   void CreatePasses(legacy::PassManager &MPM, legacy::FunctionPassManager &FPM);
  88
  89   /// Generates the TargetMachine.
  90   /// Leaves TM unchanged if it is unable to create the target machine.
  91   /// Some of our clang tests specify triples which are not built
  92   /// into clang. This is okay because these tests check the generated
  93   /// IR, and they require DataLayout which depends on the triple.
  94   /// In this case, we allow this method to fail and not report an error.
  95   /// When MustCreateTM is used, we print an error if we are unable to load
  96   /// the requested target.
  97   void CreateTargetMachine(bool MustCreateTM);
  98
  99   /// Add passes necessary to emit assembly or LLVM IR.
 100   ///
 101   /// \return True on success.
 102   bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
 103                      raw_pwrite_stream &OS);
 104
 105 public:
 106   EmitAssemblyHelper(DiagnosticsEngine &_Diags,
 107                      const HeaderSearchOptions &HeaderSearchOpts,
 108                      const CodeGenOptions &CGOpts,
 109                      const clang::TargetOptions &TOpts,
 110                      const LangOptions &LOpts, Module *M)
 111       : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
 112         TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
 113         CodeGenerationTime("codegen", "Code Generation Time") {}
 114
 115   ~EmitAssemblyHelper() {
 116     if (CodeGenOpts.DisableFree)
 117       BuryPointer(std::move(TM));
 118   }
 119
 120   std::unique_ptr<TargetMachine> TM;
 121
 122   void EmitAssembly(BackendAction Action,
 123                     std::unique_ptr<raw_pwrite_stream> OS);
 124
 125   void EmitAssemblyWithNewPassManager(BackendAction Action,
 126                                       std::unique_ptr<raw_pwrite_stream> OS);
 127 };
 128
 129 // We need this wrapper to access LangOpts and CGOpts from extension functions
 130 // that we add to the PassManagerBuilder.
 131 class PassManagerBuilderWrapper : public PassManagerBuilder {
 132 public:
 133   PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
 134                             const LangOptions &LangOpts)
 135       : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
 136   const CodeGenOptions &getCGOpts() const { return CGOpts; }
 137   const LangOptions &getLangOpts() const { return LangOpts; }
 138 private:
 139   const CodeGenOptions &CGOpts;
 140   const LangOptions &LangOpts;
 141 };
 142
 143 }
 144
 145 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 146   if (Builder.OptLevel > 0)
 147     PM.add(createObjCARCAPElimPass());
 148 }
 149
 150 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 151   if (Builder.OptLevel > 0)
 152     PM.add(createObjCARCExpandPass());
 153 }
 154
 155 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 156   if (Builder.OptLevel > 0)
 157     PM.add(createObjCARCOptPass());
 158 }
 159
 160 static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder,
 161                                      legacy::PassManagerBase &PM) {
 162   PM.add(createAddDiscriminatorsPass());
 163 }
 164
 165 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
 166                                   legacy::PassManagerBase &PM) {
 167   PM.add(createBoundsCheckingPass());
 168 }
 169
 170 static void addSanitizerCoveragePass(const PassManagerBuilder &Builder,
 171                                      legacy::PassManagerBase &PM) {
 172   const PassManagerBuilderWrapper &BuilderWrapper =
 173       static_cast<const PassManagerBuilderWrapper&>(Builder);
 174   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 175   SanitizerCoverageOptions Opts;
 176   Opts.CoverageType =
 177       static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
 178   Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
 179   Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
 180   Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
 181   Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
 182   Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
 183   Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
 184   Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
 185   Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
 186   PM.add(createSanitizerCoverageModulePass(Opts));
 187 }
 188
 189 static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
 190                                       legacy::PassManagerBase &PM) {
 191   const PassManagerBuilderWrapper &BuilderWrapper =
 192       static_cast<const PassManagerBuilderWrapper&>(Builder);
 193   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 194   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Address);
 195   bool UseAfterScope = CGOpts.SanitizeAddressUseAfterScope;
 196   PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/ false, Recover,
 197                                             UseAfterScope));
 198   PM.add(createAddressSanitizerModulePass(/*CompileKernel*/false, Recover));
 199 }
 200
 201 static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder,
 202                                             legacy::PassManagerBase &PM) {
 203   PM.add(createAddressSanitizerFunctionPass(
 204       /*CompileKernel*/ true,
 205       /*Recover*/ true, /*UseAfterScope*/ false));
 206   PM.add(createAddressSanitizerModulePass(/*CompileKernel*/true,
 207                                           /*Recover*/true));
 208 }
 209
 210 static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
 211                                    legacy::PassManagerBase &PM) {
 212   const PassManagerBuilderWrapper &BuilderWrapper =
 213       static_cast<const PassManagerBuilderWrapper&>(Builder);
 214   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
 215   int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
 216   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Memory);
 217   PM.add(createMemorySanitizerPass(TrackOrigins, Recover));
 218
 219   // MemorySanitizer inserts complex instrumentation that mostly follows
 220   // the logic of the original code, but operates on "shadow" values.
 221   // It can benefit from re-running some general purpose optimization passes.
 222   if (Builder.OptLevel > 0) {
 223     PM.add(createEarlyCSEPass());
 224     PM.add(createReassociatePass());
 225     PM.add(createLICMPass());
 226     PM.add(createGVNPass());
 227     PM.add(createInstructionCombiningPass());
 228     PM.add(createDeadStoreEliminationPass());
 229   }
 230 }
 231
 232 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
 233                                    legacy::PassManagerBase &PM) {
 234   PM.add(createThreadSanitizerPass());
 235 }
 236
 237 static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
 238                                      legacy::PassManagerBase &PM) {
 239   const PassManagerBuilderWrapper &BuilderWrapper =
 240       static_cast<const PassManagerBuilderWrapper&>(Builder);
 241   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
 242   PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
 243 }
 244
 245 static void addEfficiencySanitizerPass(const PassManagerBuilder &Builder,
 246                                        legacy::PassManagerBase &PM) {
 247   const PassManagerBuilderWrapper &BuilderWrapper =
 248       static_cast<const PassManagerBuilderWrapper&>(Builder);
 249   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
 250   EfficiencySanitizerOptions Opts;
 251   if (LangOpts.Sanitize.has(SanitizerKind::EfficiencyCacheFrag))
 252     Opts.ToolType = EfficiencySanitizerOptions::ESAN_CacheFrag;
 253   else if (LangOpts.Sanitize.has(SanitizerKind::EfficiencyWorkingSet))
 254     Opts.ToolType = EfficiencySanitizerOptions::ESAN_WorkingSet;
 255   PM.add(createEfficiencySanitizerPass(Opts));
 256 }
 257
 258 static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
 259                                          const CodeGenOptions &CodeGenOpts) {
 260   TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);
 261   if (!CodeGenOpts.SimplifyLibCalls)
 262     TLII->disableAllFunctions();
 263   else {
 264     // Disable individual libc/libm calls in TargetLibraryInfo.
 265     LibFunc::Func F;
 266     for (auto &FuncName : CodeGenOpts.getNoBuiltinFuncs())
 267       if (TLII->getLibFunc(FuncName, F))
 268         TLII->setUnavailable(F);
 269   }
 270
 271   switch (CodeGenOpts.getVecLib()) {
 272   case CodeGenOptions::Accelerate:
 273     TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
 274     break;
 275   case CodeGenOptions::SVML:
 276     TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
 277     break;
 278   default:
 279     break;
 280   }
 281   return TLII;
 282 }
 283
 284 static void addSymbolRewriterPass(const CodeGenOptions &Opts,
 285                                   legacy::PassManager *MPM) {
 286   llvm::SymbolRewriter::RewriteDescriptorList DL;
 287
 288   llvm::SymbolRewriter::RewriteMapParser MapParser;
 289   for (const auto &MapFile : Opts.RewriteMapFiles)
 290     MapParser.parse(MapFile, &DL);
 291
 292   MPM->add(createRewriteSymbolsPass(DL));
 293 }
 294
 295 void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
 296                                       legacy::FunctionPassManager &FPM) {
 297   // Handle disabling of all LLVM passes, where we want to preserve the
 298   // internal module before any optimization.
 299   if (CodeGenOpts.DisableLLVMPasses)
 300     return;
 301
 302   PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
 303
 304   // Figure out TargetLibraryInfo.  This needs to be added to MPM and FPM
 305   // manually (and not via PMBuilder), since some passes (eg. InstrProfiling)
 306   // are inserted before PMBuilder ones - they'd get the default-constructed
 307   // TLI with an unknown target otherwise.
 308   Triple TargetTriple(TheModule->getTargetTriple());
 309   std::unique_ptr<TargetLibraryInfoImpl> TLII(
 310       createTLII(TargetTriple, CodeGenOpts));
 311
 312   // At O0 and O1 we only run the always inliner which is more efficient. At
 313   // higher optimization levels we run the normal inliner.
 314   if (CodeGenOpts.OptimizationLevel <= 1) {
 315     bool InsertLifetimeIntrinsics = (CodeGenOpts.OptimizationLevel != 0 &&
 316                                      !CodeGenOpts.DisableLifetimeMarkers);
 317     PMBuilder.Inliner = createAlwaysInlinerLegacyPass(InsertLifetimeIntrinsics);
 318   } else {
 319     PMBuilder.Inliner = createFunctionInliningPass(
 320         CodeGenOpts.OptimizationLevel, CodeGenOpts.OptimizeSize);
 321   }
 322
 323   PMBuilder.OptLevel = CodeGenOpts.OptimizationLevel;
 324   PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
 325   PMBuilder.BBVectorize = CodeGenOpts.VectorizeBB;
 326   PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
 327   PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
 328
 329   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
 330   PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
 331   PMBuilder.PrepareForThinLTO = CodeGenOpts.EmitSummaryIndex;
 332   PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
 333   PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;
 334
 335   MPM.add(new TargetLibraryInfoWrapperPass(*TLII));
 336
 337   // Add target-specific passes that need to run as early as possible.
 338   if (TM)
 339     PMBuilder.addExtension(
 340         PassManagerBuilder::EP_EarlyAsPossible,
 341         [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
 342           TM->addEarlyAsPossiblePasses(PM);
 343         });
 344
 345   PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 346                          addAddDiscriminatorsPass);
 347
 348   // In ObjC ARC mode, add the main ARC optimization passes.
 349   if (LangOpts.ObjCAutoRefCount) {
 350     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 351                            addObjCARCExpandPass);
 352     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
 353                            addObjCARCAPElimPass);
 354     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 355                            addObjCARCOptPass);
 356   }
 357
 358   if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
 359     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 360                            addBoundsCheckingPass);
 361     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 362                            addBoundsCheckingPass);
 363   }
 364
 365   if (CodeGenOpts.SanitizeCoverageType ||
 366       CodeGenOpts.SanitizeCoverageIndirectCalls ||
 367       CodeGenOpts.SanitizeCoverageTraceCmp) {
 368     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 369                            addSanitizerCoveragePass);
 370     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 371                            addSanitizerCoveragePass);
 372   }
 373
 374   if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
 375     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 376                            addAddressSanitizerPasses);
 377     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 378                            addAddressSanitizerPasses);
 379   }
 380
 381   if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
 382     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 383                            addKernelAddressSanitizerPasses);
 384     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 385                            addKernelAddressSanitizerPasses);
 386   }
 387
 388   if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
 389     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 390                            addMemorySanitizerPass);
 391     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 392                            addMemorySanitizerPass);
 393   }
 394
 395   if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
 396     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 397                            addThreadSanitizerPass);
 398     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 399                            addThreadSanitizerPass);
 400   }
 401
 402   if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
 403     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 404                            addDataFlowSanitizerPass);
 405     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 406                            addDataFlowSanitizerPass);
 407   }
 408
 409   if (LangOpts.CoroutinesTS)
 410     addCoroutinePassesToExtensionPoints(PMBuilder);
 411
 412   if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Efficiency)) {
 413     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 414                            addEfficiencySanitizerPass);
 415     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 416                            addEfficiencySanitizerPass);
 417   }
 418
 419   // Set up the per-function pass manager.
 420   FPM.add(new TargetLibraryInfoWrapperPass(*TLII));
 421   if (CodeGenOpts.VerifyModule)
 422     FPM.add(createVerifierPass());
 423
 424   // Set up the per-module pass manager.
 425   if (!CodeGenOpts.RewriteMapFiles.empty())
 426     addSymbolRewriterPass(CodeGenOpts, &MPM);
 427
 428   if (!CodeGenOpts.DisableGCov &&
 429       (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
 430     // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
 431     // LLVM's -default-gcov-version flag is set to something invalid.
 432     GCOVOptions Options;
 433     Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
 434     Options.EmitData = CodeGenOpts.EmitGcovArcs;
 435     memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
 436     Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
 437     Options.NoRedZone = CodeGenOpts.DisableRedZone;
 438     Options.FunctionNamesInData =
 439         !CodeGenOpts.CoverageNoFunctionNamesInData;
 440     Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
 441     MPM.add(createGCOVProfilerPass(Options));
 442     if (CodeGenOpts.getDebugInfo() == codegenoptions::NoDebugInfo)
 443       MPM.add(createStripSymbolsPass(true));
 444   }
 445
 446   if (CodeGenOpts.hasProfileClangInstr()) {
 447     InstrProfOptions Options;
 448     Options.NoRedZone = CodeGenOpts.DisableRedZone;
 449     Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
 450     MPM.add(createInstrProfilingLegacyPass(Options));
 451   }
 452   if (CodeGenOpts.hasProfileIRInstr()) {
 453     PMBuilder.EnablePGOInstrGen = true;
 454     if (!CodeGenOpts.InstrProfileOutput.empty())
 455       PMBuilder.PGOInstrGen = CodeGenOpts.InstrProfileOutput;
 456     else
 457       PMBuilder.PGOInstrGen = "default_%m.profraw";
 458   }
 459   if (CodeGenOpts.hasProfileIRUse())
 460     PMBuilder.PGOInstrUse = CodeGenOpts.ProfileInstrumentUsePath;
 461
 462   if (!CodeGenOpts.SampleProfileFile.empty())
 463     PMBuilder.PGOSampleUse = CodeGenOpts.SampleProfileFile;
 464
 465   PMBuilder.populateFunctionPassManager(FPM);
 466   PMBuilder.populateModulePassManager(MPM);
 467 }
 468
 469 void EmitAssemblyHelper::setCommandLineOpts() {
 470   SmallVector<const char *, 16> BackendArgs;
 471   BackendArgs.push_back("clang"); // Fake program name.
 472   if (!CodeGenOpts.DebugPass.empty()) {
 473     BackendArgs.push_back("-debug-pass");
 474     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
 475   }
 476   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
 477     BackendArgs.push_back("-limit-float-precision");
 478     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
 479   }
 480   for (const std::string &BackendOption : CodeGenOpts.BackendOptions)
 481     BackendArgs.push_back(BackendOption.c_str());
 482   BackendArgs.push_back(nullptr);
 483   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
 484                                     BackendArgs.data());
 485 }
 486
 487 void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 488   // Create the TargetMachine for generating code.
 489   std::string Error;
 490   std::string Triple = TheModule->getTargetTriple();
 491   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
 492   if (!TheTarget) {
 493     if (MustCreateTM)
 494       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
 495     return;
 496   }
 497
 498   unsigned CodeModel =
 499     llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
 500       .Case("small", llvm::CodeModel::Small)
 501       .Case("kernel", llvm::CodeModel::Kernel)
 502       .Case("medium", llvm::CodeModel::Medium)
 503       .Case("large", llvm::CodeModel::Large)
 504       .Case("default", llvm::CodeModel::Default)
 505       .Default(~0u);
 506   assert(CodeModel != ~0u && "invalid code model!");
 507   llvm::CodeModel::Model CM = static_cast<llvm::CodeModel::Model>(CodeModel);
 508
 509   std::string FeaturesStr =
 510       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
 511
 512   // Keep this synced with the equivalent code in tools/driver/cc1as_main.cpp.
 513   llvm::Optional<llvm::Reloc::Model> RM;
 514   RM = llvm::StringSwitch<llvm::Reloc::Model>(CodeGenOpts.RelocationModel)
 515            .Case("static", llvm::Reloc::Static)
 516            .Case("pic", llvm::Reloc::PIC_)
 517            .Case("ropi", llvm::Reloc::ROPI)
 518            .Case("rwpi", llvm::Reloc::RWPI)
 519            .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
 520            .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC);
 521   assert(RM.hasValue() && "invalid PIC model!");
 522
 523   CodeGenOpt::Level OptLevel;
 524   switch (CodeGenOpts.OptimizationLevel) {
 525   default:
 526     llvm_unreachable("Invalid optimization level!");
 527   case 0:
 528     OptLevel = CodeGenOpt::None;
 529     break;
 530   case 1:
 531     OptLevel = CodeGenOpt::Less;
 532     break;
 533   case 2:
 534     OptLevel = CodeGenOpt::Default;
 535     break; // O2/Os/Oz
 536   case 3:
 537     OptLevel = CodeGenOpt::Aggressive;
 538     break;
 539   }
 540
 541   llvm::TargetOptions Options;
 542
 543   Options.ThreadModel =
 544     llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
 545       .Case("posix", llvm::ThreadModel::POSIX)
 546       .Case("single", llvm::ThreadModel::Single);
 547
 548   // Set float ABI type.
 549   assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
 550           CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
 551          "Invalid Floating Point ABI!");
 552   Options.FloatABIType =
 553       llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
 554           .Case("soft", llvm::FloatABI::Soft)
 555           .Case("softfp", llvm::FloatABI::Soft)
 556           .Case("hard", llvm::FloatABI::Hard)
 557           .Default(llvm::FloatABI::Default);
 558
 559   // Set FP fusion mode.
 560   switch (CodeGenOpts.getFPContractMode()) {
 561   case CodeGenOptions::FPC_Off:
 562     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
 563     break;
 564   case CodeGenOptions::FPC_On:
 565     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
 566     break;
 567   case CodeGenOptions::FPC_Fast:
 568     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
 569     break;
 570   }
 571
 572   Options.UseInitArray = CodeGenOpts.UseInitArray;
 573   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
 574   Options.CompressDebugSections = CodeGenOpts.CompressDebugSections;
 575   Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
 576
 577   // Set EABI version.
 578   Options.EABIVersion = llvm::StringSwitch<llvm::EABI>(TargetOpts.EABIVersion)
 579                             .Case("4", llvm::EABI::EABI4)
 580                             .Case("5", llvm::EABI::EABI5)
 581                             .Case("gnu", llvm::EABI::GNU)
 582                             .Default(llvm::EABI::Default);
 583
 584   if (LangOpts.SjLjExceptions)
 585     Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
 586
 587   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
 588   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
 589   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
 590   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
 591   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
 592   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
 593   Options.FunctionSections = CodeGenOpts.FunctionSections;
 594   Options.DataSections = CodeGenOpts.DataSections;
 595   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
 596   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
 597   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
 598
 599   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
 600   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
 601   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
 602   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
 603   Options.MCOptions.MCIncrementalLinkerCompatible =
 604       CodeGenOpts.IncrementalLinkerCompatible;
 605   Options.MCOptions.MCPIECopyRelocations = CodeGenOpts.PIECopyRelocations;
 606   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
 607   Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
 608   Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
 609   Options.MCOptions.ABIName = TargetOpts.ABI;
 610   for (const auto &Entry : HSOpts.UserEntries)
 611     if (!Entry.IsFramework &&
 612         (Entry.Group == frontend::IncludeDirGroup::Quoted ||
 613          Entry.Group == frontend::IncludeDirGroup::Angled ||
 614          Entry.Group == frontend::IncludeDirGroup::System))
 615       Options.MCOptions.IASSearchPaths.push_back(
 616           Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
 617
 618   TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
 619                                           Options, RM, CM, OptLevel));
 620 }
 621
 622 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
 623                                        BackendAction Action,
 624                                        raw_pwrite_stream &OS) {
 625   // Add LibraryInfo.
 626   llvm::Triple TargetTriple(TheModule->getTargetTriple());
 627   std::unique_ptr<TargetLibraryInfoImpl> TLII(
 628       createTLII(TargetTriple, CodeGenOpts));
 629   CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));
 630
 631   // Normal mode, emit a .s or .o file by running the code generator. Note,
 632   // this also adds codegenerator level optimization passes.
 633   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
 634   if (Action == Backend_EmitObj)
 635     CGFT = TargetMachine::CGFT_ObjectFile;
 636   else if (Action == Backend_EmitMCNull)
 637     CGFT = TargetMachine::CGFT_Null;
 638   else
 639     assert(Action == Backend_EmitAssembly && "Invalid action!");
 640
 641   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
 642   // "codegen" passes so that it isn't run multiple times when there is
 643   // inlining happening.
 644   if (CodeGenOpts.OptimizationLevel > 0)
 645     CodeGenPasses.add(createObjCARCContractPass());
 646
 647   if (TM->addPassesToEmitFile(CodeGenPasses, OS, CGFT,
 648                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
 649     Diags.Report(diag::err_fe_unable_to_interface_with_target);
 650     return false;
 651   }
 652
 653   return true;
 654 }
 655
 656 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
 657                                       std::unique_ptr<raw_pwrite_stream> OS) {
 658   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
 659
 660   setCommandLineOpts();
 661
 662   bool UsesCodeGen = (Action != Backend_EmitNothing &&
 663                       Action != Backend_EmitBC &&
 664                       Action != Backend_EmitLL);
 665   CreateTargetMachine(UsesCodeGen);
 666
 667   if (UsesCodeGen && !TM)
 668     return;
 669   if (TM)
 670     TheModule->setDataLayout(TM->createDataLayout());
 671
 672   legacy::PassManager PerModulePasses;
 673   PerModulePasses.add(
 674       createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
 675
 676   legacy::FunctionPassManager PerFunctionPasses(TheModule);
 677   PerFunctionPasses.add(
 678       createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
 679
 680   CreatePasses(PerModulePasses, PerFunctionPasses);
 681
 682   legacy::PassManager CodeGenPasses;
 683   CodeGenPasses.add(
 684       createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
 685
 686   switch (Action) {
 687   case Backend_EmitNothing:
 688     break;
 689
 690   case Backend_EmitBC:
 691     PerModulePasses.add(createBitcodeWriterPass(
 692         *OS, CodeGenOpts.EmitLLVMUseLists, CodeGenOpts.EmitSummaryIndex,
 693         CodeGenOpts.EmitSummaryIndex));
 694     break;
 695
 696   case Backend_EmitLL:
 697     PerModulePasses.add(
 698         createPrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
 699     break;
 700
 701   default:
 702     if (!AddEmitPasses(CodeGenPasses, Action, *OS))
 703       return;
 704   }
 705
 706   // Before executing passes, print the final values of the LLVM options.
 707   cl::PrintOptionValues();
 708
 709   // Run passes. For now we do all passes at once, but eventually we
 710   // would like to have the option of streaming code generation.
 711
 712   {
 713     PrettyStackTraceString CrashInfo("Per-function optimization");
 714
 715     PerFunctionPasses.doInitialization();
 716     for (Function &F : *TheModule)
 717       if (!F.isDeclaration())
 718         PerFunctionPasses.run(F);
 719     PerFunctionPasses.doFinalization();
 720   }
 721
 722   {
 723     PrettyStackTraceString CrashInfo("Per-module optimization passes");
 724     PerModulePasses.run(*TheModule);
 725   }
 726
 727   {
 728     PrettyStackTraceString CrashInfo("Code generation");
 729     CodeGenPasses.run(*TheModule);
 730   }
 731 }
 732
 733 static PassBuilder::OptimizationLevel mapToLevel(const CodeGenOptions &Opts) {
 734   switch (Opts.OptimizationLevel) {
 735   default:
 736     llvm_unreachable("Invalid optimization level!");
 737
 738   case 1:
 739     return PassBuilder::O1;
 740
 741   case 2:
 742     switch (Opts.OptimizeSize) {
 743     default:
 744       llvm_unreachable("Invalide optimization level for size!");
 745
 746     case 0:
 747       return PassBuilder::O2;
 748
 749     case 1:
 750       return PassBuilder::Os;
 751
 752     case 2:
 753       return PassBuilder::Oz;
 754     }
 755
 756   case 3:
 757     return PassBuilder::O3;
 758   }
 759 }
 760
 761 /// A clean version of `EmitAssembly` that uses the new pass manager.
 762 ///
 763 /// Not all features are currently supported in this system, but where
 764 /// necessary it falls back to the legacy pass manager to at least provide
 765 /// basic functionality.
 766 ///
 767 /// This API is planned to have its functionality finished and then to replace
 768 /// `EmitAssembly` at some point in the future when the default switches.
 769 void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
 770     BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
 771   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
 772   setCommandLineOpts();
 773
 774   // The new pass manager always makes a target machine available to passes
 775   // during construction.
 776   CreateTargetMachine(/*MustCreateTM*/ true);
 777   if (!TM)
 778     // This will already be diagnosed, just bail.
 779     return;
 780   TheModule->setDataLayout(TM->createDataLayout());
 781
 782   PassBuilder PB(TM.get());
 783
 784   LoopAnalysisManager LAM;
 785   FunctionAnalysisManager FAM;
 786   CGSCCAnalysisManager CGAM;
 787   ModuleAnalysisManager MAM;
 788
 789   // Register the AA manager first so that our version is the one used.
 790   FAM.registerPass([&] { return PB.buildDefaultAAPipeline(); });
 791
 792   // Register all the basic analyses with the managers.
 793   PB.registerModuleAnalyses(MAM);
 794   PB.registerCGSCCAnalyses(CGAM);
 795   PB.registerFunctionAnalyses(FAM);
 796   PB.registerLoopAnalyses(LAM);
 797   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 798
 799   ModulePassManager MPM;
 800
 801   if (!CodeGenOpts.DisableLLVMPasses) {
 802     if (CodeGenOpts.OptimizationLevel == 0) {
 803       // Build a minimal pipeline based on the semantics required by Clang,
 804       // which is just that always inlining occurs.
 805       MPM.addPass(AlwaysInlinerPass());
 806     } else {
 807       // Otherwise, use the default pass pipeline. We also have to map our
 808       // optimization levels into one of the distinct levels used to configure
 809       // the pipeline.
 810       PassBuilder::OptimizationLevel Level = mapToLevel(CodeGenOpts);
 811
 812       MPM = PB.buildPerModuleDefaultPipeline(Level);
 813     }
 814   }
 815
 816   // FIXME: We still use the legacy pass manager to do code generation. We
 817   // create that pass manager here and use it as needed below.
 818   legacy::PassManager CodeGenPasses;
 819   bool NeedCodeGen = false;
 820
 821   // Append any output we need to the pass manager.
 822   switch (Action) {
 823   case Backend_EmitNothing:
 824     break;
 825
 826   case Backend_EmitBC:
 827     MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
 828                                   CodeGenOpts.EmitSummaryIndex,
 829                                   CodeGenOpts.EmitSummaryIndex));
 830     break;
 831
 832   case Backend_EmitLL:
 833     MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
 834     break;
 835
 836   case Backend_EmitAssembly:
 837   case Backend_EmitMCNull:
 838   case Backend_EmitObj:
 839     NeedCodeGen = true;
 840     CodeGenPasses.add(
 841         createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
 842     if (!AddEmitPasses(CodeGenPasses, Action, *OS))
 843       // FIXME: Should we handle this error differently?
 844       return;
 845     break;
 846   }
 847
 848   // Before executing passes, print the final values of the LLVM options.
 849   cl::PrintOptionValues();
 850
 851   // Now that we have all of the passes ready, run them.
 852   {
 853     PrettyStackTraceString CrashInfo("Optimizer");
 854     MPM.run(*TheModule, MAM);
 855   }
 856
 857   // Now if needed, run the legacy PM for codegen.
 858   if (NeedCodeGen) {
 859     PrettyStackTraceString CrashInfo("Code generation");
 860     CodeGenPasses.run(*TheModule);
 861   }
 862 }
 863
 864 static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
 865                               std::unique_ptr<raw_pwrite_stream> OS) {
 866   StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
 867       ModuleToDefinedGVSummaries;
 868   CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
 869
 870   // We can simply import the values mentioned in the combined index, since
 871   // we should only invoke this using the individual indexes written out
 872   // via a WriteIndexesThinBackend.
 873   FunctionImporter::ImportMapTy ImportList;
 874   for (auto &GlobalList : *CombinedIndex) {
 875     auto GUID = GlobalList.first;
 876     assert(GlobalList.second.size() == 1 &&
 877            "Expected individual combined index to have one summary per GUID");
 878     auto &Summary = GlobalList.second[0];
 879     // Skip the summaries for the importing module. These are included to
 880     // e.g. record required linkage changes.
 881     if (Summary->modulePath() == M->getModuleIdentifier())
 882       continue;
 883     // Doesn't matter what value we plug in to the map, just needs an entry
 884     // to provoke importing by thinBackend.
 885     ImportList[Summary->modulePath()][GUID] = 1;
 886   }
 887
 888   std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
 889   MapVector<llvm::StringRef, llvm::BitcodeModule> ModuleMap;
 890
 891   for (auto &I : ImportList) {
 892     ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
 893         llvm::MemoryBuffer::getFile(I.first());
 894     if (!MBOrErr) {
 895       errs() << "Error loading imported file '" << I.first()
 896              << "': " << MBOrErr.getError().message() << "\n";
 897       return;
 898     }
 899
 900     Expected<std::vector<BitcodeModule>> BMsOrErr =
 901         getBitcodeModuleList(**MBOrErr);
 902     if (!BMsOrErr) {
 903       handleAllErrors(BMsOrErr.takeError(), [&](ErrorInfoBase &EIB) {
 904         errs() << "Error loading imported file '" << I.first()
 905                << "': " << EIB.message() << '\n';
 906       });
 907       return;
 908     }
 909
 910     // The bitcode file may contain multiple modules, we want the one with a
 911     // summary.
 912     bool FoundModule = false;
 913     for (BitcodeModule &BM : *BMsOrErr) {
 914       Expected<bool> HasSummary = BM.hasSummary();
 915       if (HasSummary && *HasSummary) {
 916         ModuleMap.insert({I.first(), BM});
 917         FoundModule = true;
 918         break;
 919       }
 920     }
 921     if (!FoundModule) {
 922       errs() << "Error loading imported file '" << I.first()
 923              << "': Could not find module summary\n";
 924       return;
 925     }
 926
 927     OwnedImports.push_back(std::move(*MBOrErr));
 928   }
 929   auto AddStream = [&](size_t Task) {
 930     return llvm::make_unique<lto::NativeObjectStream>(std::move(OS));
 931   };
 932   lto::Config Conf;
 933   if (Error E = thinBackend(
 934           Conf, 0, AddStream, *M, *CombinedIndex, ImportList,
 935           ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
 936     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
 937       errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
 938     });
 939   }
 940 }
 941
 942 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
 943                               const HeaderSearchOptions &HeaderOpts,
 944                               const CodeGenOptions &CGOpts,
 945                               const clang::TargetOptions &TOpts,
 946                               const LangOptions &LOpts,
 947                               const llvm::DataLayout &TDesc, Module *M,
 948                               BackendAction Action,
 949                               std::unique_ptr<raw_pwrite_stream> OS) {
 950   if (!CGOpts.ThinLTOIndexFile.empty()) {
 951     // If we are performing a ThinLTO importing compile, load the function index
 952     // into memory and pass it into runThinLTOBackend, which will run the
 953     // function importer and invoke LTO passes.
 954     Expected<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
 955         llvm::getModuleSummaryIndexForFile(CGOpts.ThinLTOIndexFile);
 956     if (!IndexOrErr) {
 957       logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
 958                             "Error loading index file '" +
 959                             CGOpts.ThinLTOIndexFile + "': ");
 960       return;
 961     }
 962     std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
 963     // A null CombinedIndex means we should skip ThinLTO compilation
 964     // (LLVM will optionally ignore empty index files, returning null instead
 965     // of an error).
 966     bool DoThinLTOBackend = CombinedIndex != nullptr;
 967     if (DoThinLTOBackend) {
 968       runThinLTOBackend(CombinedIndex.get(), M, std::move(OS));
 969       return;
 970     }
 971   }
 972
 973   EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);
 974
 975   if (CGOpts.ExperimentalNewPassManager)
 976     AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
 977   else
 978     AsmHelper.EmitAssembly(Action, std::move(OS));
 979
 980   // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
 981   // DataLayout.
 982   if (AsmHelper.TM) {
 983     std::string DLDesc = M->getDataLayout().getStringRepresentation();
 984     if (DLDesc != TDesc.getStringRepresentation()) {
 985       unsigned DiagID = Diags.getCustomDiagID(
 986           DiagnosticsEngine::Error, "backend data layout '%0' does not match "
 987                                     "expected target description '%1'");
 988       Diags.Report(DiagID) << DLDesc << TDesc.getStringRepresentation();
 989     }
 990   }
 991 }
 992
 993 static const char* getSectionNameForBitcode(const Triple &T) {
 994   switch (T.getObjectFormat()) {
 995   case Triple::MachO:
 996     return "__LLVM,__bitcode";
 997   case Triple::COFF:
 998   case Triple::ELF:
 999   case Triple::UnknownObjectFormat:
1000     return ".llvmbc";
1001   }
1002   llvm_unreachable("Unimplemented ObjectFormatType");
1003 }
1004
1005 static const char* getSectionNameForCommandline(const Triple &T) {
1006   switch (T.getObjectFormat()) {
1007   case Triple::MachO:
1008     return "__LLVM,__cmdline";
1009   case Triple::COFF:
1010   case Triple::ELF:
1011   case Triple::UnknownObjectFormat:
1012     return ".llvmcmd";
1013   }
1014   llvm_unreachable("Unimplemented ObjectFormatType");
1015 }
1016
1017 // With -fembed-bitcode, save a copy of the llvm IR as data in the
1018 // __LLVM,__bitcode section.
1019 void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
1020                          llvm::MemoryBufferRef Buf) {
1021   if (CGOpts.getEmbedBitcode() == CodeGenOptions::Embed_Off)
1022     return;
1023
1024   // Save llvm.compiler.used and remote it.
1025   SmallVector<Constant*, 2> UsedArray;
1026   SmallSet<GlobalValue*, 4> UsedGlobals;
1027   Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
1028   GlobalVariable *Used = collectUsedGlobalVariables(*M, UsedGlobals, true);
1029   for (auto *GV : UsedGlobals) {
1030     if (GV->getName() != "llvm.embedded.module" &&
1031         GV->getName() != "llvm.cmdline")
1032       UsedArray.push_back(
1033           ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1034   }
1035   if (Used)
1036     Used->eraseFromParent();
1037
1038   // Embed the bitcode for the llvm module.
1039   std::string Data;
1040   ArrayRef<uint8_t> ModuleData;
1041   Triple T(M->getTargetTriple());
1042   // Create a constant that contains the bitcode.
1043   // In case of embedding a marker, ignore the input Buf and use the empty
1044   // ArrayRef. It is also legal to create a bitcode marker even Buf is empty.
1045   if (CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Marker) {
1046     if (!isBitcode((const unsigned char *)Buf.getBufferStart(),
1047                    (const unsigned char *)Buf.getBufferEnd())) {
1048       // If the input is LLVM Assembly, bitcode is produced by serializing
1049       // the module. Use-lists order need to be perserved in this case.
1050       llvm::raw_string_ostream OS(Data);
1051       llvm::WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true);
1052       ModuleData =
1053           ArrayRef<uint8_t>((const uint8_t *)OS.str().data(), OS.str().size());
1054     } else
1055       // If the input is LLVM bitcode, write the input byte stream directly.
1056       ModuleData = ArrayRef<uint8_t>((const uint8_t *)Buf.getBufferStart(),
1057                                      Buf.getBufferSize());
1058   }
1059   llvm::Constant *ModuleConstant =
1060       llvm::ConstantDataArray::get(M->getContext(), ModuleData);
1061   llvm::GlobalVariable *GV = new llvm::GlobalVariable(
1062       *M, ModuleConstant->getType(), true, llvm::GlobalValue::PrivateLinkage,
1063       ModuleConstant);
1064   GV->setSection(getSectionNameForBitcode(T));
1065   UsedArray.push_back(
1066       ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1067   if (llvm::GlobalVariable *Old =
1068           M->getGlobalVariable("llvm.embedded.module", true)) {
1069     assert(Old->hasOneUse() &&
1070            "llvm.embedded.module can only be used once in llvm.compiler.used");
1071     GV->takeName(Old);
1072     Old->eraseFromParent();
1073   } else {
1074     GV->setName("llvm.embedded.module");
1075   }
1076
1077   // Skip if only bitcode needs to be embedded.
1078   if (CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Bitcode) {
1079     // Embed command-line options.
1080     ArrayRef<uint8_t> CmdData(const_cast<uint8_t *>(CGOpts.CmdArgs.data()),
1081                               CGOpts.CmdArgs.size());
1082     llvm::Constant *CmdConstant =
1083       llvm::ConstantDataArray::get(M->getContext(), CmdData);
1084     GV = new llvm::GlobalVariable(*M, CmdConstant->getType(), true,
1085                                   llvm::GlobalValue::PrivateLinkage,
1086                                   CmdConstant);
1087     GV->setSection(getSectionNameForCommandline(T));
1088     UsedArray.push_back(
1089         ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1090     if (llvm::GlobalVariable *Old =
1091             M->getGlobalVariable("llvm.cmdline", true)) {
1092       assert(Old->hasOneUse() &&
1093              "llvm.cmdline can only be used once in llvm.compiler.used");
1094       GV->takeName(Old);
1095       Old->eraseFromParent();
1096     } else {
1097       GV->setName("llvm.cmdline");
1098     }
1099   }
1100
1101   if (UsedArray.empty())
1102     return;
1103
1104   // Recreate llvm.compiler.used.
1105   ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());
1106   auto *NewUsed = new GlobalVariable(
1107       *M, ATy, false, llvm::GlobalValue::AppendingLinkage,
1108       llvm::ConstantArray::get(ATy, UsedArray), "llvm.compiler.used");
1109   NewUsed->setSection("llvm.metadata");
1110 }