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:
getCodeGenPasses() const57 PassManager *getCodeGenPasses() const {
58 if (!CodeGenPasses) {
59 CodeGenPasses = new PassManager();
60 CodeGenPasses->add(new TargetData(TheModule));
61 }
62 return CodeGenPasses;
63 }
64
getPerModulePasses() const65 PassManager *getPerModulePasses() const {
66 if (!PerModulePasses) {
67 PerModulePasses = new PassManager();
68 PerModulePasses->add(new TargetData(TheModule));
69 }
70 return PerModulePasses;
71 }
72
getPerFunctionPasses() const73 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:
EmitAssemblyHelper(DiagnosticsEngine & _Diags,const CodeGenOptions & CGOpts,const clang::TargetOptions & TOpts,const LangOptions & LOpts,Module * M)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
~EmitAssemblyHelper()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
addObjCARCAPElimPass(const PassManagerBuilder & Builder,PassManagerBase & PM)109 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
110 if (Builder.OptLevel > 0)
111 PM.add(createObjCARCAPElimPass());
112 }
113
addObjCARCExpandPass(const PassManagerBuilder & Builder,PassManagerBase & PM)114 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
115 if (Builder.OptLevel > 0)
116 PM.add(createObjCARCExpandPass());
117 }
118
addObjCARCOptPass(const PassManagerBuilder & Builder,PassManagerBase & PM)119 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
120 if (Builder.OptLevel > 0)
121 PM.add(createObjCARCOptPass());
122 }
123
addAddressSanitizerPass(const PassManagerBuilder & Builder,PassManagerBase & PM)124 static void addAddressSanitizerPass(const PassManagerBuilder &Builder,
125 PassManagerBase &PM) {
126 PM.add(createAddressSanitizerPass());
127 }
128
addThreadSanitizerPass(const PassManagerBuilder & Builder,PassManagerBase & PM)129 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
130 PassManagerBase &PM) {
131 PM.add(createThreadSanitizerPass());
132 }
133
CreatePasses()134 void EmitAssemblyHelper::CreatePasses() {
135 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
136 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
137
138 // Handle disabling of LLVM optimization, where we want to preserve the
139 // internal module before any optimization.
140 if (CodeGenOpts.DisableLLVMOpts) {
141 OptLevel = 0;
142 Inlining = CodeGenOpts.NoInlining;
143 }
144
145 PassManagerBuilder PMBuilder;
146 PMBuilder.OptLevel = OptLevel;
147 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
148
149 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
150 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
151 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
152
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,
160 addObjCARCOptPass);
161 }
162
163 if (LangOpts.AddressSanitizer) {
164 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
165 addAddressSanitizerPass);
166 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
167 addAddressSanitizerPass);
168 }
169
170 if (LangOpts.ThreadSanitizer) {
171 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
172 addThreadSanitizerPass);
173 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
174 addThreadSanitizerPass);
175 }
176
177 // Figure out TargetLibraryInfo.
178 Triple TargetTriple(TheModule->getTargetTriple());
179 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
180 if (!CodeGenOpts.SimplifyLibCalls)
181 PMBuilder.LibraryInfo->disableAllFunctions();
182
183 switch (Inlining) {
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
189 Threshold = 75;
190 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
191 Threshold = 25;
192 else if (OptLevel > 2)
193 Threshold = 275;
194 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
195 break;
196 }
197 case CodeGenOptions::OnlyAlwaysInlining:
198 // Respect always_inline.
199 if (OptLevel == 0)
200 // Do not insert lifetime intrinsics at -O0.
201 PMBuilder.Inliner = createAlwaysInlinerPass(false);
202 else
203 PMBuilder.Inliner = createAlwaysInlinerPass();
204 break;
205 }
206
207
208 // Set up the per-function pass manager.
209 FunctionPassManager *FPM = getPerFunctionPasses();
210 if (CodeGenOpts.VerifyModule)
211 FPM->add(createVerifierPass());
212 PMBuilder.populateFunctionPassManager(*FPM);
213
214 // Set up the per-module pass manager.
215 PassManager *MPM = getPerModulePasses();
216
217 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
218 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
219 CodeGenOpts.EmitGcovArcs,
220 TargetTriple.isMacOSX()));
221
222 if (!CodeGenOpts.DebugInfo)
223 MPM->add(createStripSymbolsPass(true));
224 }
225
226
227 PMBuilder.populateModulePassManager(*MPM);
228 }
229
AddEmitPasses(BackendAction Action,formatted_raw_ostream & OS)230 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
231 formatted_raw_ostream &OS) {
232 // Create the TargetMachine for generating code.
233 std::string Error;
234 std::string Triple = TheModule->getTargetTriple();
235 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
236 if (!TheTarget) {
237 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
238 return false;
239 }
240
241 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
242 // being gross, this is also totally broken if we ever care about
243 // concurrency.
244
245 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
246
247 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
248 TargetMachine::setDataSections (CodeGenOpts.DataSections);
249
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;
260 } else {
261 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
262 CM = llvm::CodeModel::Default;
263 }
264
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());
270 }
271 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
272 BackendArgs.push_back("-limit-float-precision");
273 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
274 }
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,
283 BackendArgs.data());
284
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();
293 }
294
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_;
300 } else {
301 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
302 "Invalid PIC model!");
303 RM = llvm::Reloc::DynamicNoPIC;
304 }
305
306 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
307 switch (CodeGenOpts.OptimizationLevel) {
308 default: break;
309 case 0: OptLevel = CodeGenOpt::None; break;
310 case 3: OptLevel = CodeGenOpt::Aggressive; break;
311 }
312
313 llvm::TargetOptions Options;
314
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;
322 } else {
323 Options.NoFramePointerElim = true;
324 Options.NoFramePointerElimNonLeaf = true;
325 }
326
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;
332 else {
333 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
334 Options.FloatABIType = llvm::FloatABI::Default;
335 }
336
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;
348
349 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
350 FeaturesStr, Options,
351 RM, CM, OptLevel);
352
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);
363
364 // Create the code generator passes.
365 PassManager *PM = getCodeGenPasses();
366
367 // Add LibraryInfo.
368 TargetLibraryInfo *TLI = new TargetLibraryInfo();
369 if (!CodeGenOpts.SimplifyLibCalls)
370 TLI->disableAllFunctions();
371 PM->add(TLI);
372
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;
380 else
381 assert(Action == Backend_EmitAssembly && "Invalid action!");
382
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());
389
390 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
391 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
392 Diags.Report(diag::err_fe_unable_to_interface_with_target);
393 return false;
394 }
395
396 return true;
397 }
398
EmitAssembly(BackendAction Action,raw_ostream * OS)399 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
400 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
401 llvm::formatted_raw_ostream FormattedOS;
402
403 CreatePasses();
404 switch (Action) {
405 case Backend_EmitNothing:
406 break;
407
408 case Backend_EmitBC:
409 getPerModulePasses()->add(createBitcodeWriterPass(*OS));
410 break;
411
412 case Backend_EmitLL:
413 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
414 getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
415 break;
416
417 default:
418 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
419 if (!AddEmitPasses(Action, FormattedOS))
420 return;
421 }
422
423 // Before executing passes, print the final values of the LLVM options.
424 cl::PrintOptionValues();
425
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.
428
429 if (PerFunctionPasses) {
430 PrettyStackTraceString CrashInfo("Per-function optimization");
431
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();
438 }
439
440 if (PerModulePasses) {
441 PrettyStackTraceString CrashInfo("Per-module optimization passes");
442 PerModulePasses->run(*TheModule);
443 }
444
445 if (CodeGenPasses) {
446 PrettyStackTraceString CrashInfo("Code generation");
447 CodeGenPasses->run(*TheModule);
448 }
449 }
450
EmitBackendOutput(DiagnosticsEngine & Diags,const CodeGenOptions & CGOpts,const clang::TargetOptions & TOpts,const LangOptions & LOpts,Module * M,BackendAction Action,raw_ostream * OS)451 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
452 const CodeGenOptions &CGOpts,
453 const clang::TargetOptions &TOpts,
454 const LangOptions &LOpts,
455 Module *M,
456 BackendAction Action, raw_ostream *OS) {
457 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
458
459 AsmHelper.EmitAssembly(Action, OS);
460 }
461