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