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