1 //===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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;
43 class EmitAssemblyHelper {
44 DiagnosticsEngine &Diags;
45 const CodeGenOptions &CodeGenOpts;
46 const TargetOptions &TargetOpts;
47 const LangOptions &LangOpts;
50 Timer CodeGenerationTime;
52 mutable PassManager *CodeGenPasses;
53 mutable PassManager *PerModulePasses;
54 mutable FunctionPassManager *PerFunctionPasses;
57 PassManager *getCodeGenPasses() const {
59 CodeGenPasses = new PassManager();
60 CodeGenPasses->add(new TargetData(TheModule));
65 PassManager *getPerModulePasses() const {
66 if (!PerModulePasses) {
67 PerModulePasses = new PassManager();
68 PerModulePasses->add(new TargetData(TheModule));
70 return PerModulePasses;
73 FunctionPassManager *getPerFunctionPasses() const {
74 if (!PerFunctionPasses) {
75 PerFunctionPasses = new FunctionPassManager(TheModule);
76 PerFunctionPasses->add(new TargetData(TheModule));
78 return PerFunctionPasses;
83 /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
85 /// \return True on success.
86 bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS);
89 EmitAssemblyHelper(DiagnosticsEngine &_Diags,
90 const CodeGenOptions &CGOpts, const TargetOptions &TOpts,
91 const LangOptions &LOpts,
93 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
94 TheModule(M), CodeGenerationTime("Code Generation Time"),
95 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
97 ~EmitAssemblyHelper() {
99 delete PerModulePasses;
100 delete PerFunctionPasses;
103 void EmitAssembly(BackendAction Action, raw_ostream *OS);
108 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
109 if (Builder.OptLevel > 0)
110 PM.add(createObjCARCExpandPass());
113 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
114 if (Builder.OptLevel > 0)
115 PM.add(createObjCARCOptPass());
118 void EmitAssemblyHelper::CreatePasses() {
119 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
120 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
122 // Handle disabling of LLVM optimization, where we want to preserve the
123 // internal module before any optimization.
124 if (CodeGenOpts.DisableLLVMOpts) {
126 Inlining = CodeGenOpts.NoInlining;
129 PassManagerBuilder PMBuilder;
130 PMBuilder.OptLevel = OptLevel;
131 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
133 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
134 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
135 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
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,
145 // Figure out TargetLibraryInfo.
146 Triple TargetTriple(TheModule->getTargetTriple());
147 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
148 if (!CodeGenOpts.SimplifyLibCalls)
149 PMBuilder.LibraryInfo->disableAllFunctions();
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
158 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
160 else if (OptLevel > 2)
162 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
165 case CodeGenOptions::OnlyAlwaysInlining:
166 // Respect always_inline.
167 PMBuilder.Inliner = createAlwaysInlinerPass();
172 // Set up the per-function pass manager.
173 FunctionPassManager *FPM = getPerFunctionPasses();
174 if (CodeGenOpts.VerifyModule)
175 FPM->add(createVerifierPass());
176 PMBuilder.populateFunctionPassManager(*FPM);
178 // Set up the per-module pass manager.
179 PassManager *MPM = getPerModulePasses();
181 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
182 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
183 CodeGenOpts.EmitGcovArcs,
184 TargetTriple.isMacOSX()));
186 if (!CodeGenOpts.DebugInfo)
187 MPM->add(createStripSymbolsPass(true));
191 PMBuilder.populateModulePassManager(*MPM);
194 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
195 formatted_raw_ostream &OS) {
196 // Create the TargetMachine for generating code.
198 std::string Triple = TheModule->getTargetTriple();
199 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
201 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
205 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
206 // being gross, this is also totally broken if we ever care about
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;
217 llvm::NoFramePointerElim = true;
218 llvm::NoFramePointerElimNonLeaf = true;
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;
227 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
228 llvm::FloatABIType = llvm::FloatABI::Default;
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;
238 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
240 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
241 TargetMachine::setDataSections (CodeGenOpts.DataSections);
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;
254 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
255 CM = llvm::CodeModel::Default;
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());
264 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
265 BackendArgs.push_back("-limit-float-precision");
266 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
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 if (CodeGenOpts.NoGlobalMerge)
273 BackendArgs.push_back("-global-merge=false");
274 BackendArgs.push_back(0);
275 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
276 const_cast<char **>(&BackendArgs[0]));
278 std::string FeaturesStr;
279 if (TargetOpts.Features.size()) {
280 SubtargetFeatures Features;
281 for (std::vector<std::string>::const_iterator
282 it = TargetOpts.Features.begin(),
283 ie = TargetOpts.Features.end(); it != ie; ++it)
284 Features.AddFeature(*it);
285 FeaturesStr = Features.getString();
288 llvm::Reloc::Model RM = llvm::Reloc::Default;
289 if (CodeGenOpts.RelocationModel == "static") {
290 RM = llvm::Reloc::Static;
291 } else if (CodeGenOpts.RelocationModel == "pic") {
292 RM = llvm::Reloc::PIC_;
294 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
295 "Invalid PIC model!");
296 RM = llvm::Reloc::DynamicNoPIC;
299 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
300 FeaturesStr, RM, CM);
302 if (CodeGenOpts.RelaxAll)
303 TM->setMCRelaxAll(true);
304 if (CodeGenOpts.SaveTempLabels)
305 TM->setMCSaveTempLabels(true);
306 if (CodeGenOpts.NoDwarf2CFIAsm)
307 TM->setMCUseCFI(false);
308 if (CodeGenOpts.NoExecStack)
309 TM->setMCNoExecStack(true);
311 // Create the code generator passes.
312 PassManager *PM = getCodeGenPasses();
313 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
315 switch (CodeGenOpts.OptimizationLevel) {
317 case 0: OptLevel = CodeGenOpt::None; break;
318 case 3: OptLevel = CodeGenOpt::Aggressive; break;
321 // Normal mode, emit a .s or .o file by running the code generator. Note,
322 // this also adds codegenerator level optimization passes.
323 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
324 if (Action == Backend_EmitObj)
325 CGFT = TargetMachine::CGFT_ObjectFile;
326 else if (Action == Backend_EmitMCNull)
327 CGFT = TargetMachine::CGFT_Null;
329 assert(Action == Backend_EmitAssembly && "Invalid action!");
331 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
332 // "codegen" passes so that it isn't run multiple times when there is
333 // inlining happening.
334 if (LangOpts.ObjCAutoRefCount)
335 PM->add(createObjCARCContractPass());
337 if (TM->addPassesToEmitFile(*PM, OS, CGFT, OptLevel,
338 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
339 Diags.Report(diag::err_fe_unable_to_interface_with_target);
346 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
347 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
348 llvm::formatted_raw_ostream FormattedOS;
352 case Backend_EmitNothing:
356 getPerModulePasses()->add(createBitcodeWriterPass(*OS));
360 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
361 getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
365 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
366 if (!AddEmitPasses(Action, FormattedOS))
370 // Before executing passes, print the final values of the LLVM options.
371 cl::PrintOptionValues();
373 // Run passes. For now we do all passes at once, but eventually we
374 // would like to have the option of streaming code generation.
376 if (PerFunctionPasses) {
377 PrettyStackTraceString CrashInfo("Per-function optimization");
379 PerFunctionPasses->doInitialization();
380 for (Module::iterator I = TheModule->begin(),
381 E = TheModule->end(); I != E; ++I)
382 if (!I->isDeclaration())
383 PerFunctionPasses->run(*I);
384 PerFunctionPasses->doFinalization();
387 if (PerModulePasses) {
388 PrettyStackTraceString CrashInfo("Per-module optimization passes");
389 PerModulePasses->run(*TheModule);
393 PrettyStackTraceString CrashInfo("Code generation");
394 CodeGenPasses->run(*TheModule);
398 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
399 const CodeGenOptions &CGOpts,
400 const TargetOptions &TOpts,
401 const LangOptions &LOpts,
403 BackendAction Action, raw_ostream *OS) {
404 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
406 AsmHelper.EmitAssembly(Action, OS);