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 clang::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,
91 const clang::TargetOptions &TOpts,
92 const LangOptions &LOpts,
94 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
95 TheModule(M), CodeGenerationTime("Code Generation Time"),
96 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
98 ~EmitAssemblyHelper() {
100 delete PerModulePasses;
101 delete PerFunctionPasses;
104 void EmitAssembly(BackendAction Action, raw_ostream *OS);
109 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
110 if (Builder.OptLevel > 0)
111 PM.add(createObjCARCAPElimPass());
114 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
115 if (Builder.OptLevel > 0)
116 PM.add(createObjCARCExpandPass());
119 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
120 if (Builder.OptLevel > 0)
121 PM.add(createObjCARCOptPass());
124 static void addAddressSanitizerPass(const PassManagerBuilder &Builder,
125 PassManagerBase &PM) {
126 PM.add(createAddressSanitizerPass());
129 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
130 PassManagerBase &PM) {
131 PM.add(createThreadSanitizerPass());
134 void EmitAssemblyHelper::CreatePasses() {
135 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
136 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
138 // Handle disabling of LLVM optimization, where we want to preserve the
139 // internal module before any optimization.
140 if (CodeGenOpts.DisableLLVMOpts) {
142 Inlining = CodeGenOpts.NoInlining;
145 PassManagerBuilder PMBuilder;
146 PMBuilder.OptLevel = OptLevel;
147 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
149 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
150 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
151 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
153 // In ObjC ARC mode, add the main ARC optimization passes.
154 if (LangOpts.ObjCAutoRefCount) {
155 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
156 addObjCARCExpandPass);
157 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
158 addObjCARCAPElimPass);
159 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
163 if (LangOpts.AddressSanitizer) {
164 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
165 addAddressSanitizerPass);
166 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
167 addAddressSanitizerPass);
170 if (LangOpts.ThreadSanitizer) {
171 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
172 addThreadSanitizerPass);
173 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
174 addThreadSanitizerPass);
177 // Figure out TargetLibraryInfo.
178 Triple TargetTriple(TheModule->getTargetTriple());
179 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
180 if (!CodeGenOpts.SimplifyLibCalls)
181 PMBuilder.LibraryInfo->disableAllFunctions();
184 case CodeGenOptions::NoInlining: break;
185 case CodeGenOptions::NormalInlining: {
186 // FIXME: Derive these constants in a principled fashion.
187 unsigned Threshold = 225;
188 if (CodeGenOpts.OptimizeSize == 1) // -Os
190 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
192 else if (OptLevel > 2)
194 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
197 case CodeGenOptions::OnlyAlwaysInlining:
198 // Respect always_inline.
200 // Do not insert lifetime intrinsics at -O0.
201 PMBuilder.Inliner = createAlwaysInlinerPass(false);
203 PMBuilder.Inliner = createAlwaysInlinerPass();
208 // Set up the per-function pass manager.
209 FunctionPassManager *FPM = getPerFunctionPasses();
210 if (CodeGenOpts.VerifyModule)
211 FPM->add(createVerifierPass());
212 PMBuilder.populateFunctionPassManager(*FPM);
214 // Set up the per-module pass manager.
215 PassManager *MPM = getPerModulePasses();
217 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
218 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
219 CodeGenOpts.EmitGcovArcs,
220 TargetTriple.isMacOSX()));
222 if (!CodeGenOpts.DebugInfo)
223 MPM->add(createStripSymbolsPass(true));
227 PMBuilder.populateModulePassManager(*MPM);
230 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
231 formatted_raw_ostream &OS) {
232 // Create the TargetMachine for generating code.
234 std::string Triple = TheModule->getTargetTriple();
235 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
237 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
241 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
242 // being gross, this is also totally broken if we ever care about
245 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
247 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
248 TargetMachine::setDataSections (CodeGenOpts.DataSections);
250 // FIXME: Parse this earlier.
251 llvm::CodeModel::Model CM;
252 if (CodeGenOpts.CodeModel == "small") {
253 CM = llvm::CodeModel::Small;
254 } else if (CodeGenOpts.CodeModel == "kernel") {
255 CM = llvm::CodeModel::Kernel;
256 } else if (CodeGenOpts.CodeModel == "medium") {
257 CM = llvm::CodeModel::Medium;
258 } else if (CodeGenOpts.CodeModel == "large") {
259 CM = llvm::CodeModel::Large;
261 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
262 CM = llvm::CodeModel::Default;
265 SmallVector<const char *, 16> BackendArgs;
266 BackendArgs.push_back("clang"); // Fake program name.
267 if (!CodeGenOpts.DebugPass.empty()) {
268 BackendArgs.push_back("-debug-pass");
269 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
271 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
272 BackendArgs.push_back("-limit-float-precision");
273 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
275 if (llvm::TimePassesIsEnabled)
276 BackendArgs.push_back("-time-passes");
277 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
278 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
279 if (CodeGenOpts.NoGlobalMerge)
280 BackendArgs.push_back("-global-merge=false");
281 BackendArgs.push_back(0);
282 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
285 std::string FeaturesStr;
286 if (TargetOpts.Features.size()) {
287 SubtargetFeatures Features;
288 for (std::vector<std::string>::const_iterator
289 it = TargetOpts.Features.begin(),
290 ie = TargetOpts.Features.end(); it != ie; ++it)
291 Features.AddFeature(*it);
292 FeaturesStr = Features.getString();
295 llvm::Reloc::Model RM = llvm::Reloc::Default;
296 if (CodeGenOpts.RelocationModel == "static") {
297 RM = llvm::Reloc::Static;
298 } else if (CodeGenOpts.RelocationModel == "pic") {
299 RM = llvm::Reloc::PIC_;
301 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
302 "Invalid PIC model!");
303 RM = llvm::Reloc::DynamicNoPIC;
306 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
307 switch (CodeGenOpts.OptimizationLevel) {
309 case 0: OptLevel = CodeGenOpt::None; break;
310 case 3: OptLevel = CodeGenOpt::Aggressive; break;
313 llvm::TargetOptions Options;
315 // Set frame pointer elimination mode.
316 if (!CodeGenOpts.DisableFPElim) {
317 Options.NoFramePointerElim = false;
318 Options.NoFramePointerElimNonLeaf = false;
319 } else if (CodeGenOpts.OmitLeafFramePointer) {
320 Options.NoFramePointerElim = false;
321 Options.NoFramePointerElimNonLeaf = true;
323 Options.NoFramePointerElim = true;
324 Options.NoFramePointerElimNonLeaf = true;
327 // Set float ABI type.
328 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
329 Options.FloatABIType = llvm::FloatABI::Soft;
330 else if (CodeGenOpts.FloatABI == "hard")
331 Options.FloatABIType = llvm::FloatABI::Hard;
333 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
334 Options.FloatABIType = llvm::FloatABI::Default;
337 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
338 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
339 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
340 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
341 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
342 Options.UseSoftFloat = CodeGenOpts.SoftFloat;
343 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
344 Options.RealignStack = CodeGenOpts.StackRealignment;
345 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
346 Options.TrapFuncName = CodeGenOpts.TrapFuncName;
347 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
349 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
350 FeaturesStr, Options,
353 if (CodeGenOpts.RelaxAll)
354 TM->setMCRelaxAll(true);
355 if (CodeGenOpts.SaveTempLabels)
356 TM->setMCSaveTempLabels(true);
357 if (CodeGenOpts.NoDwarf2CFIAsm)
358 TM->setMCUseCFI(false);
359 if (!CodeGenOpts.NoDwarfDirectoryAsm)
360 TM->setMCUseDwarfDirectory(true);
361 if (CodeGenOpts.NoExecStack)
362 TM->setMCNoExecStack(true);
364 // Create the code generator passes.
365 PassManager *PM = getCodeGenPasses();
368 TargetLibraryInfo *TLI = new TargetLibraryInfo();
369 if (!CodeGenOpts.SimplifyLibCalls)
370 TLI->disableAllFunctions();
373 // Normal mode, emit a .s or .o file by running the code generator. Note,
374 // this also adds codegenerator level optimization passes.
375 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
376 if (Action == Backend_EmitObj)
377 CGFT = TargetMachine::CGFT_ObjectFile;
378 else if (Action == Backend_EmitMCNull)
379 CGFT = TargetMachine::CGFT_Null;
381 assert(Action == Backend_EmitAssembly && "Invalid action!");
383 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
384 // "codegen" passes so that it isn't run multiple times when there is
385 // inlining happening.
386 if (LangOpts.ObjCAutoRefCount &&
387 CodeGenOpts.OptimizationLevel > 0)
388 PM->add(createObjCARCContractPass());
390 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
391 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
392 Diags.Report(diag::err_fe_unable_to_interface_with_target);
399 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
400 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
401 llvm::formatted_raw_ostream FormattedOS;
405 case Backend_EmitNothing:
409 getPerModulePasses()->add(createBitcodeWriterPass(*OS));
413 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
414 getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
418 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
419 if (!AddEmitPasses(Action, FormattedOS))
423 // Before executing passes, print the final values of the LLVM options.
424 cl::PrintOptionValues();
426 // Run passes. For now we do all passes at once, but eventually we
427 // would like to have the option of streaming code generation.
429 if (PerFunctionPasses) {
430 PrettyStackTraceString CrashInfo("Per-function optimization");
432 PerFunctionPasses->doInitialization();
433 for (Module::iterator I = TheModule->begin(),
434 E = TheModule->end(); I != E; ++I)
435 if (!I->isDeclaration())
436 PerFunctionPasses->run(*I);
437 PerFunctionPasses->doFinalization();
440 if (PerModulePasses) {
441 PrettyStackTraceString CrashInfo("Per-module optimization passes");
442 PerModulePasses->run(*TheModule);
446 PrettyStackTraceString CrashInfo("Code generation");
447 CodeGenPasses->run(*TheModule);
451 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
452 const CodeGenOptions &CGOpts,
453 const clang::TargetOptions &TOpts,
454 const LangOptions &LOpts,
456 BackendAction Action, raw_ostream *OS) {
457 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
459 AsmHelper.EmitAssembly(Action, OS);