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