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