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