blob: 414f65ecf385dd5ec4a20e7c882f01d1f6c7deeb [file] [log] [blame]
Daniel Dunbar897c6762010-06-07 23:20:08 +00001//===--- 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
Daniel Dunbar9b414d32010-06-15 17:48:49 +000010#include "clang/CodeGen/BackendUtil.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000011#include "clang/Basic/Diagnostic.h"
12#include "clang/Basic/TargetOptions.h"
Dan Gohmanb18b8ad2011-07-05 22:02:36 +000013#include "clang/Basic/LangOptions.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000014#include "clang/Frontend/CodeGenOptions.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000015#include "clang/Frontend/FrontendDiagnostic.h"
16#include "llvm/Module.h"
17#include "llvm/PassManager.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000018#include "llvm/Analysis/Verifier.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000019#include "llvm/Assembly/PrintModulePass.h"
20#include "llvm/Bitcode/ReaderWriter.h"
21#include "llvm/CodeGen/RegAllocRegistry.h"
22#include "llvm/CodeGen/SchedulerRegistry.h"
Evan Cheng693769c2011-06-29 01:14:32 +000023#include "llvm/MC/SubtargetFeature.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000024#include "llvm/Support/CommandLine.h"
25#include "llvm/Support/FormattedStream.h"
26#include "llvm/Support/PrettyStackTrace.h"
Evan Chenga6b40452011-08-24 18:09:14 +000027#include "llvm/Support/TargetRegistry.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000028#include "llvm/Support/Timer.h"
29#include "llvm/Support/raw_ostream.h"
Micah Villmow25a6a842012-10-08 16:25:52 +000030#include "llvm/DataLayout.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000031#include "llvm/Target/TargetLibraryInfo.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000032#include "llvm/Target/TargetMachine.h"
33#include "llvm/Target/TargetOptions.h"
Nick Lewyckye8ba8d72011-04-21 23:44:07 +000034#include "llvm/Transforms/Instrumentation.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000035#include "llvm/Transforms/IPO.h"
36#include "llvm/Transforms/IPO/PassManagerBuilder.h"
37#include "llvm/Transforms/Scalar.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000038using namespace clang;
39using namespace llvm;
40
41namespace {
42
43class EmitAssemblyHelper {
David Blaikied6471f72011-09-25 23:23:43 +000044 DiagnosticsEngine &Diags;
Daniel Dunbar897c6762010-06-07 23:20:08 +000045 const CodeGenOptions &CodeGenOpts;
Nick Lewycky3aaeccc2011-12-02 22:17:00 +000046 const clang::TargetOptions &TargetOpts;
Dan Gohmanb18b8ad2011-07-05 22:02:36 +000047 const LangOptions &LangOpts;
Daniel Dunbar897c6762010-06-07 23:20:08 +000048 Module *TheModule;
Daniel Dunbar897c6762010-06-07 23:20:08 +000049
50 Timer CodeGenerationTime;
51
Daniel Dunbardb2f2372010-09-17 07:35:16 +000052 mutable PassManager *CodeGenPasses;
Daniel Dunbar897c6762010-06-07 23:20:08 +000053 mutable PassManager *PerModulePasses;
54 mutable FunctionPassManager *PerFunctionPasses;
55
56private:
Nadav Rotemfa60be02012-10-24 00:53:38 +000057 PassManager *getCodeGenPasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000058 if (!CodeGenPasses) {
Daniel Dunbardb2f2372010-09-17 07:35:16 +000059 CodeGenPasses = new PassManager();
Micah Villmow25a6a842012-10-08 16:25:52 +000060 CodeGenPasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000061 // Add TargetTransformInfo.
62 if (TM) {
63 TargetTransformInfo *TTI =
64 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
65 TM->getVectorTargetTransformInfo());
66 CodeGenPasses->add(TTI);
67 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000068 }
69 return CodeGenPasses;
70 }
71
Nadav Rotemfa60be02012-10-24 00:53:38 +000072 PassManager *getPerModulePasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000073 if (!PerModulePasses) {
74 PerModulePasses = new PassManager();
Micah Villmow25a6a842012-10-08 16:25:52 +000075 PerModulePasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000076 if (TM) {
77 TargetTransformInfo *TTI =
78 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
79 TM->getVectorTargetTransformInfo());
80 PerModulePasses->add(TTI);
81 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000082 }
83 return PerModulePasses;
84 }
85
Nadav Rotemfa60be02012-10-24 00:53:38 +000086 FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000087 if (!PerFunctionPasses) {
88 PerFunctionPasses = new FunctionPassManager(TheModule);
Micah Villmow25a6a842012-10-08 16:25:52 +000089 PerFunctionPasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000090 if (TM) {
91 TargetTransformInfo *TTI =
92 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
93 TM->getVectorTargetTransformInfo());
94 PerFunctionPasses->add(TTI);
95 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000096 }
97 return PerFunctionPasses;
98 }
99
Nadav Rotemfa60be02012-10-24 00:53:38 +0000100
101 void CreatePasses(TargetMachine *TM);
102
Nadav Rotem129369d2012-10-24 03:52:31 +0000103 /// CreateTargetMachine - Generates the TargetMachine.
104 /// Returns Null if it is unable to create the target machine.
105 /// Some of our clang tests specify triples which are not built
106 /// into clang. This is okay because these tests check the generated
107 /// IR, and they require DataLayout which depends on the triple.
108 /// In this case, we allow this method to fail and not report an error.
109 /// When MustCreateTM is used, we print an error if we are unable to load
110 /// the requested target.
111 TargetMachine *CreateTargetMachine(bool MustCreateTM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000112
113 /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
114 ///
115 /// \return True on success.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000116 bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS,
117 TargetMachine *TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000118
119public:
David Blaikied6471f72011-09-25 23:23:43 +0000120 EmitAssemblyHelper(DiagnosticsEngine &_Diags,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000121 const CodeGenOptions &CGOpts,
122 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000123 const LangOptions &LOpts,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000124 Module *M)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000125 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000126 TheModule(M), CodeGenerationTime("Code Generation Time"),
Daniel Dunbar897c6762010-06-07 23:20:08 +0000127 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
128
129 ~EmitAssemblyHelper() {
130 delete CodeGenPasses;
131 delete PerModulePasses;
132 delete PerFunctionPasses;
133 }
134
135 void EmitAssembly(BackendAction Action, raw_ostream *OS);
136};
137
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000138// We need this wrapper to access LangOpts from extension functions that
139// we add to the PassManagerBuilder.
140class PassManagerBuilderWrapper : public PassManagerBuilder {
141public:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000142 PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
143 const LangOptions &LangOpts)
144 : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
145 const CodeGenOptions &getCGOpts() const { return CGOpts; }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000146 const LangOptions &getLangOpts() const { return LangOpts; }
147private:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000148 const CodeGenOptions &CGOpts;
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000149 const LangOptions &LangOpts;
150};
151
Daniel Dunbar897c6762010-06-07 23:20:08 +0000152}
153
Dan Gohmana8398ea2012-01-17 20:54:51 +0000154static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
155 if (Builder.OptLevel > 0)
156 PM.add(createObjCARCAPElimPass());
157}
158
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000159static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
160 if (Builder.OptLevel > 0)
161 PM.add(createObjCARCExpandPass());
162}
163
164static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
165 if (Builder.OptLevel > 0)
166 PM.add(createObjCARCOptPass());
167}
168
Nuno Lopesdef18492012-05-22 17:19:45 +0000169static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
170 PassManagerBase &PM) {
Joey Gouly85489082012-11-23 10:39:49 +0000171 PM.add(createBoundsCheckingPass());
Nuno Lopesdef18492012-05-22 17:19:45 +0000172}
173
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000174static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
175 PassManagerBase &PM) {
176 const PassManagerBuilderWrapper &BuilderWrapper =
177 static_cast<const PassManagerBuilderWrapper&>(Builder);
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000178 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000179 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
180 PM.add(createAddressSanitizerFunctionPass(LangOpts.SanitizeInitOrder,
181 LangOpts.SanitizeUseAfterReturn,
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000182 LangOpts.SanitizeUseAfterScope,
183 CGOpts.SanitizerBlacklistFile));
184 PM.add(createAddressSanitizerModulePass(LangOpts.SanitizeInitOrder,
185 CGOpts.SanitizerBlacklistFile));
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000186}
187
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000188static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
189 PassManagerBase &PM) {
190 PM.add(createMemorySanitizerPass());
191}
192
Kostya Serebryany3c931222012-03-01 22:27:08 +0000193static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
194 PassManagerBase &PM) {
195 PM.add(createThreadSanitizerPass());
196}
197
Nadav Rotemfa60be02012-10-24 00:53:38 +0000198void EmitAssemblyHelper::CreatePasses(TargetMachine *TM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000199 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000200 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000201
202 // Handle disabling of LLVM optimization, where we want to preserve the
203 // internal module before any optimization.
204 if (CodeGenOpts.DisableLLVMOpts) {
205 OptLevel = 0;
206 Inlining = CodeGenOpts.NoInlining;
207 }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000208
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000209 PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
Chris Lattner9ca02e52011-05-21 23:50:44 +0000210 PMBuilder.OptLevel = OptLevel;
211 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
Andrew Trick6445d622011-04-05 18:49:32 +0000212
Chris Lattner9ca02e52011-05-21 23:50:44 +0000213 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
214 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
215 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000216
217 // In ObjC ARC mode, add the main ARC optimization passes.
218 if (LangOpts.ObjCAutoRefCount) {
219 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
220 addObjCARCExpandPass);
Dan Gohmana8398ea2012-01-17 20:54:51 +0000221 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
222 addObjCARCAPElimPass);
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000223 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
224 addObjCARCOptPass);
225 }
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000226
Joey Gouly85489082012-11-23 10:39:49 +0000227 if (LangOpts.SanitizeBounds) {
Nuno Lopesdef18492012-05-22 17:19:45 +0000228 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
229 addBoundsCheckingPass);
230 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
231 addBoundsCheckingPass);
232 }
233
Richard Smithca1b62a2012-11-05 21:48:12 +0000234 if (LangOpts.SanitizeAddress) {
Kostya Serebryanyba1f0402012-10-15 14:22:56 +0000235 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000236 addAddressSanitizerPasses);
Kostya Serebryanye5dd2ea2011-11-30 22:20:21 +0000237 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000238 addAddressSanitizerPasses);
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000239 }
Kostya Serebryany3c931222012-03-01 22:27:08 +0000240
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000241 if (LangOpts.SanitizeMemory) {
242 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
243 addMemorySanitizerPass);
244 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
245 addMemorySanitizerPass);
246 }
247
Richard Smithca1b62a2012-11-05 21:48:12 +0000248 if (LangOpts.SanitizeThread) {
Kostya Serebryanye78ec3e2012-03-23 23:25:23 +0000249 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Kostya Serebryany3c931222012-03-01 22:27:08 +0000250 addThreadSanitizerPass);
251 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
252 addThreadSanitizerPass);
253 }
254
Chris Lattner33c09d52011-05-21 20:40:11 +0000255 // Figure out TargetLibraryInfo.
Bill Wendling3621b312011-05-17 23:06:23 +0000256 Triple TargetTriple(TheModule->getTargetTriple());
Chris Lattner9ca02e52011-05-21 23:50:44 +0000257 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
Chris Lattner98ec3f72011-02-18 22:34:47 +0000258 if (!CodeGenOpts.SimplifyLibCalls)
Chris Lattner9ca02e52011-05-21 23:50:44 +0000259 PMBuilder.LibraryInfo->disableAllFunctions();
Chris Lattner33c09d52011-05-21 20:40:11 +0000260
Daniel Dunbar897c6762010-06-07 23:20:08 +0000261 switch (Inlining) {
262 case CodeGenOptions::NoInlining: break;
263 case CodeGenOptions::NormalInlining: {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000264 // FIXME: Derive these constants in a principled fashion.
265 unsigned Threshold = 225;
Chris Lattner33c09d52011-05-21 20:40:11 +0000266 if (CodeGenOpts.OptimizeSize == 1) // -Os
Daniel Dunbar897c6762010-06-07 23:20:08 +0000267 Threshold = 75;
Chris Lattner33c09d52011-05-21 20:40:11 +0000268 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
Bob Wilsona0fa2032011-04-29 22:49:50 +0000269 Threshold = 25;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000270 else if (OptLevel > 2)
271 Threshold = 275;
Chris Lattner9ca02e52011-05-21 23:50:44 +0000272 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000273 break;
274 }
275 case CodeGenOptions::OnlyAlwaysInlining:
Chris Lattner33c09d52011-05-21 20:40:11 +0000276 // Respect always_inline.
Chad Rosier98759622012-02-25 02:56:13 +0000277 if (OptLevel == 0)
278 // Do not insert lifetime intrinsics at -O0.
279 PMBuilder.Inliner = createAlwaysInlinerPass(false);
280 else
281 PMBuilder.Inliner = createAlwaysInlinerPass();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000282 break;
283 }
284
Chris Lattner33c09d52011-05-21 20:40:11 +0000285 // Set up the per-function pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000286 FunctionPassManager *FPM = getPerFunctionPasses(TM);
Chris Lattner33c09d52011-05-21 20:40:11 +0000287 if (CodeGenOpts.VerifyModule)
288 FPM->add(createVerifierPass());
289 PMBuilder.populateFunctionPassManager(*FPM);
Andrew Trick6445d622011-04-05 18:49:32 +0000290
Chris Lattner33c09d52011-05-21 20:40:11 +0000291 // Set up the per-module pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000292 PassManager *MPM = getPerModulePasses(TM);
Chris Lattnerdf619762011-02-18 22:20:38 +0000293
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000294 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
295 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
Bill Wendling3621b312011-05-17 23:06:23 +0000296 CodeGenOpts.EmitGcovArcs,
297 TargetTriple.isMacOSX()));
298
Douglas Gregor4cdad312012-10-23 20:05:01 +0000299 if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000300 MPM->add(createStripSymbolsPass(true));
301 }
Nadav Rotem129369d2012-10-24 03:52:31 +0000302
Chris Lattner33c09d52011-05-21 20:40:11 +0000303 PMBuilder.populateModulePassManager(*MPM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000304}
305
Nadav Rotem129369d2012-10-24 03:52:31 +0000306TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000307 // Create the TargetMachine for generating code.
308 std::string Error;
309 std::string Triple = TheModule->getTargetTriple();
310 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
311 if (!TheTarget) {
Nadav Rotem129369d2012-10-24 03:52:31 +0000312 if (MustCreateTM)
313 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
Nadav Rotemfa60be02012-10-24 00:53:38 +0000314 return 0;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000315 }
316
317 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
318 // being gross, this is also totally broken if we ever care about
319 // concurrency.
Daniel Dunbar1ad66482010-07-01 01:31:45 +0000320
Daniel Dunbar897c6762010-06-07 23:20:08 +0000321 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
322
323 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
324 TargetMachine::setDataSections (CodeGenOpts.DataSections);
325
326 // FIXME: Parse this earlier.
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000327 llvm::CodeModel::Model CM;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000328 if (CodeGenOpts.CodeModel == "small") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000329 CM = llvm::CodeModel::Small;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000330 } else if (CodeGenOpts.CodeModel == "kernel") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000331 CM = llvm::CodeModel::Kernel;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000332 } else if (CodeGenOpts.CodeModel == "medium") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000333 CM = llvm::CodeModel::Medium;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000334 } else if (CodeGenOpts.CodeModel == "large") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000335 CM = llvm::CodeModel::Large;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000336 } else {
337 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000338 CM = llvm::CodeModel::Default;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000339 }
340
David Blaikie6bd17d22012-02-07 19:36:38 +0000341 SmallVector<const char *, 16> BackendArgs;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000342 BackendArgs.push_back("clang"); // Fake program name.
343 if (!CodeGenOpts.DebugPass.empty()) {
344 BackendArgs.push_back("-debug-pass");
345 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
346 }
347 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
348 BackendArgs.push_back("-limit-float-precision");
349 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
350 }
351 if (llvm::TimePassesIsEnabled)
352 BackendArgs.push_back("-time-passes");
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000353 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
354 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
Chad Rosier1b906052011-08-26 00:26:29 +0000355 if (CodeGenOpts.NoGlobalMerge)
356 BackendArgs.push_back("-global-merge=false");
Daniel Dunbar897c6762010-06-07 23:20:08 +0000357 BackendArgs.push_back(0);
358 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
David Blaikie6bd17d22012-02-07 19:36:38 +0000359 BackendArgs.data());
Daniel Dunbar897c6762010-06-07 23:20:08 +0000360
361 std::string FeaturesStr;
Evan Cheng368691e2011-06-30 02:06:32 +0000362 if (TargetOpts.Features.size()) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000363 SubtargetFeatures Features;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000364 for (std::vector<std::string>::const_iterator
365 it = TargetOpts.Features.begin(),
366 ie = TargetOpts.Features.end(); it != ie; ++it)
367 Features.AddFeature(*it);
368 FeaturesStr = Features.getString();
369 }
Evan Cheng2860e302011-07-19 06:37:41 +0000370
371 llvm::Reloc::Model RM = llvm::Reloc::Default;
372 if (CodeGenOpts.RelocationModel == "static") {
373 RM = llvm::Reloc::Static;
374 } else if (CodeGenOpts.RelocationModel == "pic") {
375 RM = llvm::Reloc::PIC_;
376 } else {
377 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
378 "Invalid PIC model!");
379 RM = llvm::Reloc::DynamicNoPIC;
380 }
381
Evan Cheng9254bf72011-11-16 08:38:55 +0000382 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
383 switch (CodeGenOpts.OptimizationLevel) {
384 default: break;
385 case 0: OptLevel = CodeGenOpt::None; break;
386 case 3: OptLevel = CodeGenOpt::Aggressive; break;
387 }
388
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000389 llvm::TargetOptions Options;
390
391 // Set frame pointer elimination mode.
392 if (!CodeGenOpts.DisableFPElim) {
393 Options.NoFramePointerElim = false;
394 Options.NoFramePointerElimNonLeaf = false;
395 } else if (CodeGenOpts.OmitLeafFramePointer) {
396 Options.NoFramePointerElim = false;
397 Options.NoFramePointerElimNonLeaf = true;
398 } else {
399 Options.NoFramePointerElim = true;
400 Options.NoFramePointerElimNonLeaf = true;
401 }
402
Rafael Espindola8af669f2012-06-19 01:26:10 +0000403 if (CodeGenOpts.UseInitArray)
404 Options.UseInitArray = true;
405
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000406 // Set float ABI type.
407 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
408 Options.FloatABIType = llvm::FloatABI::Soft;
409 else if (CodeGenOpts.FloatABI == "hard")
410 Options.FloatABIType = llvm::FloatABI::Hard;
411 else {
412 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
413 Options.FloatABIType = llvm::FloatABI::Default;
414 }
415
Lang Hamesc9686712012-07-06 00:59:19 +0000416 // Set FP fusion mode.
Lang Hames931c0832012-11-15 07:51:26 +0000417 switch (CodeGenOpts.getFPContractMode()) {
418 case CodeGenOptions::FPC_Off:
Lang Hamesc9686712012-07-06 00:59:19 +0000419 Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
420 break;
Lang Hames931c0832012-11-15 07:51:26 +0000421 case CodeGenOptions::FPC_On:
Lang Hamesc9686712012-07-06 00:59:19 +0000422 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
423 break;
Lang Hames931c0832012-11-15 07:51:26 +0000424 case CodeGenOptions::FPC_Fast:
Lang Hamesc9686712012-07-06 00:59:19 +0000425 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
Nadav Rotem25030c42012-10-19 04:15:32 +0000426 break;
Lang Hamesc9686712012-07-06 00:59:19 +0000427 }
428
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000429 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
430 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
431 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
432 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
433 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
434 Options.UseSoftFloat = CodeGenOpts.SoftFloat;
Nick Lewycky4e785c92011-12-06 03:33:03 +0000435 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
436 Options.RealignStack = CodeGenOpts.StackRealignment;
Nick Lewycky1db772b2012-01-23 08:29:12 +0000437 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
Bob Wilson71fd6cc2012-02-03 06:27:22 +0000438 Options.TrapFuncName = CodeGenOpts.TrapFuncName;
Chandler Carruth5081de52012-04-08 21:09:51 +0000439 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
Chad Rosiera7afeb02012-08-21 16:16:06 +0000440 Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000441
Evan Cheng368691e2011-06-30 02:06:32 +0000442 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000443 FeaturesStr, Options,
444 RM, CM, OptLevel);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000445
446 if (CodeGenOpts.RelaxAll)
447 TM->setMCRelaxAll(true);
Daniel Dunbar96932322011-03-28 22:49:28 +0000448 if (CodeGenOpts.SaveTempLabels)
449 TM->setMCSaveTempLabels(true);
Rafael Espindolaf24a1512011-04-30 18:35:43 +0000450 if (CodeGenOpts.NoDwarf2CFIAsm)
451 TM->setMCUseCFI(false);
Nick Lewyckyaaf2f362011-10-31 01:06:42 +0000452 if (!CodeGenOpts.NoDwarfDirectoryAsm)
453 TM->setMCUseDwarfDirectory(true);
Nick Lewyckyc3b90142011-06-21 00:14:18 +0000454 if (CodeGenOpts.NoExecStack)
455 TM->setMCNoExecStack(true);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000456
Nadav Rotemfa60be02012-10-24 00:53:38 +0000457 return TM;
458}
459
460bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
461 formatted_raw_ostream &OS,
462 TargetMachine *TM) {
463
Daniel Dunbar897c6762010-06-07 23:20:08 +0000464 // Create the code generator passes.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000465 PassManager *PM = getCodeGenPasses(TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000466
Chad Rosier3f3335d2012-02-29 20:14:59 +0000467 // Add LibraryInfo.
Daniel Dunbarcbbe2c02012-10-19 20:10:10 +0000468 llvm::Triple TargetTriple(TheModule->getTargetTriple());
469 TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
Chad Rosier3f3335d2012-02-29 20:14:59 +0000470 if (!CodeGenOpts.SimplifyLibCalls)
471 TLI->disableAllFunctions();
472 PM->add(TLI);
473
Nadav Rotem25030c42012-10-19 04:15:32 +0000474 // Add TargetTransformInfo.
475 PM->add(new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
476 TM->getVectorTargetTransformInfo()));
477
Daniel Dunbar897c6762010-06-07 23:20:08 +0000478 // Normal mode, emit a .s or .o file by running the code generator. Note,
479 // this also adds codegenerator level optimization passes.
480 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
481 if (Action == Backend_EmitObj)
482 CGFT = TargetMachine::CGFT_ObjectFile;
483 else if (Action == Backend_EmitMCNull)
484 CGFT = TargetMachine::CGFT_Null;
485 else
486 assert(Action == Backend_EmitAssembly && "Invalid action!");
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000487
488 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
489 // "codegen" passes so that it isn't run multiple times when there is
490 // inlining happening.
Dan Gohman465a8992012-04-04 21:04:56 +0000491 if (LangOpts.ObjCAutoRefCount &&
492 CodeGenOpts.OptimizationLevel > 0)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000493 PM->add(createObjCARCContractPass());
494
Evan Cheng9254bf72011-11-16 08:38:55 +0000495 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
Daniel Dunbar897c6762010-06-07 23:20:08 +0000496 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
497 Diags.Report(diag::err_fe_unable_to_interface_with_target);
498 return false;
499 }
500
501 return true;
502}
503
504void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
505 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
506 llvm::formatted_raw_ostream FormattedOS;
507
Nadav Rotem129369d2012-10-24 03:52:31 +0000508 bool UsesCodeGen = (Action != Backend_EmitNothing &&
509 Action != Backend_EmitBC &&
510 Action != Backend_EmitLL);
511 TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000512 CreatePasses(TM);
513
Daniel Dunbar897c6762010-06-07 23:20:08 +0000514 switch (Action) {
515 case Backend_EmitNothing:
516 break;
517
518 case Backend_EmitBC:
Nadav Rotemfa60be02012-10-24 00:53:38 +0000519 getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000520 break;
521
522 case Backend_EmitLL:
523 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000524 getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000525 break;
526
527 default:
528 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000529 if (!AddEmitPasses(Action, FormattedOS, TM))
Daniel Dunbar897c6762010-06-07 23:20:08 +0000530 return;
531 }
532
Andrew Trick92b5d942011-04-05 18:56:55 +0000533 // Before executing passes, print the final values of the LLVM options.
534 cl::PrintOptionValues();
535
Daniel Dunbar897c6762010-06-07 23:20:08 +0000536 // Run passes. For now we do all passes at once, but eventually we
537 // would like to have the option of streaming code generation.
538
539 if (PerFunctionPasses) {
540 PrettyStackTraceString CrashInfo("Per-function optimization");
541
542 PerFunctionPasses->doInitialization();
543 for (Module::iterator I = TheModule->begin(),
544 E = TheModule->end(); I != E; ++I)
545 if (!I->isDeclaration())
546 PerFunctionPasses->run(*I);
547 PerFunctionPasses->doFinalization();
548 }
549
550 if (PerModulePasses) {
551 PrettyStackTraceString CrashInfo("Per-module optimization passes");
552 PerModulePasses->run(*TheModule);
553 }
554
555 if (CodeGenPasses) {
556 PrettyStackTraceString CrashInfo("Code generation");
Daniel Dunbardb2f2372010-09-17 07:35:16 +0000557 CodeGenPasses->run(*TheModule);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000558 }
559}
560
David Blaikied6471f72011-09-25 23:23:43 +0000561void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
562 const CodeGenOptions &CGOpts,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000563 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000564 const LangOptions &LOpts,
565 Module *M,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000566 BackendAction Action, raw_ostream *OS) {
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000567 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000568
569 AsmHelper.EmitAssembly(Action, OS);
570}