BackendUtil.cpp 16 KB

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