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   // Set frame pointer elimination mode.
293   if (!CodeGenOpts.DisableFPElim) {
294     Options.NoFramePointerElim = false;
295     Options.NoFramePointerElimNonLeaf = false;
296   } else if (CodeGenOpts.OmitLeafFramePointer) {
297     Options.NoFramePointerElim = false;
298     Options.NoFramePointerElimNonLeaf = true;
299   } else {
300     Options.NoFramePointerElim = true;
301     Options.NoFramePointerElimNonLeaf = true;
302   }
303 
304   // Set float ABI type.
305   if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
306     Options.FloatABIType = llvm::FloatABI::Soft;
307   else if (CodeGenOpts.FloatABI == "hard")
308     Options.FloatABIType = llvm::FloatABI::Hard;
309   else {
310     assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
311     Options.FloatABIType = llvm::FloatABI::Default;
312   }
313 
314   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
315   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
316   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
317   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
318   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
319   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
320   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
321   Options.RealignStack = CodeGenOpts.StackRealignment;
322 
323   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
324                                                      FeaturesStr, Options,
325                                                      RM, CM, OptLevel);
326 
327   if (CodeGenOpts.RelaxAll)
328     TM->setMCRelaxAll(true);
329   if (CodeGenOpts.SaveTempLabels)
330     TM->setMCSaveTempLabels(true);
331   if (CodeGenOpts.NoDwarf2CFIAsm)
332     TM->setMCUseCFI(false);
333   if (!CodeGenOpts.NoDwarfDirectoryAsm)
334     TM->setMCUseDwarfDirectory(true);
335   if (CodeGenOpts.NoExecStack)
336     TM->setMCNoExecStack(true);
337 
338   // Create the code generator passes.
339   PassManager *PM = getCodeGenPasses();
340 
341   // Normal mode, emit a .s or .o file by running the code generator. Note,
342   // this also adds codegenerator level optimization passes.
343   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
344   if (Action == Backend_EmitObj)
345     CGFT = TargetMachine::CGFT_ObjectFile;
346   else if (Action == Backend_EmitMCNull)
347     CGFT = TargetMachine::CGFT_Null;
348   else
349     assert(Action == Backend_EmitAssembly && "Invalid action!");
350 
351   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
352   // "codegen" passes so that it isn't run multiple times when there is
353   // inlining happening.
354   if (LangOpts.ObjCAutoRefCount)
355     PM->add(createObjCARCContractPass());
356 
357   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
358                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
359     Diags.Report(diag::err_fe_unable_to_interface_with_target);
360     return false;
361   }
362 
363   return true;
364 }
365 
366 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
367   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
368   llvm::formatted_raw_ostream FormattedOS;
369 
370   CreatePasses();
371   switch (Action) {
372   case Backend_EmitNothing:
373     break;
374 
375   case Backend_EmitBC:
376     getPerModulePasses()->add(createBitcodeWriterPass(*OS));
377     break;
378 
379   case Backend_EmitLL:
380     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
381     getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
382     break;
383 
384   default:
385     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
386     if (!AddEmitPasses(Action, FormattedOS))
387       return;
388   }
389 
390   // Before executing passes, print the final values of the LLVM options.
391   cl::PrintOptionValues();
392 
393   // Run passes. For now we do all passes at once, but eventually we
394   // would like to have the option of streaming code generation.
395 
396   if (PerFunctionPasses) {
397     PrettyStackTraceString CrashInfo("Per-function optimization");
398 
399     PerFunctionPasses->doInitialization();
400     for (Module::iterator I = TheModule->begin(),
401            E = TheModule->end(); I != E; ++I)
402       if (!I->isDeclaration())
403         PerFunctionPasses->run(*I);
404     PerFunctionPasses->doFinalization();
405   }
406 
407   if (PerModulePasses) {
408     PrettyStackTraceString CrashInfo("Per-module optimization passes");
409     PerModulePasses->run(*TheModule);
410   }
411 
412   if (CodeGenPasses) {
413     PrettyStackTraceString CrashInfo("Code generation");
414     CodeGenPasses->run(*TheModule);
415   }
416 }
417 
418 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
419                               const CodeGenOptions &CGOpts,
420                               const clang::TargetOptions &TOpts,
421                               const LangOptions &LOpts,
422                               Module *M,
423                               BackendAction Action, raw_ostream *OS) {
424   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
425 
426   AsmHelper.EmitAssembly(Action, OS);
427 }
428