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 unsigned BoundsChecking;
125 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
126 PassManagerBase &PM) {
127 PM.add(createBoundsCheckingPass(BoundsChecking));
130 static void addAddressSanitizerPass(const PassManagerBuilder &Builder,
131 PassManagerBase &PM) {
132 PM.add(createAddressSanitizerPass());
135 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
136 PassManagerBase &PM) {
137 PM.add(createThreadSanitizerPass());
140 void EmitAssemblyHelper::CreatePasses() {
141 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
142 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
144 // Handle disabling of LLVM optimization, where we want to preserve the
145 // internal module before any optimization.
146 if (CodeGenOpts.DisableLLVMOpts) {
148 Inlining = CodeGenOpts.NoInlining;
151 PassManagerBuilder PMBuilder;
152 PMBuilder.OptLevel = OptLevel;
153 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
155 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
156 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
157 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
159 // In ObjC ARC mode, add the main ARC optimization passes.
160 if (LangOpts.ObjCAutoRefCount) {
161 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
162 addObjCARCExpandPass);
163 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
164 addObjCARCAPElimPass);
165 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
169 if (CodeGenOpts.BoundsChecking > 0) {
170 BoundsChecking = CodeGenOpts.BoundsChecking;
171 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
172 addBoundsCheckingPass);
173 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
174 addBoundsCheckingPass);
177 if (LangOpts.AddressSanitizer) {
178 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
179 addAddressSanitizerPass);
180 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
181 addAddressSanitizerPass);
184 if (LangOpts.ThreadSanitizer) {
185 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
186 addThreadSanitizerPass);
187 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
188 addThreadSanitizerPass);
191 // Figure out TargetLibraryInfo.
192 Triple TargetTriple(TheModule->getTargetTriple());
193 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
194 if (!CodeGenOpts.SimplifyLibCalls)
195 PMBuilder.LibraryInfo->disableAllFunctions();
198 case CodeGenOptions::NoInlining: break;
199 case CodeGenOptions::NormalInlining: {
200 // FIXME: Derive these constants in a principled fashion.
201 unsigned Threshold = 225;
202 if (CodeGenOpts.OptimizeSize == 1) // -Os
204 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
206 else if (OptLevel > 2)
208 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
211 case CodeGenOptions::OnlyAlwaysInlining:
212 // Respect always_inline.
214 // Do not insert lifetime intrinsics at -O0.
215 PMBuilder.Inliner = createAlwaysInlinerPass(false);
217 PMBuilder.Inliner = createAlwaysInlinerPass();
222 // Set up the per-function pass manager.
223 FunctionPassManager *FPM = getPerFunctionPasses();
224 if (CodeGenOpts.VerifyModule)
225 FPM->add(createVerifierPass());
226 PMBuilder.populateFunctionPassManager(*FPM);
228 // Set up the per-module pass manager.
229 PassManager *MPM = getPerModulePasses();
231 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
232 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
233 CodeGenOpts.EmitGcovArcs,
234 TargetTriple.isMacOSX()));
236 if (CodeGenOpts.DebugInfo == CodeGenOptions::NoDebugInfo)
237 MPM->add(createStripSymbolsPass(true));
241 PMBuilder.populateModulePassManager(*MPM);
244 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
245 formatted_raw_ostream &OS) {
246 // Create the TargetMachine for generating code.
248 std::string Triple = TheModule->getTargetTriple();
249 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
251 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
255 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
256 // being gross, this is also totally broken if we ever care about
259 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
261 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
262 TargetMachine::setDataSections (CodeGenOpts.DataSections);
264 // FIXME: Parse this earlier.
265 llvm::CodeModel::Model CM;
266 if (CodeGenOpts.CodeModel == "small") {
267 CM = llvm::CodeModel::Small;
268 } else if (CodeGenOpts.CodeModel == "kernel") {
269 CM = llvm::CodeModel::Kernel;
270 } else if (CodeGenOpts.CodeModel == "medium") {
271 CM = llvm::CodeModel::Medium;
272 } else if (CodeGenOpts.CodeModel == "large") {
273 CM = llvm::CodeModel::Large;
275 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
276 CM = llvm::CodeModel::Default;
279 SmallVector<const char *, 16> BackendArgs;
280 BackendArgs.push_back("clang"); // Fake program name.
281 if (!CodeGenOpts.DebugPass.empty()) {
282 BackendArgs.push_back("-debug-pass");
283 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
285 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
286 BackendArgs.push_back("-limit-float-precision");
287 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
289 if (llvm::TimePassesIsEnabled)
290 BackendArgs.push_back("-time-passes");
291 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
292 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
293 if (CodeGenOpts.NoGlobalMerge)
294 BackendArgs.push_back("-global-merge=false");
295 BackendArgs.push_back(0);
296 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
299 std::string FeaturesStr;
300 if (TargetOpts.Features.size()) {
301 SubtargetFeatures Features;
302 for (std::vector<std::string>::const_iterator
303 it = TargetOpts.Features.begin(),
304 ie = TargetOpts.Features.end(); it != ie; ++it)
305 Features.AddFeature(*it);
306 FeaturesStr = Features.getString();
309 llvm::Reloc::Model RM = llvm::Reloc::Default;
310 if (CodeGenOpts.RelocationModel == "static") {
311 RM = llvm::Reloc::Static;
312 } else if (CodeGenOpts.RelocationModel == "pic") {
313 RM = llvm::Reloc::PIC_;
315 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
316 "Invalid PIC model!");
317 RM = llvm::Reloc::DynamicNoPIC;
320 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
321 switch (CodeGenOpts.OptimizationLevel) {
323 case 0: OptLevel = CodeGenOpt::None; break;
324 case 3: OptLevel = CodeGenOpt::Aggressive; break;
327 llvm::TargetOptions Options;
329 // Set frame pointer elimination mode.
330 if (!CodeGenOpts.DisableFPElim) {
331 Options.NoFramePointerElim = false;
332 Options.NoFramePointerElimNonLeaf = false;
333 } else if (CodeGenOpts.OmitLeafFramePointer) {
334 Options.NoFramePointerElim = false;
335 Options.NoFramePointerElimNonLeaf = true;
337 Options.NoFramePointerElim = true;
338 Options.NoFramePointerElimNonLeaf = true;
341 if (CodeGenOpts.UseInitArray)
342 Options.UseInitArray = true;
344 // Set float ABI type.
345 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
346 Options.FloatABIType = llvm::FloatABI::Soft;
347 else if (CodeGenOpts.FloatABI == "hard")
348 Options.FloatABIType = llvm::FloatABI::Hard;
350 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
351 Options.FloatABIType = llvm::FloatABI::Default;
354 // Set FP fusion mode.
355 switch (LangOpts.getFPContractMode()) {
356 case LangOptions::FPC_Off:
357 Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
359 case LangOptions::FPC_On:
360 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
362 case LangOptions::FPC_Fast:
363 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
367 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
368 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
369 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
370 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
371 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
372 Options.UseSoftFloat = CodeGenOpts.SoftFloat;
373 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
374 Options.RealignStack = CodeGenOpts.StackRealignment;
375 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
376 Options.TrapFuncName = CodeGenOpts.TrapFuncName;
377 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
379 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
380 FeaturesStr, Options,
383 if (CodeGenOpts.RelaxAll)
384 TM->setMCRelaxAll(true);
385 if (CodeGenOpts.SaveTempLabels)
386 TM->setMCSaveTempLabels(true);
387 if (CodeGenOpts.NoDwarf2CFIAsm)
388 TM->setMCUseCFI(false);
389 if (!CodeGenOpts.NoDwarfDirectoryAsm)
390 TM->setMCUseDwarfDirectory(true);
391 if (CodeGenOpts.NoExecStack)
392 TM->setMCNoExecStack(true);
394 // Create the code generator passes.
395 PassManager *PM = getCodeGenPasses();
398 TargetLibraryInfo *TLI = new TargetLibraryInfo();
399 if (!CodeGenOpts.SimplifyLibCalls)
400 TLI->disableAllFunctions();
403 // Normal mode, emit a .s or .o file by running the code generator. Note,
404 // this also adds codegenerator level optimization passes.
405 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
406 if (Action == Backend_EmitObj)
407 CGFT = TargetMachine::CGFT_ObjectFile;
408 else if (Action == Backend_EmitMCNull)
409 CGFT = TargetMachine::CGFT_Null;
411 assert(Action == Backend_EmitAssembly && "Invalid action!");
413 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
414 // "codegen" passes so that it isn't run multiple times when there is
415 // inlining happening.
416 if (LangOpts.ObjCAutoRefCount &&
417 CodeGenOpts.OptimizationLevel > 0)
418 PM->add(createObjCARCContractPass());
420 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
421 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
422 Diags.Report(diag::err_fe_unable_to_interface_with_target);
429 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
430 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
431 llvm::formatted_raw_ostream FormattedOS;
435 case Backend_EmitNothing:
439 getPerModulePasses()->add(createBitcodeWriterPass(*OS));
443 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
444 getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
448 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
449 if (!AddEmitPasses(Action, FormattedOS))
453 // Before executing passes, print the final values of the LLVM options.
454 cl::PrintOptionValues();
456 // Run passes. For now we do all passes at once, but eventually we
457 // would like to have the option of streaming code generation.
459 if (PerFunctionPasses) {
460 PrettyStackTraceString CrashInfo("Per-function optimization");
462 PerFunctionPasses->doInitialization();
463 for (Module::iterator I = TheModule->begin(),
464 E = TheModule->end(); I != E; ++I)
465 if (!I->isDeclaration())
466 PerFunctionPasses->run(*I);
467 PerFunctionPasses->doFinalization();
470 if (PerModulePasses) {
471 PrettyStackTraceString CrashInfo("Per-module optimization passes");
472 PerModulePasses->run(*TheModule);
476 PrettyStackTraceString CrashInfo("Code generation");
477 CodeGenPasses->run(*TheModule);
481 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
482 const CodeGenOptions &CGOpts,
483 const clang::TargetOptions &TOpts,
484 const LangOptions &LOpts,
486 BackendAction Action, raw_ostream *OS) {
487 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
489 AsmHelper.EmitAssembly(Action, OS);