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