contrib/llvm/tools/clang/lib/CodeGen/BackendUtil.cpp

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