blob: 8a3ee398cd10aa0b1a31bc3d2b50706c34b4e404 [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 Carruth3b844ba2013-01-02 11:45:17 +000021#include "llvm/IR/DataLayout.h"
22#include "llvm/IR/Module.h"
Evan Cheng693769c2011-06-29 01:14:32 +000023#include "llvm/MC/SubtargetFeature.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000024#include "llvm/PassManager.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000025#include "llvm/Support/CommandLine.h"
26#include "llvm/Support/FormattedStream.h"
27#include "llvm/Support/PrettyStackTrace.h"
Evan Chenga6b40452011-08-24 18:09:14 +000028#include "llvm/Support/TargetRegistry.h"
Daniel Dunbar897c6762010-06-07 23:20:08 +000029#include "llvm/Support/Timer.h"
30#include "llvm/Support/raw_ostream.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"
Rafael Espindolacf565c52011-08-02 21:51:02 +000034#include "llvm/Transforms/IPO.h"
35#include "llvm/Transforms/IPO/PassManagerBuilder.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000036#include "llvm/Transforms/Instrumentation.h"
Rafael Espindolacf565c52011-08-02 21:51:02 +000037#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));
Chandler Carruthd938e872013-01-07 01:38:01 +000061 if (TM)
62 TM->addAnalysisPasses(*CodeGenPasses);
Daniel Dunbar897c6762010-06-07 23:20:08 +000063 }
64 return CodeGenPasses;
65 }
66
Nadav Rotemfa60be02012-10-24 00:53:38 +000067 PassManager *getPerModulePasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000068 if (!PerModulePasses) {
69 PerModulePasses = new PassManager();
Micah Villmow25a6a842012-10-08 16:25:52 +000070 PerModulePasses->add(new DataLayout(TheModule));
Chandler Carruthd938e872013-01-07 01:38:01 +000071 if (TM)
72 TM->addAnalysisPasses(*PerModulePasses);
Daniel Dunbar897c6762010-06-07 23:20:08 +000073 }
74 return PerModulePasses;
75 }
76
Nadav Rotemfa60be02012-10-24 00:53:38 +000077 FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const {
Daniel Dunbar897c6762010-06-07 23:20:08 +000078 if (!PerFunctionPasses) {
79 PerFunctionPasses = new FunctionPassManager(TheModule);
Micah Villmow25a6a842012-10-08 16:25:52 +000080 PerFunctionPasses->add(new DataLayout(TheModule));
Chandler Carruthd938e872013-01-07 01:38:01 +000081 if (TM)
82 TM->addAnalysisPasses(*PerFunctionPasses);
Daniel Dunbar897c6762010-06-07 23:20:08 +000083 }
84 return PerFunctionPasses;
85 }
86
Nadav Rotemfa60be02012-10-24 00:53:38 +000087
88 void CreatePasses(TargetMachine *TM);
89
Nadav Rotem129369d2012-10-24 03:52:31 +000090 /// CreateTargetMachine - Generates the TargetMachine.
91 /// Returns Null if it is unable to create the target machine.
92 /// Some of our clang tests specify triples which are not built
93 /// into clang. This is okay because these tests check the generated
94 /// IR, and they require DataLayout which depends on the triple.
95 /// In this case, we allow this method to fail and not report an error.
96 /// When MustCreateTM is used, we print an error if we are unable to load
97 /// the requested target.
98 TargetMachine *CreateTargetMachine(bool MustCreateTM);
Daniel Dunbar897c6762010-06-07 23:20:08 +000099
100 /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
101 ///
102 /// \return True on success.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000103 bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS,
104 TargetMachine *TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000105
106public:
David Blaikied6471f72011-09-25 23:23:43 +0000107 EmitAssemblyHelper(DiagnosticsEngine &_Diags,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000108 const CodeGenOptions &CGOpts,
109 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000110 const LangOptions &LOpts,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000111 Module *M)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000112 : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000113 TheModule(M), CodeGenerationTime("Code Generation Time"),
Daniel Dunbar897c6762010-06-07 23:20:08 +0000114 CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
115
116 ~EmitAssemblyHelper() {
117 delete CodeGenPasses;
118 delete PerModulePasses;
119 delete PerFunctionPasses;
120 }
121
122 void EmitAssembly(BackendAction Action, raw_ostream *OS);
123};
124
Alexey Samsonove8c03222012-12-28 09:31:34 +0000125// We need this wrapper to access LangOpts and CGOpts from extension functions
126// that we add to the PassManagerBuilder.
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000127class PassManagerBuilderWrapper : public PassManagerBuilder {
128public:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000129 PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
130 const LangOptions &LangOpts)
131 : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
132 const CodeGenOptions &getCGOpts() const { return CGOpts; }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000133 const LangOptions &getLangOpts() const { return LangOpts; }
134private:
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000135 const CodeGenOptions &CGOpts;
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000136 const LangOptions &LangOpts;
137};
138
Daniel Dunbar897c6762010-06-07 23:20:08 +0000139}
140
Dan Gohmana8398ea2012-01-17 20:54:51 +0000141static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
142 if (Builder.OptLevel > 0)
143 PM.add(createObjCARCAPElimPass());
144}
145
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000146static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
147 if (Builder.OptLevel > 0)
148 PM.add(createObjCARCExpandPass());
149}
150
151static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
152 if (Builder.OptLevel > 0)
153 PM.add(createObjCARCOptPass());
154}
155
Nuno Lopesdef18492012-05-22 17:19:45 +0000156static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
157 PassManagerBase &PM) {
Joey Gouly85489082012-11-23 10:39:49 +0000158 PM.add(createBoundsCheckingPass());
Nuno Lopesdef18492012-05-22 17:19:45 +0000159}
160
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000161static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
162 PassManagerBase &PM) {
163 const PassManagerBuilderWrapper &BuilderWrapper =
164 static_cast<const PassManagerBuilderWrapper&>(Builder);
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000165 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000166 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
Will Dietz4f45bc02013-01-18 11:30:38 +0000167 PM.add(createAddressSanitizerFunctionPass(LangOpts.Sanitize.InitOrder,
168 LangOpts.Sanitize.UseAfterReturn,
169 LangOpts.Sanitize.UseAfterScope,
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000170 CGOpts.SanitizerBlacklistFile));
Will Dietz4f45bc02013-01-18 11:30:38 +0000171 PM.add(createAddressSanitizerModulePass(LangOpts.Sanitize.InitOrder,
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000172 CGOpts.SanitizerBlacklistFile));
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000173}
174
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000175static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
176 PassManagerBase &PM) {
Evgeniy Stepanov34ef11b2012-12-24 08:42:34 +0000177 const PassManagerBuilderWrapper &BuilderWrapper =
178 static_cast<const PassManagerBuilderWrapper&>(Builder);
179 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
Alexey Samsonove8c03222012-12-28 09:31:34 +0000180 PM.add(createMemorySanitizerPass(CGOpts.MemorySanitizerTrackOrigins,
181 CGOpts.SanitizerBlacklistFile));
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000182}
183
Kostya Serebryany3c931222012-03-01 22:27:08 +0000184static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
185 PassManagerBase &PM) {
Alexey Samsonove8c03222012-12-28 09:31:34 +0000186 const PassManagerBuilderWrapper &BuilderWrapper =
187 static_cast<const PassManagerBuilderWrapper&>(Builder);
188 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
189 PM.add(createThreadSanitizerPass(CGOpts.SanitizerBlacklistFile));
Kostya Serebryany3c931222012-03-01 22:27:08 +0000190}
191
Nadav Rotemfa60be02012-10-24 00:53:38 +0000192void EmitAssemblyHelper::CreatePasses(TargetMachine *TM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000193 unsigned OptLevel = CodeGenOpts.OptimizationLevel;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000194 CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000195
196 // Handle disabling of LLVM optimization, where we want to preserve the
197 // internal module before any optimization.
198 if (CodeGenOpts.DisableLLVMOpts) {
199 OptLevel = 0;
200 Inlining = CodeGenOpts.NoInlining;
201 }
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000202
Alexey Samsonov91ecfa62012-12-03 19:12:58 +0000203 PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
Chris Lattner9ca02e52011-05-21 23:50:44 +0000204 PMBuilder.OptLevel = OptLevel;
205 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
Andrew Trick6445d622011-04-05 18:49:32 +0000206
Chris Lattner9ca02e52011-05-21 23:50:44 +0000207 PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
208 PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
209 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000210
211 // In ObjC ARC mode, add the main ARC optimization passes.
212 if (LangOpts.ObjCAutoRefCount) {
213 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
214 addObjCARCExpandPass);
Dan Gohmana8398ea2012-01-17 20:54:51 +0000215 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
216 addObjCARCAPElimPass);
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000217 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
218 addObjCARCOptPass);
219 }
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000220
Will Dietz4f45bc02013-01-18 11:30:38 +0000221 if (LangOpts.Sanitize.Bounds) {
Nuno Lopesdef18492012-05-22 17:19:45 +0000222 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
223 addBoundsCheckingPass);
224 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
225 addBoundsCheckingPass);
226 }
227
Will Dietz4f45bc02013-01-18 11:30:38 +0000228 if (LangOpts.Sanitize.Address) {
Kostya Serebryanyba1f0402012-10-15 14:22:56 +0000229 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000230 addAddressSanitizerPasses);
Kostya Serebryanye5dd2ea2011-11-30 22:20:21 +0000231 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
Alexey Samsonov4d1a6e42012-11-29 22:36:21 +0000232 addAddressSanitizerPasses);
Kostya Serebryany1b4eca62011-11-16 17:34:26 +0000233 }
Kostya Serebryany3c931222012-03-01 22:27:08 +0000234
Will Dietz4f45bc02013-01-18 11:30:38 +0000235 if (LangOpts.Sanitize.Memory) {
Evgeniy Stepanov09ccf392012-12-03 13:20:43 +0000236 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
237 addMemorySanitizerPass);
238 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
239 addMemorySanitizerPass);
240 }
241
Will Dietz4f45bc02013-01-18 11:30:38 +0000242 if (LangOpts.Sanitize.Thread) {
Kostya Serebryanye78ec3e2012-03-23 23:25:23 +0000243 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
Kostya Serebryany3c931222012-03-01 22:27:08 +0000244 addThreadSanitizerPass);
245 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
246 addThreadSanitizerPass);
247 }
248
Chris Lattner33c09d52011-05-21 20:40:11 +0000249 // Figure out TargetLibraryInfo.
Bill Wendling3621b312011-05-17 23:06:23 +0000250 Triple TargetTriple(TheModule->getTargetTriple());
Chris Lattner9ca02e52011-05-21 23:50:44 +0000251 PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
Chris Lattner98ec3f72011-02-18 22:34:47 +0000252 if (!CodeGenOpts.SimplifyLibCalls)
Chris Lattner9ca02e52011-05-21 23:50:44 +0000253 PMBuilder.LibraryInfo->disableAllFunctions();
Chris Lattner33c09d52011-05-21 20:40:11 +0000254
Daniel Dunbar897c6762010-06-07 23:20:08 +0000255 switch (Inlining) {
256 case CodeGenOptions::NoInlining: break;
257 case CodeGenOptions::NormalInlining: {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000258 // FIXME: Derive these constants in a principled fashion.
259 unsigned Threshold = 225;
Chris Lattner33c09d52011-05-21 20:40:11 +0000260 if (CodeGenOpts.OptimizeSize == 1) // -Os
Daniel Dunbar897c6762010-06-07 23:20:08 +0000261 Threshold = 75;
Chris Lattner33c09d52011-05-21 20:40:11 +0000262 else if (CodeGenOpts.OptimizeSize == 2) // -Oz
Bob Wilsona0fa2032011-04-29 22:49:50 +0000263 Threshold = 25;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000264 else if (OptLevel > 2)
265 Threshold = 275;
Chris Lattner9ca02e52011-05-21 23:50:44 +0000266 PMBuilder.Inliner = createFunctionInliningPass(Threshold);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000267 break;
268 }
269 case CodeGenOptions::OnlyAlwaysInlining:
Chris Lattner33c09d52011-05-21 20:40:11 +0000270 // Respect always_inline.
Chad Rosier98759622012-02-25 02:56:13 +0000271 if (OptLevel == 0)
272 // Do not insert lifetime intrinsics at -O0.
273 PMBuilder.Inliner = createAlwaysInlinerPass(false);
274 else
275 PMBuilder.Inliner = createAlwaysInlinerPass();
Daniel Dunbar897c6762010-06-07 23:20:08 +0000276 break;
277 }
278
Chris Lattner33c09d52011-05-21 20:40:11 +0000279 // Set up the per-function pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000280 FunctionPassManager *FPM = getPerFunctionPasses(TM);
Chris Lattner33c09d52011-05-21 20:40:11 +0000281 if (CodeGenOpts.VerifyModule)
282 FPM->add(createVerifierPass());
283 PMBuilder.populateFunctionPassManager(*FPM);
Andrew Trick6445d622011-04-05 18:49:32 +0000284
Chris Lattner33c09d52011-05-21 20:40:11 +0000285 // Set up the per-module pass manager.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000286 PassManager *MPM = getPerModulePasses(TM);
Chris Lattnerdf619762011-02-18 22:20:38 +0000287
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000288 if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
289 MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
Bill Wendling3621b312011-05-17 23:06:23 +0000290 CodeGenOpts.EmitGcovArcs,
Bill Wendling44f4a2d2012-12-10 19:47:53 +0000291 TargetTriple.isMacOSX(),
292 false,
293 CodeGenOpts.DisableRedZone));
Bill Wendling3621b312011-05-17 23:06:23 +0000294
Douglas Gregor4cdad312012-10-23 20:05:01 +0000295 if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000296 MPM->add(createStripSymbolsPass(true));
297 }
Nadav Rotem129369d2012-10-24 03:52:31 +0000298
Chris Lattner33c09d52011-05-21 20:40:11 +0000299 PMBuilder.populateModulePassManager(*MPM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000300}
301
Nadav Rotem129369d2012-10-24 03:52:31 +0000302TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000303 // Create the TargetMachine for generating code.
304 std::string Error;
305 std::string Triple = TheModule->getTargetTriple();
306 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
307 if (!TheTarget) {
Nadav Rotem129369d2012-10-24 03:52:31 +0000308 if (MustCreateTM)
309 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
Nadav Rotemfa60be02012-10-24 00:53:38 +0000310 return 0;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000311 }
312
313 // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
314 // being gross, this is also totally broken if we ever care about
315 // concurrency.
Daniel Dunbar1ad66482010-07-01 01:31:45 +0000316
Daniel Dunbar897c6762010-06-07 23:20:08 +0000317 TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
318
319 TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
320 TargetMachine::setDataSections (CodeGenOpts.DataSections);
321
322 // FIXME: Parse this earlier.
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000323 llvm::CodeModel::Model CM;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000324 if (CodeGenOpts.CodeModel == "small") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000325 CM = llvm::CodeModel::Small;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000326 } else if (CodeGenOpts.CodeModel == "kernel") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000327 CM = llvm::CodeModel::Kernel;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000328 } else if (CodeGenOpts.CodeModel == "medium") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000329 CM = llvm::CodeModel::Medium;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000330 } else if (CodeGenOpts.CodeModel == "large") {
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000331 CM = llvm::CodeModel::Large;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000332 } else {
333 assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
Benjamin Kramer77577ce2011-07-20 14:43:06 +0000334 CM = llvm::CodeModel::Default;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000335 }
336
David Blaikie6bd17d22012-02-07 19:36:38 +0000337 SmallVector<const char *, 16> BackendArgs;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000338 BackendArgs.push_back("clang"); // Fake program name.
339 if (!CodeGenOpts.DebugPass.empty()) {
340 BackendArgs.push_back("-debug-pass");
341 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
342 }
343 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
344 BackendArgs.push_back("-limit-float-precision");
345 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
346 }
347 if (llvm::TimePassesIsEnabled)
348 BackendArgs.push_back("-time-passes");
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000349 for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
350 BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
Chad Rosier1b906052011-08-26 00:26:29 +0000351 if (CodeGenOpts.NoGlobalMerge)
352 BackendArgs.push_back("-global-merge=false");
Daniel Dunbar897c6762010-06-07 23:20:08 +0000353 BackendArgs.push_back(0);
354 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
David Blaikie6bd17d22012-02-07 19:36:38 +0000355 BackendArgs.data());
Daniel Dunbar897c6762010-06-07 23:20:08 +0000356
357 std::string FeaturesStr;
Evan Cheng368691e2011-06-30 02:06:32 +0000358 if (TargetOpts.Features.size()) {
Daniel Dunbar897c6762010-06-07 23:20:08 +0000359 SubtargetFeatures Features;
Daniel Dunbar897c6762010-06-07 23:20:08 +0000360 for (std::vector<std::string>::const_iterator
361 it = TargetOpts.Features.begin(),
362 ie = TargetOpts.Features.end(); it != ie; ++it)
363 Features.AddFeature(*it);
364 FeaturesStr = Features.getString();
365 }
Evan Cheng2860e302011-07-19 06:37:41 +0000366
367 llvm::Reloc::Model RM = llvm::Reloc::Default;
368 if (CodeGenOpts.RelocationModel == "static") {
369 RM = llvm::Reloc::Static;
370 } else if (CodeGenOpts.RelocationModel == "pic") {
371 RM = llvm::Reloc::PIC_;
372 } else {
373 assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
374 "Invalid PIC model!");
375 RM = llvm::Reloc::DynamicNoPIC;
376 }
377
Evan Cheng9254bf72011-11-16 08:38:55 +0000378 CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
379 switch (CodeGenOpts.OptimizationLevel) {
380 default: break;
381 case 0: OptLevel = CodeGenOpt::None; break;
382 case 3: OptLevel = CodeGenOpt::Aggressive; break;
383 }
384
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000385 llvm::TargetOptions Options;
386
387 // Set frame pointer elimination mode.
388 if (!CodeGenOpts.DisableFPElim) {
389 Options.NoFramePointerElim = false;
390 Options.NoFramePointerElimNonLeaf = false;
391 } else if (CodeGenOpts.OmitLeafFramePointer) {
392 Options.NoFramePointerElim = false;
393 Options.NoFramePointerElimNonLeaf = true;
394 } else {
395 Options.NoFramePointerElim = true;
396 Options.NoFramePointerElimNonLeaf = true;
397 }
398
Rafael Espindola8af669f2012-06-19 01:26:10 +0000399 if (CodeGenOpts.UseInitArray)
400 Options.UseInitArray = true;
401
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000402 // Set float ABI type.
403 if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
404 Options.FloatABIType = llvm::FloatABI::Soft;
405 else if (CodeGenOpts.FloatABI == "hard")
406 Options.FloatABIType = llvm::FloatABI::Hard;
407 else {
408 assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
409 Options.FloatABIType = llvm::FloatABI::Default;
410 }
411
Lang Hamesc9686712012-07-06 00:59:19 +0000412 // Set FP fusion mode.
Lang Hames931c0832012-11-15 07:51:26 +0000413 switch (CodeGenOpts.getFPContractMode()) {
414 case CodeGenOptions::FPC_Off:
Lang Hamesc9686712012-07-06 00:59:19 +0000415 Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
416 break;
Lang Hames931c0832012-11-15 07:51:26 +0000417 case CodeGenOptions::FPC_On:
Lang Hamesc9686712012-07-06 00:59:19 +0000418 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
419 break;
Lang Hames931c0832012-11-15 07:51:26 +0000420 case CodeGenOptions::FPC_Fast:
Lang Hamesc9686712012-07-06 00:59:19 +0000421 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
Nadav Rotem25030c42012-10-19 04:15:32 +0000422 break;
Lang Hamesc9686712012-07-06 00:59:19 +0000423 }
424
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000425 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
426 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
427 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
428 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
429 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
430 Options.UseSoftFloat = CodeGenOpts.SoftFloat;
Nick Lewycky4e785c92011-12-06 03:33:03 +0000431 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
432 Options.RealignStack = CodeGenOpts.StackRealignment;
Nick Lewycky1db772b2012-01-23 08:29:12 +0000433 Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
Bob Wilson71fd6cc2012-02-03 06:27:22 +0000434 Options.TrapFuncName = CodeGenOpts.TrapFuncName;
Chandler Carruth5081de52012-04-08 21:09:51 +0000435 Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
Chad Rosiera7afeb02012-08-21 16:16:06 +0000436 Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000437
Evan Cheng368691e2011-06-30 02:06:32 +0000438 TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000439 FeaturesStr, Options,
440 RM, CM, OptLevel);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000441
442 if (CodeGenOpts.RelaxAll)
443 TM->setMCRelaxAll(true);
Daniel Dunbar96932322011-03-28 22:49:28 +0000444 if (CodeGenOpts.SaveTempLabels)
445 TM->setMCSaveTempLabels(true);
Rafael Espindolaf24a1512011-04-30 18:35:43 +0000446 if (CodeGenOpts.NoDwarf2CFIAsm)
447 TM->setMCUseCFI(false);
Nick Lewyckyaaf2f362011-10-31 01:06:42 +0000448 if (!CodeGenOpts.NoDwarfDirectoryAsm)
449 TM->setMCUseDwarfDirectory(true);
Nick Lewyckyc3b90142011-06-21 00:14:18 +0000450 if (CodeGenOpts.NoExecStack)
451 TM->setMCNoExecStack(true);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000452
Nadav Rotemfa60be02012-10-24 00:53:38 +0000453 return TM;
454}
455
456bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
457 formatted_raw_ostream &OS,
458 TargetMachine *TM) {
459
Daniel Dunbar897c6762010-06-07 23:20:08 +0000460 // Create the code generator passes.
Nadav Rotemfa60be02012-10-24 00:53:38 +0000461 PassManager *PM = getCodeGenPasses(TM);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000462
Chad Rosier3f3335d2012-02-29 20:14:59 +0000463 // Add LibraryInfo.
Daniel Dunbarcbbe2c02012-10-19 20:10:10 +0000464 llvm::Triple TargetTriple(TheModule->getTargetTriple());
465 TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
Chad Rosier3f3335d2012-02-29 20:14:59 +0000466 if (!CodeGenOpts.SimplifyLibCalls)
467 TLI->disableAllFunctions();
468 PM->add(TLI);
469
Chandler Carruthd938e872013-01-07 01:38:01 +0000470 // Add Target specific analysis passes.
471 TM->addAnalysisPasses(*PM);
Nadav Rotem25030c42012-10-19 04:15:32 +0000472
Daniel Dunbar897c6762010-06-07 23:20:08 +0000473 // Normal mode, emit a .s or .o file by running the code generator. Note,
474 // this also adds codegenerator level optimization passes.
475 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
476 if (Action == Backend_EmitObj)
477 CGFT = TargetMachine::CGFT_ObjectFile;
478 else if (Action == Backend_EmitMCNull)
479 CGFT = TargetMachine::CGFT_Null;
480 else
481 assert(Action == Backend_EmitAssembly && "Invalid action!");
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000482
483 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
484 // "codegen" passes so that it isn't run multiple times when there is
485 // inlining happening.
Dan Gohman465a8992012-04-04 21:04:56 +0000486 if (LangOpts.ObjCAutoRefCount &&
487 CodeGenOpts.OptimizationLevel > 0)
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000488 PM->add(createObjCARCContractPass());
489
Evan Cheng9254bf72011-11-16 08:38:55 +0000490 if (TM->addPassesToEmitFile(*PM, OS, CGFT,
Daniel Dunbar897c6762010-06-07 23:20:08 +0000491 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
492 Diags.Report(diag::err_fe_unable_to_interface_with_target);
493 return false;
494 }
495
496 return true;
497}
498
499void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
500 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
501 llvm::formatted_raw_ostream FormattedOS;
502
Nadav Rotem129369d2012-10-24 03:52:31 +0000503 bool UsesCodeGen = (Action != Backend_EmitNothing &&
504 Action != Backend_EmitBC &&
505 Action != Backend_EmitLL);
506 TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000507 CreatePasses(TM);
508
Daniel Dunbar897c6762010-06-07 23:20:08 +0000509 switch (Action) {
510 case Backend_EmitNothing:
511 break;
512
513 case Backend_EmitBC:
Nadav Rotemfa60be02012-10-24 00:53:38 +0000514 getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000515 break;
516
517 case Backend_EmitLL:
518 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000519 getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
Daniel Dunbar897c6762010-06-07 23:20:08 +0000520 break;
521
522 default:
523 FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
Nadav Rotemfa60be02012-10-24 00:53:38 +0000524 if (!AddEmitPasses(Action, FormattedOS, TM))
Daniel Dunbar897c6762010-06-07 23:20:08 +0000525 return;
526 }
527
Andrew Trick92b5d942011-04-05 18:56:55 +0000528 // Before executing passes, print the final values of the LLVM options.
529 cl::PrintOptionValues();
530
Daniel Dunbar897c6762010-06-07 23:20:08 +0000531 // Run passes. For now we do all passes at once, but eventually we
532 // would like to have the option of streaming code generation.
533
534 if (PerFunctionPasses) {
535 PrettyStackTraceString CrashInfo("Per-function optimization");
536
537 PerFunctionPasses->doInitialization();
538 for (Module::iterator I = TheModule->begin(),
539 E = TheModule->end(); I != E; ++I)
540 if (!I->isDeclaration())
541 PerFunctionPasses->run(*I);
542 PerFunctionPasses->doFinalization();
543 }
544
545 if (PerModulePasses) {
546 PrettyStackTraceString CrashInfo("Per-module optimization passes");
547 PerModulePasses->run(*TheModule);
548 }
549
550 if (CodeGenPasses) {
551 PrettyStackTraceString CrashInfo("Code generation");
Daniel Dunbardb2f2372010-09-17 07:35:16 +0000552 CodeGenPasses->run(*TheModule);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000553 }
554}
555
David Blaikied6471f72011-09-25 23:23:43 +0000556void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
557 const CodeGenOptions &CGOpts,
Nick Lewycky3aaeccc2011-12-02 22:17:00 +0000558 const clang::TargetOptions &TOpts,
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000559 const LangOptions &LOpts,
560 Module *M,
Daniel Dunbar05a7f3d2010-06-07 23:21:04 +0000561 BackendAction Action, raw_ostream *OS) {
Dan Gohmanb18b8ad2011-07-05 22:02:36 +0000562 EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
Daniel Dunbar897c6762010-06-07 23:20:08 +0000563
564 AsmHelper.EmitAssembly(Action, OS);
565}