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/TargetOptions.h"
  13 #include "clang/Basic/LangOptions.h"
  14 #include "clang/Frontend/CodeGenOptions.h"
  15 #include "clang/Frontend/FrontendDiagnostic.h"
  16 #include "llvm/Module.h"
  17 #include "llvm/PassManager.h"
  18 #include "llvm/Analysis/Verifier.h"
  19 #include "llvm/Assembly/PrintModulePass.h"
  20 #include "llvm/Bitcode/ReaderWriter.h"
  21 #include "llvm/CodeGen/RegAllocRegistry.h"
  22 #include "llvm/CodeGen/SchedulerRegistry.h"
  23 #include "llvm/MC/SubtargetFeature.h"
  24 #include "llvm/Support/CommandLine.h"
  25 #include "llvm/Support/FormattedStream.h"
  26 #include "llvm/Support/PrettyStackTrace.h"
  27 #include "llvm/Support/TargetRegistry.h"
  28 #include "llvm/Support/Timer.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include "llvm/Target/TargetData.h"
  31 #include "llvm/Target/TargetLibraryInfo.h"
  32 #include "llvm/Target/TargetMachine.h"
  33 #include "llvm/Target/TargetOptions.h"
  34 #include "llvm/Transforms/Instrumentation.h"
  35 #include "llvm/Transforms/IPO.h"
  36 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
  37 #include "llvm/Transforms/Scalar.h"
  38 using namespace clang;
  39 using namespace llvm;
  40
  41 namespace {
  42
  43 class EmitAssemblyHelper {
  44   DiagnosticsEngine &Diags;
  45   const CodeGenOptions &CodeGenOpts;
  46   const clang::TargetOptions &TargetOpts;
  47   const LangOptions &LangOpts;
  48   Module *TheModule;
  49
  50   Timer CodeGenerationTime;
  51
  52   mutable PassManager *CodeGenPasses;
  53   mutable PassManager *PerModulePasses;
  54   mutable FunctionPassManager *PerFunctionPasses;
  55
  56 private:
  57   PassManager *getCodeGenPasses() const {
  58     if (!CodeGenPasses) {
  59       CodeGenPasses = new PassManager();
  60       CodeGenPasses->add(new TargetData(TheModule));
  61     }
  62     return CodeGenPasses;
  63   }
  64
  65   PassManager *getPerModulePasses() const {
  66     if (!PerModulePasses) {
  67       PerModulePasses = new PassManager();
  68       PerModulePasses->add(new TargetData(TheModule));
  69     }
  70     return PerModulePasses;
  71   }
  72
  73   FunctionPassManager *getPerFunctionPasses() const {
  74     if (!PerFunctionPasses) {
  75       PerFunctionPasses = new FunctionPassManager(TheModule);
  76       PerFunctionPasses->add(new TargetData(TheModule));
  77     }
  78     return PerFunctionPasses;
  79   }
  80
  81   void CreatePasses();
  82
  83   /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
  84   ///
  85   /// \return True on success.
  86   bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS);
  87
  88 public:
  89   EmitAssemblyHelper(DiagnosticsEngine &_Diags,
  90                      const CodeGenOptions &CGOpts,
  91                      const clang::TargetOptions &TOpts,
  92                      const LangOptions &LOpts,
  93                      Module *M)
  94     : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
  95       TheModule(M), CodeGenerationTime("Code Generation Time"),
  96       CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
  97
  98   ~EmitAssemblyHelper() {
  99     delete CodeGenPasses;
 100     delete PerModulePasses;
 101     delete PerFunctionPasses;
 102   }
 103
 104   void EmitAssembly(BackendAction Action, raw_ostream *OS);
 105 };
 106
 107 }
 108
 109 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 110   if (Builder.OptLevel > 0)
 111     PM.add(createObjCARCAPElimPass());
 112 }
 113
 114 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 115   if (Builder.OptLevel > 0)
 116     PM.add(createObjCARCExpandPass());
 117 }
 118
 119 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
 120   if (Builder.OptLevel > 0)
 121     PM.add(createObjCARCOptPass());
 122 }
 123
 124 static unsigned BoundsChecking;
 125 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
 126                                     PassManagerBase &PM) {
 127   PM.add(createBoundsCheckingPass(BoundsChecking));
 128 }
 129
 130 static void addAddressSanitizerPass(const PassManagerBuilder &Builder,
 131                                     PassManagerBase &PM) {
 132   PM.add(createAddressSanitizerPass());
 133 }
 134
 135 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
 136                                    PassManagerBase &PM) {
 137   PM.add(createThreadSanitizerPass());
 138 }
 139
 140 void EmitAssemblyHelper::CreatePasses() {
 141   unsigned OptLevel = CodeGenOpts.OptimizationLevel;
 142   CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
 143
 144   // Handle disabling of LLVM optimization, where we want to preserve the
 145   // internal module before any optimization.
 146   if (CodeGenOpts.DisableLLVMOpts) {
 147     OptLevel = 0;
 148     Inlining = CodeGenOpts.NoInlining;
 149   }
 150
 151   PassManagerBuilder PMBuilder;
 152   PMBuilder.OptLevel = OptLevel;
 153   PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
 154
 155   PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
 156   PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
 157   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
 158
 159   // In ObjC ARC mode, add the main ARC optimization passes.
 160   if (LangOpts.ObjCAutoRefCount) {
 161     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
 162                            addObjCARCExpandPass);
 163     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
 164                            addObjCARCAPElimPass);
 165     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 166                            addObjCARCOptPass);
 167   }
 168
 169   if (CodeGenOpts.BoundsChecking > 0) {
 170     BoundsChecking = CodeGenOpts.BoundsChecking;
 171     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 172                            addBoundsCheckingPass);
 173     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 174                            addBoundsCheckingPass);
 175   }
 176
 177   if (LangOpts.AddressSanitizer) {
 178     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
 179                            addAddressSanitizerPass);
 180     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 181                            addAddressSanitizerPass);
 182   }
 183
 184   if (LangOpts.ThreadSanitizer) {
 185     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
 186                            addThreadSanitizerPass);
 187     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 188                            addThreadSanitizerPass);
 189   }
 190
 191   // Figure out TargetLibraryInfo.
 192   Triple TargetTriple(TheModule->getTargetTriple());
 193   PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
 194   if (!CodeGenOpts.SimplifyLibCalls)
 195     PMBuilder.LibraryInfo->disableAllFunctions();
 196
 197   switch (Inlining) {
 198   case CodeGenOptions::NoInlining: break;
 199   case CodeGenOptions::NormalInlining: {
 200     // FIXME: Derive these constants in a principled fashion.
 201     unsigned Threshold = 225;
 202     if (CodeGenOpts.OptimizeSize == 1)      // -Os
 203       Threshold = 75;
 204     else if (CodeGenOpts.OptimizeSize == 2) // -Oz
 205       Threshold = 25;
 206     else if (OptLevel > 2)
 207       Threshold = 275;
 208     PMBuilder.Inliner = createFunctionInliningPass(Threshold);
 209     break;
 210   }
 211   case CodeGenOptions::OnlyAlwaysInlining:
 212     // Respect always_inline.
 213     if (OptLevel == 0)
 214       // Do not insert lifetime intrinsics at -O0.
 215       PMBuilder.Inliner = createAlwaysInlinerPass(false);
 216     else
 217       PMBuilder.Inliner = createAlwaysInlinerPass();
 218     break;
 219   }
 220
 221
 222   // Set up the per-function pass manager.
 223   FunctionPassManager *FPM = getPerFunctionPasses();
 224   if (CodeGenOpts.VerifyModule)
 225     FPM->add(createVerifierPass());
 226   PMBuilder.populateFunctionPassManager(*FPM);
 227
 228   // Set up the per-module pass manager.
 229   PassManager *MPM = getPerModulePasses();
 230
 231   if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
 232     MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
 233                                     CodeGenOpts.EmitGcovArcs,
 234                                     TargetTriple.isMacOSX()));
 235
 236     if (CodeGenOpts.DebugInfo == CodeGenOptions::NoDebugInfo)
 237       MPM->add(createStripSymbolsPass(true));
 238   }
 239
 240
 241   PMBuilder.populateModulePassManager(*MPM);
 242 }
 243
 244 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
 245                                        formatted_raw_ostream &OS) {
 246   // Create the TargetMachine for generating code.
 247   std::string Error;
 248   std::string Triple = TheModule->getTargetTriple();
 249   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
 250   if (!TheTarget) {
 251     Diags.Report(diag::err_fe_unable_to_create_target) << Error;
 252     return false;
 253   }
 254
 255   // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
 256   // being gross, this is also totally broken if we ever care about
 257   // concurrency.
 258
 259   TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
 260
 261   TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
 262   TargetMachine::setDataSections    (CodeGenOpts.DataSections);
 263
 264   // FIXME: Parse this earlier.
 265   llvm::CodeModel::Model CM;
 266   if (CodeGenOpts.CodeModel == "small") {
 267     CM = llvm::CodeModel::Small;
 268   } else if (CodeGenOpts.CodeModel == "kernel") {
 269     CM = llvm::CodeModel::Kernel;
 270   } else if (CodeGenOpts.CodeModel == "medium") {
 271     CM = llvm::CodeModel::Medium;
 272   } else if (CodeGenOpts.CodeModel == "large") {
 273     CM = llvm::CodeModel::Large;
 274   } else {
 275     assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
 276     CM = llvm::CodeModel::Default;
 277   }
 278
 279   SmallVector<const char *, 16> BackendArgs;
 280   BackendArgs.push_back("clang"); // Fake program name.
 281   if (!CodeGenOpts.DebugPass.empty()) {
 282     BackendArgs.push_back("-debug-pass");
 283     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
 284   }
 285   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
 286     BackendArgs.push_back("-limit-float-precision");
 287     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
 288   }
 289   if (llvm::TimePassesIsEnabled)
 290     BackendArgs.push_back("-time-passes");
 291   for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
 292     BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
 293   if (CodeGenOpts.NoGlobalMerge)
 294     BackendArgs.push_back("-global-merge=false");
 295   BackendArgs.push_back(0);
 296   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
 297                                     BackendArgs.data());
 298
 299   std::string FeaturesStr;
 300   if (TargetOpts.Features.size()) {
 301     SubtargetFeatures Features;
 302     for (std::vector<std::string>::const_iterator
 303            it = TargetOpts.Features.begin(),
 304            ie = TargetOpts.Features.end(); it != ie; ++it)
 305       Features.AddFeature(*it);
 306     FeaturesStr = Features.getString();
 307   }
 308
 309   llvm::Reloc::Model RM = llvm::Reloc::Default;
 310   if (CodeGenOpts.RelocationModel == "static") {
 311     RM = llvm::Reloc::Static;
 312   } else if (CodeGenOpts.RelocationModel == "pic") {
 313     RM = llvm::Reloc::PIC_;
 314   } else {
 315     assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
 316            "Invalid PIC model!");
 317     RM = llvm::Reloc::DynamicNoPIC;
 318   }
 319
 320   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
 321   switch (CodeGenOpts.OptimizationLevel) {
 322   default: break;
 323   case 0: OptLevel = CodeGenOpt::None; break;
 324   case 3: OptLevel = CodeGenOpt::Aggressive; break;
 325   }
 326
 327   llvm::TargetOptions Options;
 328
 329   // Set frame pointer elimination mode.
 330   if (!CodeGenOpts.DisableFPElim) {
 331     Options.NoFramePointerElim = false;
 332     Options.NoFramePointerElimNonLeaf = false;
 333   } else if (CodeGenOpts.OmitLeafFramePointer) {
 334     Options.NoFramePointerElim = false;
 335     Options.NoFramePointerElimNonLeaf = true;
 336   } else {
 337     Options.NoFramePointerElim = true;
 338     Options.NoFramePointerElimNonLeaf = true;
 339   }
 340
 341   if (CodeGenOpts.UseInitArray)
 342     Options.UseInitArray = true;
 343
 344   // Set float ABI type.
 345   if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
 346     Options.FloatABIType = llvm::FloatABI::Soft;
 347   else if (CodeGenOpts.FloatABI == "hard")
 348     Options.FloatABIType = llvm::FloatABI::Hard;
 349   else {
 350     assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
 351     Options.FloatABIType = llvm::FloatABI::Default;
 352   }
 353
 354   // Set FP fusion mode.
 355   switch (LangOpts.getFPContractMode()) {
 356   case LangOptions::FPC_Off:
 357     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
 358     break;
 359   case LangOptions::FPC_On:
 360     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
 361     break;
 362   case LangOptions::FPC_Fast:
 363     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
 364     break;
 365   }
 366
 367   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
 368   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
 369   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
 370   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
 371   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
 372   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
 373   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
 374   Options.RealignStack = CodeGenOpts.StackRealignment;
 375   Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
 376   Options.TrapFuncName = CodeGenOpts.TrapFuncName;
 377   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
 378
 379   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
 380                                                      FeaturesStr, Options,
 381                                                      RM, CM, OptLevel);
 382
 383   if (CodeGenOpts.RelaxAll)
 384     TM->setMCRelaxAll(true);
 385   if (CodeGenOpts.SaveTempLabels)
 386     TM->setMCSaveTempLabels(true);
 387   if (CodeGenOpts.NoDwarf2CFIAsm)
 388     TM->setMCUseCFI(false);
 389   if (!CodeGenOpts.NoDwarfDirectoryAsm)
 390     TM->setMCUseDwarfDirectory(true);
 391   if (CodeGenOpts.NoExecStack)
 392     TM->setMCNoExecStack(true);
 393
 394   // Create the code generator passes.
 395   PassManager *PM = getCodeGenPasses();
 396
 397   // Add LibraryInfo.
 398   TargetLibraryInfo *TLI = new TargetLibraryInfo();
 399   if (!CodeGenOpts.SimplifyLibCalls)
 400     TLI->disableAllFunctions();
 401   PM->add(TLI);
 402
 403   // Normal mode, emit a .s or .o file by running the code generator. Note,
 404   // this also adds codegenerator level optimization passes.
 405   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
 406   if (Action == Backend_EmitObj)
 407     CGFT = TargetMachine::CGFT_ObjectFile;
 408   else if (Action == Backend_EmitMCNull)
 409     CGFT = TargetMachine::CGFT_Null;
 410   else
 411     assert(Action == Backend_EmitAssembly && "Invalid action!");
 412
 413   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
 414   // "codegen" passes so that it isn't run multiple times when there is
 415   // inlining happening.
 416   if (LangOpts.ObjCAutoRefCount &&
 417       CodeGenOpts.OptimizationLevel > 0)
 418     PM->add(createObjCARCContractPass());
 419
 420   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
 421                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
 422     Diags.Report(diag::err_fe_unable_to_interface_with_target);
 423     return false;
 424   }
 425
 426   return true;
 427 }
 428
 429 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
 430   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
 431   llvm::formatted_raw_ostream FormattedOS;
 432
 433   CreatePasses();
 434   switch (Action) {
 435   case Backend_EmitNothing:
 436     break;
 437
 438   case Backend_EmitBC:
 439     getPerModulePasses()->add(createBitcodeWriterPass(*OS));
 440     break;
 441
 442   case Backend_EmitLL:
 443     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
 444     getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
 445     break;
 446
 447   default:
 448     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
 449     if (!AddEmitPasses(Action, FormattedOS))
 450       return;
 451   }
 452
 453   // Before executing passes, print the final values of the LLVM options.
 454   cl::PrintOptionValues();
 455
 456   // Run passes. For now we do all passes at once, but eventually we
 457   // would like to have the option of streaming code generation.
 458
 459   if (PerFunctionPasses) {
 460     PrettyStackTraceString CrashInfo("Per-function optimization");
 461
 462     PerFunctionPasses->doInitialization();
 463     for (Module::iterator I = TheModule->begin(),
 464            E = TheModule->end(); I != E; ++I)
 465       if (!I->isDeclaration())
 466         PerFunctionPasses->run(*I);
 467     PerFunctionPasses->doFinalization();
 468   }
 469
 470   if (PerModulePasses) {
 471     PrettyStackTraceString CrashInfo("Per-module optimization passes");
 472     PerModulePasses->run(*TheModule);
 473   }
 474
 475   if (CodeGenPasses) {
 476     PrettyStackTraceString CrashInfo("Code generation");
 477     CodeGenPasses->run(*TheModule);
 478   }
 479 }
 480
 481 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
 482                               const CodeGenOptions &CGOpts,
 483                               const clang::TargetOptions &TOpts,
 484                               const LangOptions &LOpts,
 485                               Module *M,
 486                               BackendAction Action, raw_ostream *OS) {
 487   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
 488
 489   AsmHelper.EmitAssembly(Action, OS);
 490 }