blob: ea5bcb55f8c1dfa8aa5a398d07eb61fe106a4d1a [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"
Dan Gohmanb18b8ad2011-07-05 22:02:36 +000012#include "clang/Basic/LangOptions.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000013#include "clang/Basic/TargetOptions.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"
Rafael Espindolacf565c52011-08-02 21:51:02 +000016#include "llvm/Analysis/Verifier.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000017#include "llvm/Assembly/PrintModulePass.h"
18#include "llvm/Bitcode/ReaderWriter.h"
19#include "llvm/CodeGen/RegAllocRegistry.h"
20#include "llvm/CodeGen/SchedulerRegistry.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000021#include "llvm/DataLayout.h"
Evan Cheng693769c2011-06-29 01:14:32 +000022#include "llvm/MC/SubtargetFeature.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000023#include "llvm/Module.h"
24#include "llvm/PassManager.h"
NAKAMURA Takumi007c44c2012-12-11 05:53:24 +000025#include "llvm/TargetTransformInfo.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000026#include "llvm/Support/CommandLine.h"
27#include "llvm/Support/FormattedStream.h"
28#include "llvm/Support/PrettyStackTrace.h"
Evan Chenga6b40452011-08-24 18:09:14 +000029#include "llvm/Support/TargetRegistry.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000030#include "llvm/Support/Timer.h"
31#include "llvm/Support/raw_ostream.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000032#include "llvm/Target/TargetLibraryInfo.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000033#include "llvm/Target/TargetMachine.h"
34#include "llvm/Target/TargetOptions.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000035#include "llvm/Transforms/IPO.h"
36#include "llvm/Transforms/IPO/PassManagerBuilder.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000037#include "llvm/Transforms/Instrumentation.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000038#include "llvm/Transforms/Scalar.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000039using namespace clang;
40using namespace llvm;
41
42namespace {
43
44class EmitAssemblyHelper {
David Blaikied6471f72011-09-25 23:23:43 +000045 DiagnosticsEngine &Diags;
Daniel Dunbar897c6762010-06-07 23:20:08 +000046 const CodeGenOptions &CodeGenOpts;
Nick Lewycky3aaeccc2011-12-02 22:17:00 +000047 const clang::TargetOptions &TargetOpts;
Dan Gohmanb18b8ad2011-07-05 22:02:36 +000048 const LangOptions &LangOpts;
Daniel Dunbar897c6762010-06-07 23:20:08 +000049 Module *TheModule;
Daniel Dunbar897c6762010-06-07 23:20:08 +000050
51 Timer CodeGenerationTime;
52
Daniel Dunbardb2f2372010-09-17 07:35:16 +000053 mutable PassManager *CodeGenPasses;
Daniel Dunbar897c6762010-06-07 23:20:08 +000054 mutable PassManager *PerModulePasses;
55 mutable FunctionPassManager *PerFunctionPasses;
56
57private:
Nadav Rotemfa60be02012-10-24 00:53:38 +000058 PassManager *getCodeGenPasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000059 if (!CodeGenPasses) {
Daniel Dunbardb2f2372010-09-17 07:35:16 +000060 CodeGenPasses = new PassManager();
Micah Villmow25a6a842012-10-08 16:25:52 +000061 CodeGenPasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000062 // Add TargetTransformInfo.
63 if (TM) {
64 TargetTransformInfo *TTI =
65 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
66 TM->getVectorTargetTransformInfo());
67 CodeGenPasses->add(TTI);
68 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000069 }
70 return CodeGenPasses;
71 }
72
Nadav Rotemfa60be02012-10-24 00:53:38 +000073 PassManager *getPerModulePasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000074 if (!PerModulePasses) {
75 PerModulePasses = new PassManager();
Micah Villmow25a6a842012-10-08 16:25:52 +000076 PerModulePasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000077 if (TM) {
78 TargetTransformInfo *TTI =
79 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
80 TM->getVectorTargetTransformInfo());
81 PerModulePasses->add(TTI);
82 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000083 }
84 return PerModulePasses;
85 }
86
Nadav Rotemfa60be02012-10-24 00:53:38 +000087 FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000088 if (!PerFunctionPasses) {
89 PerFunctionPasses = new FunctionPassManager(TheModule);
Micah Villmow25a6a842012-10-08 16:25:52 +000090 PerFunctionPasses->add(new DataLayout(TheModule));
Nadav Rotemfa60be02012-10-24 00:53:38 +000091 if (TM) {
92 TargetTransformInfo *TTI =
93 new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
94 TM->getVectorTargetTransformInfo());
95 PerFunctionPasses->add(TTI);
96 }
Daniel Dunbar897c6762010-06-07 23:20:08 +000097 }
98 return PerFunctionPasses;
99 }
100
Nadav Rotemfa60be02012-10-24 00:53:38 +0000101
102 void CreatePasses(TargetMachine *TM);
103
Nadav Rotem129369d2012-10-24 03:52:31 +0000104 /// CreateTargetMachine - Generates the TargetMachine.
105 /// Returns Null if it is unable to create the target machine.
106 /// Some of our clang tests specify triples which are not built
107 /// into clang. This is okay because these tests check the generated
108 /// IR, and they require DataLayout which depends on the triple.
109 /// In this case, we allow this method to fail and not report an error.
110 /// When MustCreateTM is used, we print an error if we are unable to load
111 /// the requested target.
112 TargetMachine *CreateTargetMachine(bool MustCreateTM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000113
114 /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
115 ///
116 /// \return True on success.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000117 bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS,
118 TargetMachine *TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000119
120public:
David Blaikied6471f72011-09-25 23:23:43 +0000121 EmitAssemblyHelper(DiagnosticsEngine &_Diags,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000122 const CodeGenOptions &CGOpts,
123 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000124 const LangOptions &LOpts,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000125 Module *M)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000126 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000127 TheModule(M), CodeGenerationTime("Code Generation Time"),
Daniel Dunbar897c6762010-06-07 23:20:08 +0000128 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
129
130 ~EmitAssemblyHelper() {
131 delete CodeGenPasses;
132 delete PerModulePasses;
133 delete PerFunctionPasses;
134 }
135
136 void EmitAssembly(BackendAction Action, raw_ostream *OS);
137};
138
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000139// We need this wrapper to access LangOpts from extension functions that
140// we add to the PassManagerBuilder.
141class PassManagerBuilderWrapper : public PassManagerBuilder {
142public:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000143 PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
144 const LangOptions &LangOpts)
145 : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
146 const CodeGenOptions &getCGOpts() const { return CGOpts; }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000147 const LangOptions &getLangOpts() const { return LangOpts; }
148private:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000149 const CodeGenOptions &CGOpts;
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000150 const LangOptions &LangOpts;
151};
152
Daniel Dunbar897c6762010-06-07 23:20:08 +0000153}
154
Dan Gohmana8398ea2012-01-17 20:54:51 +0000155static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
156 if (Builder.OptLevel > 0)
157 PM.add(createObjCARCAPElimPass());
158}
159
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000160static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
161 if (Builder.OptLevel > 0)
162 PM.add(createObjCARCExpandPass());
163}
164
165static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
166 if (Builder.OptLevel > 0)
167 PM.add(createObjCARCOptPass());
168}
169
Nuno Lopesdef18492012-05-22 17:19:45 +0000170static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
171 PassManagerBase &PM) {
Joey Gouly85489082012-11-23 10:39:49 +0000172 PM.add(createBoundsCheckingPass());
Nuno Lopesdef18492012-05-22 17:19:45 +0000173}
174
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000175static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
176 PassManagerBase &PM) {
177 const PassManagerBuilderWrapper &BuilderWrapper =
178 static_cast<const PassManagerBuilderWrapper&>(Builder);
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000179 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000180 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
181 PM.add(createAddressSanitizerFunctionPass(LangOpts.SanitizeInitOrder,
182 LangOpts.SanitizeUseAfterReturn,
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000183 LangOpts.SanitizeUseAfterScope,
184 CGOpts.SanitizerBlacklistFile));
185 PM.add(createAddressSanitizerModulePass(LangOpts.SanitizeInitOrder,
186 CGOpts.SanitizerBlacklistFile));
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000187}
188
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000189static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
190 PassManagerBase &PM) {
Evgeniy Stepanov34ef11b2012-12-24 08:42:34 +0000191 const PassManagerBuilderWrapper &BuilderWrapper =
192 static_cast<const PassManagerBuilderWrapper&>(Builder);
193 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
194 PM.add(createMemorySanitizerPass(CGOpts.MemorySanitizerTrackOrigins));
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000195}
196
Kostya Serebryany3c931222012-03-01 22:27:08 +0000197static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
198 PassManagerBase &PM) {
199 PM.add(createThreadSanitizerPass());
200}
201
Nadav Rotemfa60be02012-10-24 00:53:38 +0000202void EmitAssemblyHelper::CreatePasses(TargetMachine *TM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000203 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000204 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000205
206 // Handle disabling of LLVM optimization, where we want to preserve the
207 // internal module before any optimization.
208 if (CodeGenOpts.DisableLLVMOpts) {
209 OptLevel = 0;
210 Inlining = CodeGenOpts.NoInlining;
211 }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000212
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000213 PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
Chris Lattner9ca02e52011-05-21 23:50:44 +0000214 PMBuilder.OptLevel = OptLevel;
215 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
Andrew Trick6445d622011-04-05 18:49:32 +0000216
Chris Lattner9ca02e52011-05-21 23:50:44 +0000217 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
218 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
219 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000220
221 // In ObjC ARC mode, add the main ARC optimization passes.
222 if (LangOpts.ObjCAutoRefCount) {
223 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
224 addObjCARCExpandPass);
Dan Gohmana8398ea2012-01-17 20:54:51 +0000225 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
226 addObjCARCAPElimPass);
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000227 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
228 addObjCARCOptPass);
229 }
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000230
Joey Gouly85489082012-11-23 10:39:49 +0000231 if (LangOpts.SanitizeBounds) {
Nuno Lopesdef18492012-05-22 17:19:45 +0000232 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
233 addBoundsCheckingPass);
234 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
235 addBoundsCheckingPass);
236 }
237
Richard Smithca1b62a2012-11-05 21:48:12 +0000238 if (LangOpts.SanitizeAddress) {
Kostya Serebryanyba1f0402012-10-15 14:22:56 +0000239 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000240 addAddressSanitizerPasses);
Kostya Serebryanye5dd2ea2011-11-30 22:20:21 +0000241 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000242 addAddressSanitizerPasses);
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000243 }
Kostya Serebryany3c931222012-03-01 22:27:08 +0000244
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000245 if (LangOpts.SanitizeMemory) {
246 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
247 addMemorySanitizerPass);
248 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
249 addMemorySanitizerPass);
250 }
251
Richard Smithca1b62a2012-11-05 21:48:12 +0000252 if (LangOpts.SanitizeThread) {
Kostya Serebryanye78ec3e2012-03-23 23:25:23 +0000253 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Kostya Serebryany3c931222012-03-01 22:27:08 +0000254 addThreadSanitizerPass);
255 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
256 addThreadSanitizerPass);
257 }
258
Chris Lattner33c09d52011-05-21 20:40:11 +0000259 // Figure out TargetLibraryInfo.
Bill Wendling3621b312011-05-17 23:06:23 +0000260 Triple TargetTriple(TheModule->getTargetTriple());
Chris Lattner9ca02e52011-05-21 23:50:44 +0000261 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
Chris Lattner98ec3f72011-02-18 22:34:47 +0000262 if (!CodeGenOpts.SimplifyLibCalls)
Chris Lattner9ca02e52011-05-21 23:50:44 +0000263 PMBuilder.LibraryInfo->disableAllFunctions();
Chris Lattner33c09d52011-05-21 20:40:11 +0000264
Daniel Dunbar897c6762010-06-07 23:20:08 +0000265 switch (Inlining) {
266 case CodeGenOptions::NoInlining: break;
267 case CodeGenOptions::NormalInlining: {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000268 // FIXME: Derive these constants in a principled fashion.
269 unsigned Threshold = 225;
Chris Lattner33c09d52011-05-21 20:40:11 +0000270 if (CodeGenOpts.OptimizeSize == 1) // -Os
Daniel Dunbar897c6762010-06-07 23:20:08 +0000271 Threshold = 75;
Chris Lattner33c09d52011-05-21 20:40:11 +0000272 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
Bob Wilsona0fa2032011-04-29 22:49:50 +0000273 Threshold = 25;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000274 else if (OptLevel > 2)
275 Threshold = 275;
Chris Lattner9ca02e52011-05-21 23:50:44 +0000276 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000277 break;
278 }
279 case CodeGenOptions::OnlyAlwaysInlining:
Chris Lattner33c09d52011-05-21 20:40:11 +0000280 // Respect always_inline.
Chad Rosier98759622012-02-25 02:56:13 +0000281 if (OptLevel == 0)
282 // Do not insert lifetime intrinsics at -O0.
283 PMBuilder.Inliner = createAlwaysInlinerPass(false);
284 else
285 PMBuilder.Inliner = createAlwaysInlinerPass();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000286 break;
287 }
288
Chris Lattner33c09d52011-05-21 20:40:11 +0000289 // Set up the per-function pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000290 FunctionPassManager *FPM = getPerFunctionPasses(TM);
Chris Lattner33c09d52011-05-21 20:40:11 +0000291 if (CodeGenOpts.VerifyModule)
292 FPM->add(createVerifierPass());
293 PMBuilder.populateFunctionPassManager(*FPM);
Andrew Trick6445d622011-04-05 18:49:32 +0000294
Chris Lattner33c09d52011-05-21 20:40:11 +0000295 // Set up the per-module pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000296 PassManager *MPM = getPerModulePasses(TM);
Chris Lattnerdf619762011-02-18 22:20:38 +0000297
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000298 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
299 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
Bill Wendling3621b312011-05-17 23:06:23 +0000300 CodeGenOpts.EmitGcovArcs,
Bill Wendling44f4a2d2012-12-10 19:47:53 +0000301 TargetTriple.isMacOSX(),
302 false,
303 CodeGenOpts.DisableRedZone));
Bill Wendling3621b312011-05-17 23:06:23 +0000304
Douglas Gregor4cdad312012-10-23 20:05:01 +0000305 if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000306 MPM->add(createStripSymbolsPass(true));
307 }
Nadav Rotem129369d2012-10-24 03:52:31 +0000308
Chris Lattner33c09d52011-05-21 20:40:11 +0000309 PMBuilder.populateModulePassManager(*MPM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000310}
311
Nadav Rotem129369d2012-10-24 03:52:31 +0000312TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000313 // Create the TargetMachine for generating code.
314 std::string Error;
315 std::string Triple = TheModule->getTargetTriple();
316 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
317 if (!TheTarget) {
Nadav Rotem129369d2012-10-24 03:52:31 +0000318 if (MustCreateTM)
319 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
Nadav Rotemfa60be02012-10-24 00:53:38 +0000320 return 0;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000321 }
322
323 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
324 // being gross, this is also totally broken if we ever care about
325 // concurrency.
Daniel Dunbar1ad66482010-07-01 01:31:45 +0000326
Daniel Dunbar897c6762010-06-07 23:20:08 +0000327 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
328
329 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
330 TargetMachine::setDataSections (CodeGenOpts.DataSections);
331
332 // FIXME: Parse this earlier.
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000333 llvm::CodeModel::Model CM;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000334 if (CodeGenOpts.CodeModel == "small") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000335 CM = llvm::CodeModel::Small;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000336 } else if (CodeGenOpts.CodeModel == "kernel") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000337 CM = llvm::CodeModel::Kernel;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000338 } else if (CodeGenOpts.CodeModel == "medium") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000339 CM = llvm::CodeModel::Medium;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000340 } else if (CodeGenOpts.CodeModel == "large") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000341 CM = llvm::CodeModel::Large;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000342 } else {
343 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000344 CM = llvm::CodeModel::Default;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000345 }
346
David Blaikie6bd17d22012-02-07 19:36:38 +0000347 SmallVector<const char *, 16> BackendArgs;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000348 BackendArgs.push_back("clang"); // Fake program name.
349 if (!CodeGenOpts.DebugPass.empty()) {
350 BackendArgs.push_back("-debug-pass");
351 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
352 }
353 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
354 BackendArgs.push_back("-limit-float-precision");
355 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
356 }
357 if (llvm::TimePassesIsEnabled)
358 BackendArgs.push_back("-time-passes");
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000359 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
360 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
Chad Rosier1b906052011-08-26 00:26:29 +0000361 if (CodeGenOpts.NoGlobalMerge)
362 BackendArgs.push_back("-global-merge=false");
Daniel Dunbar897c6762010-06-07 23:20:08 +0000363 BackendArgs.push_back(0);
364 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
David Blaikie6bd17d22012-02-07 19:36:38 +0000365 BackendArgs.data());
Daniel Dunbar897c6762010-06-07 23:20:08 +0000366
367 std::string FeaturesStr;
Evan Cheng368691e2011-06-30 02:06:32 +0000368 if (TargetOpts.Features.size()) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000369 SubtargetFeatures Features;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000370 for (std::vector<std::string>::const_iterator
371 it = TargetOpts.Features.begin(),
372 ie = TargetOpts.Features.end(); it != ie; ++it)
373 Features.AddFeature(*it);
374 FeaturesStr = Features.getString();
375 }
Evan Cheng2860e302011-07-19 06:37:41 +0000376
377 llvm::Reloc::Model RM = llvm::Reloc::Default;
378 if (CodeGenOpts.RelocationModel == "static") {
379 RM = llvm::Reloc::Static;
380 } else if (CodeGenOpts.RelocationModel == "pic") {
381 RM = llvm::Reloc::PIC_;
382 } else {
383 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
384 "Invalid PIC model!");
385 RM = llvm::Reloc::DynamicNoPIC;
386 }
387
Evan Cheng9254bf72011-11-16 08:38:55 +0000388 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
389 switch (CodeGenOpts.OptimizationLevel) {
390 default: break;
391 case 0: OptLevel = CodeGenOpt::None; break;
392 case 3: OptLevel = CodeGenOpt::Aggressive; break;
393 }
394
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000395 llvm::TargetOptions Options;
396
397 // Set frame pointer elimination mode.
398 if (!CodeGenOpts.DisableFPElim) {
399 Options.NoFramePointerElim = false;
400 Options.NoFramePointerElimNonLeaf = false;
401 } else if (CodeGenOpts.OmitLeafFramePointer) {
402 Options.NoFramePointerElim = false;
403 Options.NoFramePointerElimNonLeaf = true;
404 } else {
405 Options.NoFramePointerElim = true;
406 Options.NoFramePointerElimNonLeaf = true;
407 }
408
Rafael Espindola8af669f2012-06-19 01:26:10 +0000409 if (CodeGenOpts.UseInitArray)
410 Options.UseInitArray = true;
411
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000412 // Set float ABI type.
413 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
414 Options.FloatABIType = llvm::FloatABI::Soft;
415 else if (CodeGenOpts.FloatABI == "hard")
416 Options.FloatABIType = llvm::FloatABI::Hard;
417 else {
418 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
419 Options.FloatABIType = llvm::FloatABI::Default;
420 }
421
Lang Hamesc9686712012-07-06 00:59:19 +0000422 // Set FP fusion mode.
Lang Hames931c0832012-11-15 07:51:26 +0000423 switch (CodeGenOpts.getFPContractMode()) {
424 case CodeGenOptions::FPC_Off:
Lang Hamesc9686712012-07-06 00:59:19 +0000425 Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
426 break;
Lang Hames931c0832012-11-15 07:51:26 +0000427 case CodeGenOptions::FPC_On:
Lang Hamesc9686712012-07-06 00:59:19 +0000428 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
429 break;
Lang Hames931c0832012-11-15 07:51:26 +0000430 case CodeGenOptions::FPC_Fast:
Lang Hamesc9686712012-07-06 00:59:19 +0000431 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
Nadav Rotem25030c42012-10-19 04:15:32 +0000432 break;
Lang Hamesc9686712012-07-06 00:59:19 +0000433 }
434
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000435 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
436 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
437 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
438 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
439 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
440 Options.UseSoftFloat = CodeGenOpts.SoftFloat;
Nick Lewycky4e785c92011-12-06 03:33:03 +0000441 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
442 Options.RealignStack = CodeGenOpts.StackRealignment;
Nick Lewycky1db772b2012-01-23 08:29:12 +0000443 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
Bob Wilson71fd6cc2012-02-03 06:27:22 +0000444 Options.TrapFuncName = CodeGenOpts.TrapFuncName;
Chandler Carruth5081de52012-04-08 21:09:51 +0000445 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
Chad Rosiera7afeb02012-08-21 16:16:06 +0000446 Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000447
Evan Cheng368691e2011-06-30 02:06:32 +0000448 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000449 FeaturesStr, Options,
450 RM, CM, OptLevel);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000451
452 if (CodeGenOpts.RelaxAll)
453 TM->setMCRelaxAll(true);
Daniel Dunbar96932322011-03-28 22:49:28 +0000454 if (CodeGenOpts.SaveTempLabels)
455 TM->setMCSaveTempLabels(true);
Rafael Espindolaf24a1512011-04-30 18:35:43 +0000456 if (CodeGenOpts.NoDwarf2CFIAsm)
457 TM->setMCUseCFI(false);
Nick Lewyckyaaf2f362011-10-31 01:06:42 +0000458 if (!CodeGenOpts.NoDwarfDirectoryAsm)
459 TM->setMCUseDwarfDirectory(true);
Nick Lewyckyc3b90142011-06-21 00:14:18 +0000460 if (CodeGenOpts.NoExecStack)
461 TM->setMCNoExecStack(true);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000462
Nadav Rotemfa60be02012-10-24 00:53:38 +0000463 return TM;
464}
465
466bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
467 formatted_raw_ostream &OS,
468 TargetMachine *TM) {
469
Daniel Dunbar897c6762010-06-07 23:20:08 +0000470 // Create the code generator passes.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000471 PassManager *PM = getCodeGenPasses(TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000472
Chad Rosier3f3335d2012-02-29 20:14:59 +0000473 // Add LibraryInfo.
Daniel Dunbarcbbe2c02012-10-19 20:10:10 +0000474 llvm::Triple TargetTriple(TheModule->getTargetTriple());
475 TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
Chad Rosier3f3335d2012-02-29 20:14:59 +0000476 if (!CodeGenOpts.SimplifyLibCalls)
477 TLI->disableAllFunctions();
478 PM->add(TLI);
479
Nadav Rotem25030c42012-10-19 04:15:32 +0000480 // Add TargetTransformInfo.
481 PM->add(new TargetTransformInfo(TM->getScalarTargetTransformInfo(),
482 TM->getVectorTargetTransformInfo()));
483
Daniel Dunbar897c6762010-06-07 23:20:08 +0000484 // Normal mode, emit a .s or .o file by running the code generator. Note,
485 // this also adds codegenerator level optimization passes.
486 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
487 if (Action == Backend_EmitObj)
488 CGFT = TargetMachine::CGFT_ObjectFile;
489 else if (Action == Backend_EmitMCNull)
490 CGFT = TargetMachine::CGFT_Null;
491 else
492 assert(Action == Backend_EmitAssembly && "Invalid action!");
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000493
494 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
495 // "codegen" passes so that it isn't run multiple times when there is
496 // inlining happening.
Dan Gohman465a8992012-04-04 21:04:56 +0000497 if (LangOpts.ObjCAutoRefCount &&
498 CodeGenOpts.OptimizationLevel > 0)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000499 PM->add(createObjCARCContractPass());
500
Evan Cheng9254bf72011-11-16 08:38:55 +0000501 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
Daniel Dunbar897c6762010-06-07 23:20:08 +0000502 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
503 Diags.Report(diag::err_fe_unable_to_interface_with_target);
504 return false;
505 }
506
507 return true;
508}
509
510void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
511 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
512 llvm::formatted_raw_ostream FormattedOS;
513
Nadav Rotem129369d2012-10-24 03:52:31 +0000514 bool UsesCodeGen = (Action != Backend_EmitNothing &&
515 Action != Backend_EmitBC &&
516 Action != Backend_EmitLL);
517 TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000518 CreatePasses(TM);
519
Daniel Dunbar897c6762010-06-07 23:20:08 +0000520 switch (Action) {
521 case Backend_EmitNothing:
522 break;
523
524 case Backend_EmitBC:
Nadav Rotemfa60be02012-10-24 00:53:38 +0000525 getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000526 break;
527
528 case Backend_EmitLL:
529 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000530 getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000531 break;
532
533 default:
534 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000535 if (!AddEmitPasses(Action, FormattedOS, TM))
Daniel Dunbar897c6762010-06-07 23:20:08 +0000536 return;
537 }
538
Andrew Trick92b5d942011-04-05 18:56:55 +0000539 // Before executing passes, print the final values of the LLVM options.
540 cl::PrintOptionValues();
541
Daniel Dunbar897c6762010-06-07 23:20:08 +0000542 // Run passes. For now we do all passes at once, but eventually we
543 // would like to have the option of streaming code generation.
544
545 if (PerFunctionPasses) {
546 PrettyStackTraceString CrashInfo("Per-function optimization");
547
548 PerFunctionPasses->doInitialization();
549 for (Module::iterator I = TheModule->begin(),
550 E = TheModule->end(); I != E; ++I)
551 if (!I->isDeclaration())
552 PerFunctionPasses->run(*I);
553 PerFunctionPasses->doFinalization();
554 }
555
556 if (PerModulePasses) {
557 PrettyStackTraceString CrashInfo("Per-module optimization passes");
558 PerModulePasses->run(*TheModule);
559 }
560
561 if (CodeGenPasses) {
562 PrettyStackTraceString CrashInfo("Code generation");
Daniel Dunbardb2f2372010-09-17 07:35:16 +0000563 CodeGenPasses->run(*TheModule);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000564 }
565}
566
David Blaikied6471f72011-09-25 23:23:43 +0000567void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
568 const CodeGenOptions &CGOpts,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000569 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000570 const LangOptions &LOpts,
571 Module *M,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000572 BackendAction Action, raw_ostream *OS) {
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000573 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000574
575 AsmHelper.EmitAssembly(Action, OS);
576}