1181111Sdes//===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===// 257429Smarkm// 357429Smarkm// The LLVM Compiler Infrastructure 457429Smarkm// 557429Smarkm// This file is distributed under the University of Illinois Open Source 657429Smarkm// License. See LICENSE.TXT for details. 757429Smarkm// 865674Skris//===----------------------------------------------------------------------===// 965674Skris 1065674Skris#include "clang/CodeGen/BackendUtil.h" 1165674Skris#include "clang/Basic/Diagnostic.h" 1265674Skris#include "clang/Basic/LangOptions.h" 1365674Skris#include "clang/Basic/TargetOptions.h" 1465674Skris#include "clang/Frontend/CodeGenOptions.h" 1565674Skris#include "clang/Frontend/FrontendDiagnostic.h" 1665674Skris#include "llvm/Analysis/Verifier.h" 1765674Skris#include "llvm/Assembly/PrintModulePass.h" 1865674Skris#include "llvm/Bitcode/ReaderWriter.h" 1965674Skris#include "llvm/CodeGen/RegAllocRegistry.h" 2065674Skris#include "llvm/CodeGen/SchedulerRegistry.h" 2165674Skris#include "llvm/IR/DataLayout.h" 2265674Skris#include "llvm/IR/Module.h" 2365674Skris#include "llvm/MC/SubtargetFeature.h" 2465674Skris#include "llvm/PassManager.h" 2565674Skris#include "llvm/Support/CommandLine.h" 2665674Skris#include "llvm/Support/FormattedStream.h" 2765674Skris#include "llvm/Support/PrettyStackTrace.h" 2865674Skris#include "llvm/Support/TargetRegistry.h" 2965674Skris#include "llvm/Support/Timer.h" 3065674Skris#include "llvm/Support/raw_ostream.h" 3165674Skris#include "llvm/Target/TargetLibraryInfo.h" 3265674Skris#include "llvm/Target/TargetMachine.h" 3365674Skris#include "llvm/Target/TargetOptions.h" 3465674Skris#include "llvm/Transforms/IPO.h" 3565674Skris#include "llvm/Transforms/IPO/PassManagerBuilder.h" 3665674Skris#include "llvm/Transforms/Instrumentation.h" 3757429Smarkm#include "llvm/Transforms/ObjCARC.h" 3857429Smarkm#include "llvm/Transforms/Scalar.h" 3957429Smarkmusing namespace clang; 4057429Smarkmusing namespace llvm; 41162856Sdes 42162856Sdesnamespace { 43162856Sdes 44162856Sdesclass EmitAssemblyHelper { 45162856Sdes DiagnosticsEngine &Diags; 46162856Sdes const CodeGenOptions &CodeGenOpts; 47162856Sdes const clang::TargetOptions &TargetOpts; 4857429Smarkm const LangOptions &LangOpts; 49147005Sdes Module *TheModule; 5076262Sgreen 5157429Smarkm Timer CodeGenerationTime; 52162856Sdes 53162856Sdes mutable PassManager *CodeGenPasses; 5476262Sgreen mutable PassManager *PerModulePasses; 55126277Sdes mutable FunctionPassManager *PerFunctionPasses; 5676262Sgreen 57147005Sdesprivate: 58124211Sdes PassManager *getCodeGenPasses(TargetMachine *TM) const { 59124211Sdes if (!CodeGenPasses) { 60147005Sdes CodeGenPasses = new PassManager(); 61147005Sdes CodeGenPasses->add(new DataLayout(TheModule)); 62147005Sdes if (TM) 63147005Sdes TM->addAnalysisPasses(*CodeGenPasses); 64147005Sdes } 65147005Sdes return CodeGenPasses; 66147005Sdes } 67147005Sdes 68126277Sdes PassManager *getPerModulePasses(TargetMachine *TM) const { 69126277Sdes if (!PerModulePasses) { 70126277Sdes PerModulePasses = new PassManager(); 71126277Sdes PerModulePasses->add(new DataLayout(TheModule)); 72126277Sdes if (TM) 73126277Sdes TM->addAnalysisPasses(*PerModulePasses); 74126277Sdes } 75126277Sdes return PerModulePasses; 7657429Smarkm } 7757429Smarkm 7857429Smarkm FunctionPassManager *getPerFunctionPasses(TargetMachine *TM) const { 7957429Smarkm if (!PerFunctionPasses) { 8065674Skris PerFunctionPasses = new FunctionPassManager(TheModule); 8176262Sgreen PerFunctionPasses->add(new DataLayout(TheModule)); 8257429Smarkm if (TM) 8376262Sgreen TM->addAnalysisPasses(*PerFunctionPasses); 84147005Sdes } 85137019Sdes return PerFunctionPasses; 86126277Sdes } 87137019Sdes 8857429Smarkm 8998941Sdes void CreatePasses(TargetMachine *TM); 90126277Sdes 91124211Sdes /// CreateTargetMachine - Generates the TargetMachine. 9298941Sdes /// Returns Null if it is unable to create the target machine. 9357429Smarkm /// Some of our clang tests specify triples which are not built 9457429Smarkm /// into clang. This is okay because these tests check the generated 95113911Sdes /// IR, and they require DataLayout which depends on the triple. 96126277Sdes /// In this case, we allow this method to fail and not report an error. 9773400Sassar /// When MustCreateTM is used, we print an error if we are unable to load 9892559Sdes /// the requested target. 9992559Sdes TargetMachine *CreateTargetMachine(bool MustCreateTM); 100124211Sdes 10157565Smarkm /// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR. 10257565Smarkm /// 103126277Sdes /// \return True on success. 104126277Sdes bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS, 105197679Sdes TargetMachine *TM); 10698941Sdes 10798941Sdespublic: 10898941Sdes EmitAssemblyHelper(DiagnosticsEngine &_Diags, 10998941Sdes const CodeGenOptions &CGOpts, 11098941Sdes const clang::TargetOptions &TOpts, 111124211Sdes const LangOptions &LOpts, 11298941Sdes Module *M) 113126277Sdes : Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts), LangOpts(LOpts), 114137019Sdes TheModule(M), CodeGenerationTime("Code Generation Time"), 115137019Sdes CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {} 116137019Sdes 117137019Sdes ~EmitAssemblyHelper() { 118126277Sdes delete CodeGenPasses; 119126277Sdes delete PerModulePasses; 120126277Sdes delete PerFunctionPasses; 121147005Sdes } 122126277Sdes 123126277Sdes void EmitAssembly(BackendAction Action, raw_ostream *OS); 124126277Sdes}; 125147005Sdes 126147005Sdes// We need this wrapper to access LangOpts and CGOpts from extension functions 127147005Sdes// that we add to the PassManagerBuilder. 128147005Sdesclass PassManagerBuilderWrapper : public PassManagerBuilder { 129126277Sdespublic: 130124211Sdes PassManagerBuilderWrapper(const CodeGenOptions &CGOpts, 131126277Sdes const LangOptions &LangOpts) 132147005Sdes : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {} 133147005Sdes const CodeGenOptions &getCGOpts() const { return CGOpts; } 134147005Sdes const LangOptions &getLangOpts() const { return LangOpts; } 135147005Sdesprivate: 136147005Sdes const CodeGenOptions &CGOpts; 137147005Sdes const LangOptions &LangOpts; 138147005Sdes}; 139147005Sdes 140147005Sdes} 141147005Sdes 142147005Sdesstatic void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 143147005Sdes if (Builder.OptLevel > 0) 144147005Sdes PM.add(createObjCARCAPElimPass()); 145147005Sdes} 146147005Sdes 147147005Sdesstatic void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 148147005Sdes if (Builder.OptLevel > 0) 149147005Sdes PM.add(createObjCARCExpandPass()); 150147005Sdes} 151147005Sdes 152147005Sdesstatic void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) { 153147005Sdes if (Builder.OptLevel > 0) 154147005Sdes PM.add(createObjCARCOptPass()); 155147005Sdes} 156147005Sdes 157147005Sdesstatic void addBoundsCheckingPass(const PassManagerBuilder &Builder, 158147005Sdes PassManagerBase &PM) { 159147005Sdes PM.add(createBoundsCheckingPass()); 160147005Sdes} 161147005Sdes 162147005Sdesstatic void addAddressSanitizerPasses(const PassManagerBuilder &Builder, 163147005Sdes PassManagerBase &PM) { 164147005Sdes const PassManagerBuilderWrapper &BuilderWrapper = 165147005Sdes static_cast<const PassManagerBuilderWrapper&>(Builder); 166126277Sdes const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts(); 167126277Sdes const LangOptions &LangOpts = BuilderWrapper.getLangOpts(); 168126277Sdes PM.add(createAddressSanitizerFunctionPass( 169126277Sdes LangOpts.Sanitize.InitOrder, 170126277Sdes LangOpts.Sanitize.UseAfterReturn, 171147005Sdes LangOpts.Sanitize.UseAfterScope, 172124211Sdes CGOpts.SanitizerBlacklistFile, 173126277Sdes CGOpts.SanitizeAddressZeroBaseShadow)); 174126277Sdes PM.add(createAddressSanitizerModulePass( 175149753Sdes LangOpts.Sanitize.InitOrder, 176149753Sdes CGOpts.SanitizerBlacklistFile, 177126277Sdes CGOpts.SanitizeAddressZeroBaseShadow)); 178126277Sdes} 179126277Sdes 180126277Sdesstatic void addMemorySanitizerPass(const PassManagerBuilder &Builder, 181126277Sdes PassManagerBase &PM) { 182126277Sdes const PassManagerBuilderWrapper &BuilderWrapper = 183147005Sdes static_cast<const PassManagerBuilderWrapper&>(Builder); 184147005Sdes const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts(); 185147005Sdes PM.add(createMemorySanitizerPass(CGOpts.SanitizeMemoryTrackOrigins, 186147005Sdes CGOpts.SanitizerBlacklistFile)); 187126277Sdes 18857429Smarkm // MemorySanitizer inserts complex instrumentation that mostly follows 189126277Sdes // the logic of the original code, but operates on "shadow" values. 190126277Sdes // It can benefit from re-running some general purpose optimization passes. 191126277Sdes if (Builder.OptLevel > 0) { 192126277Sdes PM.add(createEarlyCSEPass()); 193126277Sdes PM.add(createReassociatePass()); 194126277Sdes PM.add(createLICMPass()); 195126277Sdes PM.add(createGVNPass()); 196126277Sdes PM.add(createInstructionCombiningPass()); 197124211Sdes PM.add(createDeadStoreEliminationPass()); 198124211Sdes } 19998941Sdes} 20057429Smarkm 201124211Sdesstatic void addThreadSanitizerPass(const PassManagerBuilder &Builder, 202126277Sdes PassManagerBase &PM) { 20398941Sdes const PassManagerBuilderWrapper &BuilderWrapper = 204126277Sdes static_cast<const PassManagerBuilderWrapper&>(Builder); 205126277Sdes const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts(); 206126277Sdes PM.add(createThreadSanitizerPass(CGOpts.SanitizerBlacklistFile)); 20798941Sdes} 208126277Sdes 209126277Sdesvoid EmitAssemblyHelper::CreatePasses(TargetMachine *TM) { 210126277Sdes unsigned OptLevel = CodeGenOpts.OptimizationLevel; 211126277Sdes CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining(); 212240075Sdes 213240075Sdes // Handle disabling of LLVM optimization, where we want to preserve the 21457429Smarkm // internal module before any optimization. 215126277Sdes 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