BackendUtil.cpp revision 3105627bd76d6a0cc5ee305c99f4c96519bac9ac 
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"
39using namespace clang;
40using namespace llvm;
41
42namespace {
43
44class 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
57private:
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
107public:
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.
128class PassManagerBuilderWrapper : public PassManagerBuilder {
129public:
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; }
135private:
136  const CodeGenOptions &CGOpts;
137  const LangOptions &LangOpts;
138};
139
140}
141
142static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
143  if (Builder.OptLevel > 0)
144    PM.add(createObjCARCAPElimPass());
145}
146
147static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
148  if (Builder.OptLevel > 0)
149    PM.add(createObjCARCExpandPass());
150}
151
152static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
153  if (Builder.OptLevel > 0)
154    PM.add(createObjCARCOptPass());
155}
156
157static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
158                                    PassManagerBase &PM) {
159  PM.add(createBoundsCheckingPass());
160}
161
162static 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
180static 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
201static 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
209void 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.DisableGCov &&
306      (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
307    // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
308    // LLVM's -default-gcov-version flag is set to something invalid.
309    GCOVOptions Options;
310    Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
311    Options.EmitData = CodeGenOpts.EmitGcovArcs;
312    memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
313    Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
314    Options.NoRedZone = CodeGenOpts.DisableRedZone;
315    Options.FunctionNamesInData =
316        !CodeGenOpts.CoverageNoFunctionNamesInData;
317    MPM->add(createGCOVProfilerPass(Options));
318    if (CodeGenOpts.getDebugInfo() == CodeGenOptions::NoDebugInfo)
319      MPM->add(createStripSymbolsPass(true));
320  }
321
322  PMBuilder.populateModulePassManager(*MPM);
323}
324
325TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
326  // Create the TargetMachine for generating code.
327  std::string Error;
328  std::string Triple = TheModule->getTargetTriple();
329  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
330  if (!TheTarget) {
331    if (MustCreateTM)
332      Diags.Report(diag::err_fe_unable_to_create_target) << Error;
333    return 0;
334  }
335
336  // FIXME: Expose these capabilities via actual APIs!!!! Aside from just
337  // being gross, this is also totally broken if we ever care about
338  // concurrency.
339
340  TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
341
342  TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
343  TargetMachine::setDataSections    (CodeGenOpts.DataSections);
344
345  // FIXME: Parse this earlier.
346  llvm::CodeModel::Model CM;
347  if (CodeGenOpts.CodeModel == "small") {
348    CM = llvm::CodeModel::Small;
349  } else if (CodeGenOpts.CodeModel == "kernel") {
350    CM = llvm::CodeModel::Kernel;
351  } else if (CodeGenOpts.CodeModel == "medium") {
352    CM = llvm::CodeModel::Medium;
353  } else if (CodeGenOpts.CodeModel == "large") {
354    CM = llvm::CodeModel::Large;
355  } else {
356    assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
357    CM = llvm::CodeModel::Default;
358  }
359
360  SmallVector<const char *, 16> BackendArgs;
361  BackendArgs.push_back("clang"); // Fake program name.
362  if (!CodeGenOpts.DebugPass.empty()) {
363    BackendArgs.push_back("-debug-pass");
364    BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
365  }
366  if (!CodeGenOpts.LimitFloatPrecision.empty()) {
367    BackendArgs.push_back("-limit-float-precision");
368    BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
369  }
370  if (llvm::TimePassesIsEnabled)
371    BackendArgs.push_back("-time-passes");
372  for (unsigned i = 0, e = CodeGenOpts.BackendOptions.size(); i != e; ++i)
373    BackendArgs.push_back(CodeGenOpts.BackendOptions[i].c_str());
374  if (CodeGenOpts.NoGlobalMerge)
375    BackendArgs.push_back("-global-merge=false");
376  BackendArgs.push_back(0);
377  llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
378                                    BackendArgs.data());
379
380  std::string FeaturesStr;
381  if (TargetOpts.Features.size()) {
382    SubtargetFeatures Features;
383    for (std::vector<std::string>::const_iterator
384           it = TargetOpts.Features.begin(),
385           ie = TargetOpts.Features.end(); it != ie; ++it)
386      Features.AddFeature(*it);
387    FeaturesStr = Features.getString();
388  }
389
390  llvm::Reloc::Model RM = llvm::Reloc::Default;
391  if (CodeGenOpts.RelocationModel == "static") {
392    RM = llvm::Reloc::Static;
393  } else if (CodeGenOpts.RelocationModel == "pic") {
394    RM = llvm::Reloc::PIC_;
395  } else {
396    assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
397           "Invalid PIC model!");
398    RM = llvm::Reloc::DynamicNoPIC;
399  }
400
401  CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
402  switch (CodeGenOpts.OptimizationLevel) {
403  default: break;
404  case 0: OptLevel = CodeGenOpt::None; break;
405  case 3: OptLevel = CodeGenOpt::Aggressive; break;
406  }
407
408  llvm::TargetOptions Options;
409
410  // Set frame pointer elimination mode.
411  if (!CodeGenOpts.DisableFPElim) {
412    Options.NoFramePointerElim = false;
413    Options.NoFramePointerElimNonLeaf = false;
414  } else if (CodeGenOpts.OmitLeafFramePointer) {
415    Options.NoFramePointerElim = false;
416    Options.NoFramePointerElimNonLeaf = true;
417  } else {
418    Options.NoFramePointerElim = true;
419    Options.NoFramePointerElimNonLeaf = true;
420  }
421
422  if (CodeGenOpts.UseInitArray)
423    Options.UseInitArray = true;
424
425  // Set float ABI type.
426  if (CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp")
427    Options.FloatABIType = llvm::FloatABI::Soft;
428  else if (CodeGenOpts.FloatABI == "hard")
429    Options.FloatABIType = llvm::FloatABI::Hard;
430  else {
431    assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
432    Options.FloatABIType = llvm::FloatABI::Default;
433  }
434
435  // Set FP fusion mode.
436  switch (CodeGenOpts.getFPContractMode()) {
437  case CodeGenOptions::FPC_Off:
438    Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
439    break;
440  case CodeGenOptions::FPC_On:
441    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
442    break;
443  case CodeGenOptions::FPC_Fast:
444    Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
445    break;
446  }
447
448  Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
449  Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
450  Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
451  Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
452  Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
453  Options.UseSoftFloat = CodeGenOpts.SoftFloat;
454  Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
455  Options.RealignStack = CodeGenOpts.StackRealignment;
456  Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
457  Options.TrapFuncName = CodeGenOpts.TrapFuncName;
458  Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
459  Options.SSPBufferSize = CodeGenOpts.SSPBufferSize;
460  Options.EnableSegmentedStacks = CodeGenOpts.EnableSegmentedStacks;
461
462  TargetMachine *TM = TheTarget->createTargetMachine(Triple, TargetOpts.CPU,
463                                                     FeaturesStr, Options,
464                                                     RM, CM, OptLevel);
465
466  if (CodeGenOpts.RelaxAll)
467    TM->setMCRelaxAll(true);
468  if (CodeGenOpts.SaveTempLabels)
469    TM->setMCSaveTempLabels(true);
470  if (CodeGenOpts.NoDwarf2CFIAsm)
471    TM->setMCUseCFI(false);
472  if (!CodeGenOpts.NoDwarfDirectoryAsm)
473    TM->setMCUseDwarfDirectory(true);
474  if (CodeGenOpts.NoExecStack)
475    TM->setMCNoExecStack(true);
476
477  return TM;
478}
479
480bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
481                                       formatted_raw_ostream &OS,
482                                       TargetMachine *TM) {
483
484  // Create the code generator passes.
485  PassManager *PM = getCodeGenPasses(TM);
486
487  // Add LibraryInfo.
488  llvm::Triple TargetTriple(TheModule->getTargetTriple());
489  TargetLibraryInfo *TLI = new TargetLibraryInfo(TargetTriple);
490  if (!CodeGenOpts.SimplifyLibCalls)
491    TLI->disableAllFunctions();
492  PM->add(TLI);
493
494  // Add Target specific analysis passes.
495  TM->addAnalysisPasses(*PM);
496
497  // Normal mode, emit a .s or .o file by running the code generator. Note,
498  // this also adds codegenerator level optimization passes.
499  TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
500  if (Action == Backend_EmitObj)
501    CGFT = TargetMachine::CGFT_ObjectFile;
502  else if (Action == Backend_EmitMCNull)
503    CGFT = TargetMachine::CGFT_Null;
504  else
505    assert(Action == Backend_EmitAssembly && "Invalid action!");
506
507  // Add ObjC ARC final-cleanup optimizations. This is done as part of the
508  // "codegen" passes so that it isn't run multiple times when there is
509  // inlining happening.
510  if (LangOpts.ObjCAutoRefCount &&
511      CodeGenOpts.OptimizationLevel > 0)
512    PM->add(createObjCARCContractPass());
513
514  if (TM->addPassesToEmitFile(*PM, OS, CGFT,
515                              /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
516    Diags.Report(diag::err_fe_unable_to_interface_with_target);
517    return false;
518  }
519
520  return true;
521}
522
523void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
524  TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
525  llvm::formatted_raw_ostream FormattedOS;
526
527  bool UsesCodeGen = (Action != Backend_EmitNothing &&
528                      Action != Backend_EmitBC &&
529                      Action != Backend_EmitLL);
530  TargetMachine *TM = CreateTargetMachine(UsesCodeGen);
531  if (UsesCodeGen && !TM) return;
532  CreatePasses(TM);
533
534  switch (Action) {
535  case Backend_EmitNothing:
536    break;
537
538  case Backend_EmitBC:
539    getPerModulePasses(TM)->add(createBitcodeWriterPass(*OS));
540    break;
541
542  case Backend_EmitLL:
543    FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
544    getPerModulePasses(TM)->add(createPrintModulePass(&FormattedOS));
545    break;
546
547  default:
548    FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
549    if (!AddEmitPasses(Action, FormattedOS, TM))
550      return;
551  }
552
553  // Before executing passes, print the final values of the LLVM options.
554  cl::PrintOptionValues();
555
556  // Run passes. For now we do all passes at once, but eventually we
557  // would like to have the option of streaming code generation.
558
559  if (PerFunctionPasses) {
560    PrettyStackTraceString CrashInfo("Per-function optimization");
561
562    PerFunctionPasses->doInitialization();
563    for (Module::iterator I = TheModule->begin(),
564           E = TheModule->end(); I != E; ++I)
565      if (!I->isDeclaration())
566        PerFunctionPasses->run(*I);
567    PerFunctionPasses->doFinalization();
568  }
569
570  if (PerModulePasses) {
571    PrettyStackTraceString CrashInfo("Per-module optimization passes");
572    PerModulePasses->run(*TheModule);
573  }
574
575  if (CodeGenPasses) {
576    PrettyStackTraceString CrashInfo("Code generation");
577    CodeGenPasses->run(*TheModule);
578  }
579}
580
581void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
582                              const CodeGenOptions &CGOpts,
583                              const clang::TargetOptions &TOpts,
584                              const LangOptions &LOpts,
585                              Module *M,
586                              BackendAction Action, raw_ostream *OS) {
587  EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, LOpts, M);
588
589  AsmHelper.EmitAssembly(Action, OS);
590}
591