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/LangOptions.h"
13 #include "clang/Basic/TargetOptions.h"
14 #include "clang/Frontend/CodeGenOptions.h"
15 #include "clang/Frontend/FrontendDiagnostic.h"
16 #include "llvm/Analysis/Verifier.h"
17 #include "llvm/Assembly/PrintModulePass.h"
18 #include "llvm/Bitcode/ReaderWriter.h"
19 #include "llvm/CodeGen/RegAllocRegistry.h"
20 #include "llvm/CodeGen/SchedulerRegistry.h"
21 #include "llvm/IR/DataLayout.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/MC/SubtargetFeature.h"
24 #include "llvm/PassManager.h"
25 #include "llvm/Support/CommandLine.h"
26 #include "llvm/Support/FormattedStream.h"
27 #include "llvm/Support/PrettyStackTrace.h"
28 #include "llvm/Support/TargetRegistry.h"
29 #include "llvm/Support/Timer.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Target/TargetLibraryInfo.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Transforms/IPO.h"
35 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
36 #include "llvm/Transforms/Instrumentation.h"
37 #include "llvm/Transforms/ObjCARC.h"
38 #include "llvm/Transforms/Scalar.h"
39 using namespace clang;
40 using namespace llvm;
41 
42 namespace {
43 
44 class EmitAssemblyHelper {
45   DiagnosticsEngine &Diags;
46   const CodeGenOptions &CodeGenOpts;
47   const clang::TargetOptions &TargetOpts;
48   const LangOptions &LangOpts;
49   Module *TheModule;
50 
51   Timer CodeGenerationTime;
52 
53   mutable PassManager *CodeGenPasses;
54   mutable PassManager *PerModulePasses;
55   mutable FunctionPassManager *PerFunctionPasses;
56 
57 private:
58   PassManager *getCodeGenPasses(TargetMachine *TM) const {
59     if (!CodeGenPasses) {
60       CodeGenPasses = new PassManager();
61       CodeGenPasses->add(new DataLayout(TheModule));
62       if (TM)
63         TM->addAnalysisPasses(*CodeGenPasses);
64     }
65     return CodeGenPasses;
66   }
67 
68   PassManager *getPerModulePasses(TargetMachine *TM) const {
69     if (!PerModulePasses) {
70       PerModulePasses = new PassManager();
71       PerModulePasses->add(new DataLayout(TheModule));
72       if (TM)
73         TM->addAnalysisPasses(*PerModulePasses);
74     }
75     return PerModulePasses;
76   }
77 
78   FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const {
79     if (!PerFunctionPasses) {
80       PerFunctionPasses = new FunctionPassManager(TheModule);
81       PerFunctionPasses->add(new DataLayout(TheModule));
82       if (TM)
83         TM->addAnalysisPasses(*PerFunctionPasses);
84     }
85     return PerFunctionPasses;
86   }
87 
88 
89   void CreatePasses(TargetMachine *TM);
90 
91   /// CreateTargetMachine - Generates the TargetMachine.
92   /// Returns Null if it is unable to create the target machine.
93   /// Some of our clang tests specify triples which are not built
94   /// into clang. This is okay because these tests check the generated
95   /// IR, and they require DataLayout which depends on the triple.
96   /// In this case, we allow this method to fail and not report an error.
97   /// When MustCreateTM is used, we print an error if we are unable to load
98   /// the requested target.
99   TargetMachine *CreateTargetMachine(bool MustCreateTM);
100 
101   /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
102   ///
103   /// \return True on success.
104   bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS,
105                      TargetMachine *TM);
106 
107 public:
108   EmitAssemblyHelper(DiagnosticsEngine &_Diags,
109                      const CodeGenOptions &CGOpts,
110                      const clang::TargetOptions &TOpts,
111                      const LangOptions &LOpts,
112                      Module *M)
113     : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts),
114       TheModule(M), CodeGenerationTime("Code Generation Time"),
115       CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
116 
117   ~EmitAssemblyHelper() {
118     delete CodeGenPasses;
119     delete PerModulePasses;
120     delete PerFunctionPasses;
121   }
122 
123   void EmitAssembly(BackendAction Action, raw_ostream *OS);
124 };
125 
126 // We need this wrapper to access LangOpts and CGOpts from extension functions
127 // that we add to the PassManagerBuilder.
128 class PassManagerBuilderWrapper : public PassManagerBuilder {
129 public:
130   PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
131                             const LangOptions &LangOpts)
132       : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
133   const CodeGenOptions &getCGOpts() const { return CGOpts; }
134   const LangOptions &getLangOpts() const { return LangOpts; }
135 private:
136   const CodeGenOptions &CGOpts;
137   const LangOptions &LangOpts;
138 };
139 
140 }
141 
142 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
143   if (Builder.OptLevel > 0)
144     PM.add(createObjCARCAPElimPass());
145 }
146 
147 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
148   if (Builder.OptLevel > 0)
149     PM.add(createObjCARCExpandPass());
150 }
151 
152 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
153   if (Builder.OptLevel > 0)
154     PM.add(createObjCARCOptPass());
155 }
156 
157 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
158                                     PassManagerBase &PM) {
159   PM.add(createBoundsCheckingPass());
160 }
161 
162 static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
163                                       PassManagerBase &PM) {
164   const PassManagerBuilderWrapper &BuilderWrapper =
165       static_cast<const PassManagerBuilderWrapper&>(Builder);
166   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
167   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
168   PM.add(createAddressSanitizerFunctionPass(
169       LangOpts.Sanitize.InitOrder,
170       LangOpts.Sanitize.UseAfterReturn,
171       LangOpts.Sanitize.UseAfterScope,
172       CGOpts.SanitizerBlacklistFile,
173       CGOpts.SanitizeAddressZeroBaseShadow));
174   PM.add(createAddressSanitizerModulePass(
175       LangOpts.Sanitize.InitOrder,
176       CGOpts.SanitizerBlacklistFile,
177       CGOpts.SanitizeAddressZeroBaseShadow));
178 }
179 
180 static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
181                                    PassManagerBase &PM) {
182   const PassManagerBuilderWrapper &BuilderWrapper =
183       static_cast<const PassManagerBuilderWrapper&>(Builder);
184   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
185   PM.add(createMemorySanitizerPass(CGOpts.SanitizeMemoryTrackOrigins,
186                                    CGOpts.SanitizerBlacklistFile));
187 
188   // MemorySanitizer inserts complex instrumentation that mostly follows
189   // the logic of the original code, but operates on "shadow" values.
190   // It can benefit from re-running some general purpose optimization passes.
191   if (Builder.OptLevel > 0) {
192     PM.add(createEarlyCSEPass());
193     PM.add(createReassociatePass());
194     PM.add(createLICMPass());
195     PM.add(createGVNPass());
196     PM.add(createInstructionCombiningPass());
197     PM.add(createDeadStoreEliminationPass());
198   }
199 }
200 
201 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
202                                    PassManagerBase &PM) {
203   const PassManagerBuilderWrapper &BuilderWrapper =
204       static_cast<const PassManagerBuilderWrapper&>(Builder);
205   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
206   PM.add(createThreadSanitizerPass(CGOpts.SanitizerBlacklistFile));
207 }
208 
209 void EmitAssemblyHelper::CreatePasses(TargetMachine *TM) {
210   unsigned OptLevel = CodeGenOpts.OptimizationLevel;
211   CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
212 
213   // Handle disabling of LLVM optimization, where we want to preserve the
214   // internal module before any optimization.
215   if (CodeGenOpts.DisableLLVMOpts) {
216     OptLevel = 0;
217     Inlining = CodeGenOpts.NoInlining;
218   }
219 
220   PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
221   PMBuilder.OptLevel = OptLevel;
222   PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
223 
224   PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
225   PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
226   PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
227 
228   // In ObjC ARC mode, add the main ARC optimization passes.
229   if (LangOpts.ObjCAutoRefCount) {
230     PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
231                            addObjCARCExpandPass);
232     PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
233                            addObjCARCAPElimPass);
234     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
235                            addObjCARCOptPass);
236   }
237 
238   if (LangOpts.Sanitize.Bounds) {
239     PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
240                            addBoundsCheckingPass);
241     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
242                            addBoundsCheckingPass);
243   }
244 
245   if (LangOpts.Sanitize.Address) {
246     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
247                            addAddressSanitizerPasses);
248     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
249                            addAddressSanitizerPasses);
250   }
251 
252   if (LangOpts.Sanitize.Memory) {
253     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
254                            addMemorySanitizerPass);
255     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
256                            addMemorySanitizerPass);
257   }
258 
259   if (LangOpts.Sanitize.Thread) {
260     PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
261                            addThreadSanitizerPass);
262     PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
263                            addThreadSanitizerPass);
264   }
265 
266   // Figure out TargetLibraryInfo.
267   Triple TargetTriple(TheModule->getTargetTriple());
268   PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
269   if (!CodeGenOpts.SimplifyLibCalls)
270     PMBuilder.LibraryInfo->disableAllFunctions();
271 
272   switch (Inlining) {
273   case CodeGenOptions::NoInlining: break;
274   case CodeGenOptions::NormalInlining: {
275     // FIXME: Derive these constants in a principled fashion.
276     unsigned Threshold = 225;
277     if (CodeGenOpts.OptimizeSize == 1)      // -Os
278       Threshold = 75;
279     else if (CodeGenOpts.OptimizeSize == 2) // -Oz
280       Threshold = 25;
281     else if (OptLevel > 2)
282       Threshold = 275;
283     PMBuilder.Inliner = createFunctionInliningPass(Threshold);
284     break;
285   }
286   case CodeGenOptions::OnlyAlwaysInlining:
287     // Respect always_inline.
288     if (OptLevel == 0)
289       // Do not insert lifetime intrinsics at -O0.
290       PMBuilder.Inliner = createAlwaysInlinerPass(false);
291     else
292       PMBuilder.Inliner = createAlwaysInlinerPass();
293     break;
294   }
295 
296   // Set up the per-function pass manager.
297   FunctionPassManager *FPM = getPerFunctionPasses(TM);
298   if (CodeGenOpts.VerifyModule)
299     FPM->add(createVerifierPass());
300   PMBuilder.populateFunctionPassManager(*FPM);
301 
302   // Set up the per-module pass manager.
303   PassManager *MPM = getPerModulePasses(TM);
304 
305   if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
306     MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
307                                     CodeGenOpts.EmitGcovArcs,
308                                     TargetTriple.isMacOSX(),
309                                     false,
310                                     CodeGenOpts.DisableRedZone));
311 
312     if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
313       MPM->add(createStripSymbolsPass(true));
314   }
315 
316   PMBuilder.populateModulePassManager(*MPM);
317 }
318 
319 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
320   // Create the TargetMachine for generating code.
321   std::string Error;
322   std::string Triple = TheModule->getTargetTriple();
323   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
324   if (!TheTarget) {
325     if (MustCreateTM)
326       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
327     return 0;
328   }
329 
330   // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
331   // being gross, this is also totally broken if we ever care about
332   // concurrency.
333 
334   TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
335 
336   TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
337   TargetMachine::setDataSections    (CodeGenOpts.DataSections);
338 
339   // FIXME: Parse this earlier.
340   llvm::CodeModel::Model CM;
341   if (CodeGenOpts.CodeModel == "small") {
342     CM = llvm::CodeModel::Small;
343   } else if (CodeGenOpts.CodeModel == "kernel") {
344     CM = llvm::CodeModel::Kernel;
345   } else if (CodeGenOpts.CodeModel == "medium") {
346     CM = llvm::CodeModel::Medium;
347   } else if (CodeGenOpts.CodeModel == "large") {
348     CM = llvm::CodeModel::Large;
349   } else {
350     assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
351     CM = llvm::CodeModel::Default;
352   }
353 
354   SmallVector<const char *, 16> BackendArgs;
355   BackendArgs.push_back("clang"); // Fake program name.
356   if (!CodeGenOpts.DebugPass.empty()) {
357     BackendArgs.push_back("-debug-pass");
358     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
359   }
360   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
361     BackendArgs.push_back("-limit-float-precision");
362     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
363   }
364   if (llvm::TimePassesIsEnabled)
365     BackendArgs.push_back("-time-passes");
366   for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
367     BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
368   if (CodeGenOpts.NoGlobalMerge)
369     BackendArgs.push_back("-global-merge=false");
370   BackendArgs.push_back(0);
371   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
372                                     BackendArgs.data());
373 
374   std::string FeaturesStr;
375   if (TargetOpts.Features.size()) {
376     SubtargetFeatures Features;
377     for (std::vector<std::string>::const_iterator
378            it = TargetOpts.Features.begin(),
379            ie = TargetOpts.Features.end(); it != ie; ++it)
380       Features.AddFeature(*it);
381     FeaturesStr = Features.getString();
382   }
383 
384   llvm::Reloc::Model RM = llvm::Reloc::Default;
385   if (CodeGenOpts.RelocationModel == "static") {
386     RM = llvm::Reloc::Static;
387   } else if (CodeGenOpts.RelocationModel == "pic") {
388     RM = llvm::Reloc::PIC_;
389   } else {
390     assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
391            "Invalid PIC model!");
392     RM = llvm::Reloc::DynamicNoPIC;
393   }
394 
395   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
396   switch (CodeGenOpts.OptimizationLevel) {
397   default: break;
398   case 0: OptLevel = CodeGenOpt::None; break;
399   case 3: OptLevel = CodeGenOpt::Aggressive; break;
400   }
401 
402   llvm::TargetOptions Options;
403 
404   // Set frame pointer elimination mode.
405   if (!CodeGenOpts.DisableFPElim) {
406     Options.NoFramePointerElim = false;
407     Options.NoFramePointerElimNonLeaf = false;
408   } else if (CodeGenOpts.OmitLeafFramePointer) {
409     Options.NoFramePointerElim = false;
410     Options.NoFramePointerElimNonLeaf = true;
411   } else {
412     Options.NoFramePointerElim = true;
413     Options.NoFramePointerElimNonLeaf = true;
414   }
415 
416   if (CodeGenOpts.UseInitArray)
417     Options.UseInitArray = true;
418 
419   // Set float ABI type.
420   if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
421     Options.FloatABIType = llvm::FloatABI::Soft;
422   else if (CodeGenOpts.FloatABI == "hard")
423     Options.FloatABIType = llvm::FloatABI::Hard;
424   else {
425     assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
426     Options.FloatABIType = llvm::FloatABI::Default;
427   }
428 
429   // Set FP fusion mode.
430   switch (CodeGenOpts.getFPContractMode()) {
431   case CodeGenOptions::FPC_Off:
432     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
433     break;
434   case CodeGenOptions::FPC_On:
435     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
436     break;
437   case CodeGenOptions::FPC_Fast:
438     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
439     break;
440   }
441 
442   Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
443   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
444   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
445   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
446   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
447   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
448   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
449   Options.RealignStack = CodeGenOpts.StackRealignment;
450   Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
451   Options.TrapFuncName = CodeGenOpts.TrapFuncName;
452   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
453   Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
454 
455   TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
456                                                      FeaturesStr, Options,
457                                                      RM, CM, OptLevel);
458 
459   if (CodeGenOpts.RelaxAll)
460     TM->setMCRelaxAll(true);
461   if (CodeGenOpts.SaveTempLabels)
462     TM->setMCSaveTempLabels(true);
463   if (CodeGenOpts.NoDwarf2CFIAsm)
464     TM->setMCUseCFI(false);
465   if (!CodeGenOpts.NoDwarfDirectoryAsm)
466     TM->setMCUseDwarfDirectory(true);
467   if (CodeGenOpts.NoExecStack)
468     TM->setMCNoExecStack(true);
469 
470   return TM;
471 }
472 
473 bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
474                                        formatted_raw_ostream &OS,
475                                        TargetMachine *TM) {
476 
477   // Create the code generator passes.
478   PassManager *PM = getCodeGenPasses(TM);
479 
480   // Add LibraryInfo.
481   llvm::Triple TargetTriple(TheModule->getTargetTriple());
482   TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
483   if (!CodeGenOpts.SimplifyLibCalls)
484     TLI->disableAllFunctions();
485   PM->add(TLI);
486 
487   // Add Target specific analysis passes.
488   TM->addAnalysisPasses(*PM);
489 
490   // Normal mode, emit a .s or .o file by running the code generator. Note,
491   // this also adds codegenerator level optimization passes.
492   TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
493   if (Action == Backend_EmitObj)
494     CGFT = TargetMachine::CGFT_ObjectFile;
495   else if (Action == Backend_EmitMCNull)
496     CGFT = TargetMachine::CGFT_Null;
497   else
498     assert(Action == Backend_EmitAssembly && "Invalid action!");
499 
500   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
501   // "codegen" passes so that it isn't run multiple times when there is
502   // inlining happening.
503   if (LangOpts.ObjCAutoRefCount &&
504       CodeGenOpts.OptimizationLevel > 0)
505     PM->add(createObjCARCContractPass());
506 
507   if (TM->addPassesToEmitFile(*PM, OS, CGFT,
508                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
509     Diags.Report(diag::err_fe_unable_to_interface_with_target);
510     return false;
511   }
512 
513   return true;
514 }
515 
516 void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
517   TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
518   llvm::formatted_raw_ostream FormattedOS;
519 
520   bool UsesCodeGen = (Action != Backend_EmitNothing &&
521                       Action != Backend_EmitBC &&
522                       Action != Backend_EmitLL);
523   TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
524   CreatePasses(TM);
525 
526   switch (Action) {
527   case Backend_EmitNothing:
528     break;
529 
530   case Backend_EmitBC:
531     getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
532     break;
533 
534   case Backend_EmitLL:
535     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
536     getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
537     break;
538 
539   default:
540     FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
541     if (!AddEmitPasses(Action, FormattedOS, TM))
542       return;
543   }
544 
545   // Before executing passes, print the final values of the LLVM options.
546   cl::PrintOptionValues();
547 
548   // Run passes. For now we do all passes at once, but eventually we
549   // would like to have the option of streaming code generation.
550 
551   if (PerFunctionPasses) {
552     PrettyStackTraceString CrashInfo("Per-function optimization");
553 
554     PerFunctionPasses->doInitialization();
555     for (Module::iterator I = TheModule->begin(),
556            E = TheModule->end(); I != E; ++I)
557       if (!I->isDeclaration())
558         PerFunctionPasses->run(*I);
559     PerFunctionPasses->doFinalization();
560   }
561 
562   if (PerModulePasses) {
563     PrettyStackTraceString CrashInfo("Per-module optimization passes");
564     PerModulePasses->run(*TheModule);
565   }
566 
567   if (CodeGenPasses) {
568     PrettyStackTraceString CrashInfo("Code generation");
569     CodeGenPasses->run(*TheModule);
570   }
571 }
572 
573 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
574                               const CodeGenOptions &CGOpts,
575                               const clang::TargetOptions &TOpts,
576                               const LangOptions &LOpts,
577                               Module *M,
578                               BackendAction Action, raw_ostream *OS) {
579   EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
580 
581   AsmHelper.EmitAssembly(Action, OS);
582 }
583