1aa4c91ff9669244b873cadd37e86fb7e19c5e82cChris Lattner//===-- Passes.cpp - Target independent code generation passes ------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 97237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos// 107237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos// This file defines interfaces to access the target independent code 117237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos// generation passes provided by the LLVM backend. 127237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos// 137237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos//===---------------------------------------------------------------------===// 147237ecef134cd88aad13190f078ff23057bfcb71Alkis Evlogimenos 15d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Passes.h" 16d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/Analysis/Passes.h" 17d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/CodeGen/MachineFunctionPass.h" 18d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/CodeGen/RegAllocRegistry.h" 1936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/IRPrintingPasses.h" 20ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines#include "llvm/IR/LegacyPassManager.h" 2136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/Verifier.h" 22564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson#include "llvm/MC/MCAsmInfo.h" 23d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/Support/CommandLine.h" 24d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/Support/Debug.h" 257461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick#include "llvm/Support/ErrorHandling.h" 264c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar#include "llvm/Support/raw_ostream.h" 27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Transforms/Scalar.h" 2837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines#include "llvm/Transforms/Utils/SymbolRewriter.h" 2913ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 30aa4c91ff9669244b873cadd37e86fb7e19c5e82cChris Lattnerusing namespace llvm; 31d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 32d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisablePostRA("disable-post-ra", cl::Hidden, 33d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Post Regalloc")); 34d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableBranchFold("disable-branch-fold", cl::Hidden, 35d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable branch folding")); 36d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableTailDuplicate("disable-tail-duplicate", cl::Hidden, 37d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable tail duplication")); 38d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableEarlyTailDup("disable-early-taildup", cl::Hidden, 39d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable pre-register allocation tail duplication")); 409e67db4af13abb967cae5858502207a43d26bf84Chandler Carruthstatic cl::opt<bool> DisableBlockPlacement("disable-block-placement", 4174a4533a4290b7c6f1fe04a30ca13ec25c529e0aBenjamin Kramer cl::Hidden, cl::desc("Disable probability-driven block placement")); 42d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> EnableBlockPlacementStats("enable-block-placement-stats", 43d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::Hidden, cl::desc("Collect probability-driven block placement stats")); 44d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableSSC("disable-ssc", cl::Hidden, 45d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Stack Slot Coloring")); 46d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineDCE("disable-machine-dce", cl::Hidden, 47d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Dead Code Elimination")); 480d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesenstatic cl::opt<bool> DisableEarlyIfConversion("disable-early-ifcvt", cl::Hidden, 490d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesen cl::desc("Disable Early If-conversion")); 50d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineLICM("disable-machine-licm", cl::Hidden, 51d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine LICM")); 52d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineCSE("disable-machine-cse", cl::Hidden, 53d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Common Subexpression Elimination")); 548dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickstatic cl::opt<cl::boolOrDefault> 558dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickOptimizeRegAlloc("optimize-regalloc", cl::Hidden, 568dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick cl::desc("Enable optimized register allocation compilation path.")); 57d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm", 58d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::Hidden, 59d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine LICM")); 60d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineSink("disable-machine-sink", cl::Hidden, 61d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Sinking")); 62d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableLSR("disable-lsr", cl::Hidden, 63d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Loop Strength Reduction Pass")); 6436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic cl::opt<bool> DisableConstantHoisting("disable-constant-hoisting", 6536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines cl::Hidden, cl::desc("Disable ConstantHoisting")); 66d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableCGP("disable-cgp", cl::Hidden, 67d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Codegen Prepare")); 68d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableCopyProp("disable-copyprop", cl::Hidden, 6901b623c8c2d1bd015a8bb20eafee3322575eff8fEvan Cheng cl::desc("Disable Copy Propagation pass")); 7037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesstatic cl::opt<bool> DisablePartialLibcallInlining("disable-partial-libcall-inlining", 7137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines cl::Hidden, cl::desc("Disable Partial Libcall Inlining")); 72d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintLSR("print-lsr-output", cl::Hidden, 73d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Print LLVM IR produced by the loop-reduce pass")); 74d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintISelInput("print-isel-input", cl::Hidden, 75d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Print LLVM IR input to isel pass")); 76d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintGCInfo("print-gc", cl::Hidden, 77d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Dump garbage collector data")); 78d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> VerifyMachineCode("verify-machineinstrs", cl::Hidden, 79d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Verify generated machine code"), 80ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cl::init(false), 81ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cl::ZeroOrMore); 82ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 836e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilsonstatic cl::opt<std::string> 846e1b8128505711276a87e96f6bffb818b435cbd5Bob WilsonPrintMachineInstrs("print-machineinstrs", cl::ValueOptional, 856e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson cl::desc("Print machine instrs"), 866e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson cl::value_desc("pass-name"), cl::init("option-unspecified")); 87d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 8836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// Temporary option to allow experimenting with MachineScheduler as a post-RA 8936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// scheduler. Targets can "properly" enable this with 90c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines// substitutePass(&PostRASchedulerID, &PostMachineSchedulerID); Ideally it 91c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines// wouldn't be part of the standard pass pipeline, and the target would just add 92c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines// a PostRA scheduling pass wherever it wants. 9336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic cl::opt<bool> MISchedPostRA("misched-postra", cl::Hidden, 9436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines cl::desc("Run MachineScheduler post regalloc (independent of preRA sched)")); 9536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 96d7c7a686ac18f8f3c035d158d8b713077be83ea4Cameron Zwarich// Experimental option to run live interval analysis early. 97dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesenstatic cl::opt<bool> EarlyLiveIntervals("early-live-intervals", cl::Hidden, 98dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen cl::desc("Run live interval analysis earlier in the pipeline")); 99dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 10037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesstatic cl::opt<bool> UseCFLAA("use-cfl-aa-in-codegen", 10137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines cl::init(false), cl::Hidden, 10237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines cl::desc("Enable the new, experimental CFL alias analysis in CodeGen")); 10337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 10479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// Allow standard passes to be disabled by command line options. This supports 10579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// simple binary flags that either suppress the pass or do nothing. 10679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// i.e. -disable-mypass=false has no effect. 10779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// These should be converted to boolOrDefault in order to use applyOverride. 1085ed028385c39f3de4570fa6f77c734d968d26902Andrew Trickstatic IdentifyingPassPtr applyDisable(IdentifyingPassPtr PassID, 1095ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick bool Override) { 11079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (Override) 1115ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick return IdentifyingPassPtr(); 1123fb99a73686c39d9855b3f8881add977af3868cbBob Wilson return PassID; 11379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick} 11479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 11579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// Allow standard passes to be disabled by the command line, regardless of who 11679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// is adding the pass. 11779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 11879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// StandardID is the pass identified in the standard pass pipeline and provided 11979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// to addPass(). It may be a target-specific ID in the case that the target 12079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// directly adds its own pass, but in that case we harmlessly fall through. 12179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 12279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// TargetID is the pass that the target has configured to override StandardID. 12379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 12479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// StandardID may be a pseudo ID. In that case TargetID is the name of the real 12579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// pass to run. This allows multiple options to control a single pass depending 12679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// on where in the pipeline that pass is added. 1275ed028385c39f3de4570fa6f77c734d968d26902Andrew Trickstatic IdentifyingPassPtr overridePass(AnalysisID StandardID, 1285ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID) { 12979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &PostRASchedulerID) 13079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisablePostRA); 13179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 13279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &BranchFolderPassID) 13379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableBranchFold); 13479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 13579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TailDuplicateID) 13679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableTailDuplicate); 13779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 13879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TargetPassConfig::EarlyTailDuplicateID) 13979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableEarlyTailDup); 14079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 14179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineBlockPlacementID) 14274a4533a4290b7c6f1fe04a30ca13ec25c529e0aBenjamin Kramer return applyDisable(TargetID, DisableBlockPlacement); 14379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 14479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &StackSlotColoringID) 14579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableSSC); 14679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 14779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &DeadMachineInstructionElimID) 14879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineDCE); 14979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 15033242fd3ed5586091e73254b58dd1825e9d53c60Jakob Stoklund Olesen if (StandardID == &EarlyIfConverterID) 1510d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesen return applyDisable(TargetID, DisableEarlyIfConversion); 15233242fd3ed5586091e73254b58dd1825e9d53c60Jakob Stoklund Olesen 15379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineLICMID) 15479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineLICM); 15579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 15679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineCSEID) 15779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineCSE); 15879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 15979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TargetPassConfig::PostRAMachineLICMID) 16079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisablePostRAMachineLICM); 16179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineSinkingID) 16379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineSink); 16479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineCopyPropagationID) 16679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableCopyProp); 16779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return TargetID; 16979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick} 17079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 171eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 1727461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// TargetPassConfig 1737461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick//===---------------------------------------------------------------------===// 1747461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 1757461334084aa77286b6f9af596fb0f6ba0465685Andrew TrickINITIALIZE_PASS(TargetPassConfig, "targetpassconfig", 1767461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick "Target Pass Configuration", false, false) 1777461334084aa77286b6f9af596fb0f6ba0465685Andrew Trickchar TargetPassConfig::ID = 0; 1787461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 17979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick// Pseudo Pass IDs. 18079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trickchar TargetPassConfig::EarlyTailDuplicateID = 0; 18179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trickchar TargetPassConfig::PostRAMachineLICMID = 0; 18279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 1835e108eeeef34dd2afa00d1da77bca47188de4244Andrew Tricknamespace llvm { 1845e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trickclass PassConfigImpl { 1855e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trickpublic: 1865e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // List of passes explicitly substituted by this target. Normally this is 1875e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // empty, but it is a convenient way to suppress or replace specific passes 1885e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // that are part of a standard pass pipeline without overridding the entire 1895e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // pipeline. This mechanism allows target options to inherit a standard pass's 1905e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // user interface. For example, a target may disable a standard pass by 1913fb99a73686c39d9855b3f8881add977af3868cbBob Wilson // default by substituting a pass ID of zero, and the user may still enable 1923fb99a73686c39d9855b3f8881add977af3868cbBob Wilson // that standard pass with an explicit command line option. 1935ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick DenseMap<AnalysisID,IdentifyingPassPtr> TargetPasses; 1946e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 1956e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson /// Store the pairs of <AnalysisID, AnalysisID> of which the second pass 1966e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson /// is inserted after each instance of the first one. 1975ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick SmallVector<std::pair<AnalysisID, IdentifyingPassPtr>, 4> InsertedPasses; 1985e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick}; 1995e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} // namespace llvm 2005e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 2017461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick// Out of line virtual method. 2025e108eeeef34dd2afa00d1da77bca47188de4244Andrew TrickTargetPassConfig::~TargetPassConfig() { 2035e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick delete Impl; 2045e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 2057461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 20661f1e3db43e556f495b6b9360d2f550291f78471Andrew Trick// Out of line constructor provides default values for pass options and 20761f1e3db43e556f495b6b9360d2f550291f78471Andrew Trick// registers all common codegen passes. 208061efcfb3e79899493d857f49e50d09f29037e0aAndrew TrickTargetPassConfig::TargetPassConfig(TargetMachine *tm, PassManagerBase &pm) 209dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : ImmutablePass(ID), PM(&pm), StartAfter(nullptr), StopAfter(nullptr), 210ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Started(true), Stopped(false), AddingMachinePasses(false), TM(tm), 211ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Impl(nullptr), Initialized(false), DisableVerify(false), 212ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick EnableTailMerge(true) { 213ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick 2145e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick Impl = new PassConfigImpl(); 2155e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 2167461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick // Register all target independent codegen passes to activate their PassIDs, 2177461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick // including this pass itself. 2187461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick initializeCodeGen(*PassRegistry::getPassRegistry()); 21979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 22079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick // Substitute Pseudo Pass IDs for real ones. 2213fb99a73686c39d9855b3f8881add977af3868cbBob Wilson substitutePass(&EarlyTailDuplicateID, &TailDuplicateID); 2223fb99a73686c39d9855b3f8881add977af3868cbBob Wilson substitutePass(&PostRAMachineLICMID, &MachineLICMID); 2237461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2247461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 2256e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson/// Insert InsertedPassID pass after TargetPassID. 2263fb99a73686c39d9855b3f8881add977af3868cbBob Wilsonvoid TargetPassConfig::insertPass(AnalysisID TargetPassID, 2275ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr InsertedPassID) { 228fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer assert(((!InsertedPassID.isInstance() && 229fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer TargetPassID != InsertedPassID.getID()) || 230fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer (InsertedPassID.isInstance() && 231fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer TargetPassID != InsertedPassID.getInstance()->getPassID())) && 2325ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick "Insert a pass after itself!"); 2335ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick std::pair<AnalysisID, IdentifyingPassPtr> P(TargetPassID, InsertedPassID); 2346e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson Impl->InsertedPasses.push_back(P); 2356e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson} 2366e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 2377461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// createPassConfig - Create a pass configuration object to be used by 2387461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// addPassToEmitX methods for generating a pipeline of CodeGen passes. 2397461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// 2407461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// Targets may override this to extend TargetPassConfig. 241061efcfb3e79899493d857f49e50d09f29037e0aAndrew TrickTargetPassConfig *LLVMTargetMachine::createPassConfig(PassManagerBase &PM) { 242061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick return new TargetPassConfig(this, PM); 2437461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2447461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 2457461334084aa77286b6f9af596fb0f6ba0465685Andrew TrickTargetPassConfig::TargetPassConfig() 246dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : ImmutablePass(ID), PM(nullptr) { 2477461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick llvm_unreachable("TargetPassConfig should not be constructed on-the-fly"); 2487461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2497461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 250ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick// Helper to verify the analysis is really immutable. 251ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trickvoid TargetPassConfig::setOpt(bool &Opt, bool Val) { 252ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick assert(!Initialized && "PassConfig is immutable"); 253ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick Opt = Val; 254ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick} 255ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick 2563fb99a73686c39d9855b3f8881add977af3868cbBob Wilsonvoid TargetPassConfig::substitutePass(AnalysisID StandardID, 2575ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID) { 2583fb99a73686c39d9855b3f8881add977af3868cbBob Wilson Impl->TargetPasses[StandardID] = TargetID; 2595e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 260746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick 2615ed028385c39f3de4570fa6f77c734d968d26902Andrew TrickIdentifyingPassPtr TargetPassConfig::getPassSubstitution(AnalysisID ID) const { 2625ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick DenseMap<AnalysisID, IdentifyingPassPtr>::const_iterator 2635e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick I = Impl->TargetPasses.find(ID); 2645e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick if (I == Impl->TargetPasses.end()) 2655e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return ID; 2665e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return I->second; 2675e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 2685e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 26930a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// Add a pass to the PassManager if that pass is supposed to be run. If the 27030a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// Started/Stopped flags indicate either that the compilation should start at 27130a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// a later pass or that it should stop after an earlier pass, then do not add 27230a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// the pass. Finally, compare the current pass against the StartAfter 27330a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// and StopAfter options and change the Started/Stopped flags accordingly. 274ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesvoid TargetPassConfig::addPass(Pass *P, bool verifyAfter, bool printAfter) { 2756b2bb15bf7c77918adc433646846f6847d421257Bob Wilson assert(!Initialized && "PassConfig is immutable"); 2766b2bb15bf7c77918adc433646846f6847d421257Bob Wilson 2776068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // Cache the Pass ID here in case the pass manager finds this pass is 2786068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // redundant with ones already scheduled / available, and deletes it. 2796068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // Fundamentally, once we add the pass to the manager, we no longer own it 2806068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // and shouldn't reference it. 2816068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth AnalysisID PassID = P->getPassID(); 2826068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth 283ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Started && !Stopped) { 284ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines std::string Banner; 285ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Construct banner message before PM->add() as that may delete the pass. 286ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (AddingMachinePasses && (printAfter || verifyAfter)) 287ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Banner = std::string("After ") + std::string(P->getPassName()); 28830a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson PM->add(P); 289ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (AddingMachinePasses) { 290ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (printAfter) 291ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPrintPass(Banner); 292ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (verifyAfter) 293ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addVerifyPass(Banner); 294ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 295ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } else { 296f8e16c6f5a3a0d2cc6f7ae6dae0a8f55a89cfb2fBenjamin Kramer delete P; 297ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 2986068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth if (StopAfter == PassID) 29930a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson Stopped = true; 3006068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth if (StartAfter == PassID) 30130a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson Started = true; 30230a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson if (Stopped && !Started) 30330a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson report_fatal_error("Cannot stop compilation after pass that is not run"); 304564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson} 305564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 3065e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick/// Add a CodeGen pass at this point in the pipeline after checking for target 3075e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick/// and command line overrides. 3085ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// 3095ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// addPass cannot return a pointer to the pass instance because is internal the 3105ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// PassManager and the instance we create here may already be freed. 311ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesAnalysisID TargetPassConfig::addPass(AnalysisID PassID, bool verifyAfter, 312ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool printAfter) { 3135ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID = getPassSubstitution(PassID); 3145ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr FinalPtr = overridePass(PassID, TargetID); 3155ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (!FinalPtr.isValid()) 316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3175ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick 3185ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick Pass *P; 3195ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (FinalPtr.isInstance()) 3205ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick P = FinalPtr.getInstance(); 3215ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick else { 3225ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick P = Pass::createPass(FinalPtr.getID()); 3235ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (!P) 3245ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick llvm_unreachable("Pass ID not registered"); 3255ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick } 3265ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick AnalysisID FinalID = P->getPassID(); 327ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(P, verifyAfter, printAfter); // Ends the lifetime of P. 3285ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick 3296e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // Add the passes after the pass P if there is any. 330f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper for (SmallVectorImpl<std::pair<AnalysisID, IdentifyingPassPtr> >::iterator 3316e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson I = Impl->InsertedPasses.begin(), E = Impl->InsertedPasses.end(); 3326e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson I != E; ++I) { 3333fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if ((*I).first == PassID) { 3345ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick assert((*I).second.isValid() && "Illegal Pass ID!"); 3355ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick Pass *NP; 3365ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if ((*I).second.isInstance()) 3375ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick NP = (*I).second.getInstance(); 3385ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick else { 3395ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick NP = Pass::createPass((*I).second.getID()); 3405ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick assert(NP && "Pass ID not registered"); 3415ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick } 342ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(NP, false, false); 3436e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 3446e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 3455e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return FinalID; 346061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 347d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 348ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesvoid TargetPassConfig::printAndVerify(const std::string &Banner) { 349ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPrintPass(Banner); 350ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addVerifyPass(Banner); 351ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 352ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 353ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesvoid TargetPassConfig::addPrintPass(const std::string &Banner) { 354d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (TM->shouldPrintMachineCode()) 355ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PM->add(createMachineFunctionPrinterPass(dbgs(), Banner)); 356ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 357d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 358ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesvoid TargetPassConfig::addVerifyPass(const std::string &Banner) { 359d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (VerifyMachineCode) 360ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PM->add(createMachineVerifierPass(Banner)); 361d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick} 362d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 363061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick/// Add common target configurable passes that perform LLVM IR to IR transforms 364061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick/// following machine independent optimization. 365061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trickvoid TargetPassConfig::addIRPasses() { 366d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Basic AliasAnalysis support. 367d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that 368d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // BasicAliasAnalysis wins if they disagree. This is intended to help 369d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // support "obvious" type-punning idioms. 37037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (UseCFLAA) 37137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines addPass(createCFLAliasAnalysisPass()); 372564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createTypeBasedAliasAnalysisPass()); 37337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines addPass(createScopedNoAliasAAPass()); 374564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createBasicAliasAnalysisPass()); 375d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 376d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Before running any passes, run the verifier to determine if the input 377d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // coming from the front-end and/or optimizer is valid. 3784c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (!DisableVerify) 379564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createVerifierPass()); 380d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 381d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run loop strength reduction before anything else. 382d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None && !DisableLSR) { 383e4ba75f43e2ab1480d119d2d4eb878256274e0fbChandler Carruth addPass(createLoopStrengthReducePass()); 384d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (PrintLSR) 38536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createPrintFunctionPass(dbgs(), "\n\n*** Code after LSR ***\n")); 386d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 387d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 388ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Run GC lowering passes for builtin collectors 389ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // TODO: add a pass insertion point here 390564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createGCLoweringPass()); 391ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(createShadowStackGCLoweringPass()); 392d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 393d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Make sure that no unreachable blocks are instruction selected. 394564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createUnreachableBlockEliminationPass()); 39536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 39636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Prepare expensive constants for SelectionDAG. 39736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (getOptLevel() != CodeGenOpt::None && !DisableConstantHoisting) 39836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createConstantHoistingPass()); 39937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 40037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (getOptLevel() != CodeGenOpt::None && !DisablePartialLibcallInlining) 40137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines addPass(createPartiallyInlineLibCallsPass()); 402564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson} 403564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 404564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson/// Turn exception handling constructs into something the code generators can 405564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson/// handle. 406564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilsonvoid TargetPassConfig::addPassesToHandleExceptions() { 407564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson switch (TM->getMCAsmInfo()->getExceptionHandlingType()) { 408564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::SjLj: 409564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both 410564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // Dwarf EH prepare needs to be run after SjLj prepare. Otherwise, 411564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // catch info can get misplaced when a selector ends up more than one block 412564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // removed from the parent invoke(s). This could happen when a landing 413564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // pad is shared by multiple invokes and is also a target of a normal 414564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // edge from elsewhere. 415ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling addPass(createSjLjEHPreparePass(TM)); 416564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // FALLTHROUGH 417564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::DwarfCFI: 418564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::ARM: 419ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling addPass(createDwarfEHPass(TM)); 420564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson break; 421ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case ExceptionHandling::WinEH: 4224c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // We support using both GCC-style and MSVC-style exceptions on Windows, so 4234c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // add both preparation passes. Each pass will only actually run if it 4244c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // recognizes the personality function. 425ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(createWinEHPass(TM)); 4264c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar addPass(createDwarfEHPass(TM)); 427ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 428564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::None: 42936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createLowerInvokePass()); 430564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 431564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // The lower invoke pass may create unreachable code. Remove it. 432564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createUnreachableBlockEliminationPass()); 433564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson break; 434564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson } 435061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 436d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 43708510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// Add pass to prepare the LLVM IR for code generation. This should be done 43808510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// before exception handling preparation passes. 43908510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendlingvoid TargetPassConfig::addCodeGenPrepare() { 440d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None && !DisableCGP) 441f9fd58a44bbc7d9371ce39eb20eec16b0f1f7395Bill Wendling addPass(createCodeGenPreparePass(TM)); 44237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines addPass(createRewriteSymbolsPass()); 44308510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling} 444d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 44508510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// Add common passes that perform LLVM IR to IR transforms in preparation for 44608510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// instruction selection. 44708510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendlingvoid TargetPassConfig::addISelPrepare() { 448d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick addPreISel(); 449d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 45036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createStackProtectorPass(TM)); 45136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 452d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (PrintISelInput) 45336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createPrintFunctionPass( 45436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines dbgs(), "\n\n*** Final LLVM Code input to ISel ***\n")); 455d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 456d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // All passes which modify the LLVM IR are now complete; run the verifier 457d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // to ensure that the IR is valid. 458d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (!DisableVerify) 459564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createVerifierPass()); 460061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 461d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 462f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add the complete set of target-independent postISel code generator passes. 463f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 464f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// This can be read as the standard order of major LLVM CodeGen stages. Stages 465f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// with nontrivial configuration or multiple passes are broken out below in 466f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// add%Stage routines. 467f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 468f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Any TargetPassConfig::addXX routine may be overriden by the Target. The 469f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// addPre/Post methods with empty header implementations allow injecting 470f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// target-specific fixups just before or after major stages. Additionally, 471f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// targets have the flexibility to change pass order within a stage by 472f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// overriding default implementation of add%Stage routines below. Each 473f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// technique has maintainability tradeoffs because alternate pass orders are 474f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// not well supported. addPre/Post works better if the target pass is easily 475f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// tied to a common pass. But if it has subtle dependencies on multiple passes, 47606efdd238ed7d14eaabc3b074c3b0b292c1c3127Andrew Trick/// the target should override the stage instead. 477f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 478f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// TODO: We could use a single addPre/Post(ID) hook to allow pass injection 479f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// before/after any target-independent pass. But it's currently overkill. 480061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trickvoid TargetPassConfig::addMachinePasses() { 481ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AddingMachinePasses = true; 482ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 4836e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // Insert a machine instr printer pass after the specified pass. 4846e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // If -print-machineinstrs specified, print machineinstrs after all passes. 4856e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson if (StringRef(PrintMachineInstrs.getValue()).equals("")) 4866e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson TM->Options.PrintMachineCode = true; 4876e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson else if (!StringRef(PrintMachineInstrs.getValue()) 4886e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson .equals("option-unspecified")) { 4896e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson const PassRegistry *PR = PassRegistry::getPassRegistry(); 4906e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson const PassInfo *TPI = PR->getPassInfo(PrintMachineInstrs.getValue()); 491ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const PassInfo *IPI = PR->getPassInfo(StringRef("machineinstr-printer")); 4926e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson assert (TPI && IPI && "Pass ID not registered!"); 49359324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky const char *TID = (const char *)(TPI->getTypeInfo()); 49459324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky const char *IID = (const char *)(IPI->getTypeInfo()); 4953fb99a73686c39d9855b3f8881add977af3868cbBob Wilson insertPass(TID, IID); 4966e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 4976e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 498f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen // Print the instruction selected machine code... 499f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen printAndVerify("After Instruction Selection"); 500f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen 501d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Expand pseudo-instructions emitted by ISel. 502ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&ExpandISelPseudosID); 503d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 504f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Add passes that optimize machine instructions in SSA form. 505d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None) { 506f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addMachineSSAOptimization(); 5078f54a53f0ed2091e05d5ca87d239487da292cbbcCraig Topper } else { 508f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // If the target requests it, assign local variables to stack slots relative 509f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // to one another and simplify frame index references where possible. 510ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&LocalStackSlotAllocationID, false); 511d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 512d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 513d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run pre-ra passes. 514ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPreRegAlloc(); 515d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 516f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Run register allocation and passes that are tightly coupled with it, 517f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // including phi elimination and scheduling. 5188dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (getOptimizeRegAlloc()) 5198dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick addOptimizedRegAlloc(createRegAllocPass(true)); 5208dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick else 5218dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick addFastRegAlloc(createRegAllocPass(false)); 522d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 523d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run post-ra passes. 524ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPostRegAlloc(); 525d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 526d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Insert prolog/epilog code. Eliminate abstract frame index references... 5273fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PrologEpilogCodeInserterID); 528d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 529f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick /// Add passes that optimize machine instructions after register allocation. 530f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick if (getOptLevel() != CodeGenOpt::None) 531f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addMachineLateOptimization(); 532d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 533d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Expand pseudo instructions before second scheduling pass. 5343fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&ExpandPostRAPseudosID); 535d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 536d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run pre-sched2 passes. 537ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPreSched2(); 538d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 539d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Second pass scheduler. 54079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (getOptLevel() != CodeGenOpt::None) { 54136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MISchedPostRA) 54236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(&PostMachineSchedulerID); 54336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines else 54436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(&PostRASchedulerID); 545d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 546d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 547f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // GC 548ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng if (addGCPasses()) { 549ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng if (PrintGCInfo) 550ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(createGCInfoPrinter(dbgs()), false, false); 551ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng } 552d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 553f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Basic block placement. 55479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (getOptLevel() != CodeGenOpt::None) 555f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addBlockPlacement(); 556d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 557ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPreEmitPass(); 55836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 559ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&StackMapLivenessID, false); 560ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 561ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AddingMachinePasses = false; 562d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick} 563d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 564f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add passes that optimize machine instructions in SSA form. 565f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addMachineSSAOptimization() { 566f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Pre-ra tail duplication. 567ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&EarlyTailDuplicateID); 568f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 569f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Optimize PHIs before DCE: removing dead PHI cycles may make more 570f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // instructions dead. 571ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&OptimizePHIsID, false); 572f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 573c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem // This pass merges large allocas. StackSlotColoring is a different pass 574c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem // which merges spill slots. 575ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&StackColoringID, false); 576c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem 577f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // If the target requests it, assign local variables to stack slots relative 578f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // to one another and simplify frame index references where possible. 579ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&LocalStackSlotAllocationID, false); 580f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 581f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // With optimization, dead code should already be eliminated. However 582f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // there is one known exception: lowered code for arguments that are only 583f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // used by tail calls, where the tail calls reuse the incoming stack 584f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // arguments directly (see t11 in test/CodeGen/X86/sibcall.ll). 5853fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&DeadMachineInstructionElimID); 586f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 58702c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // Allow targets to insert passes that improve instruction level parallelism, 58802c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // like if-conversion. Such passes will typically need dominator trees and 58902c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // loop info, just like LICM and CSE below. 590ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addILPOpts(); 59102c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen 592ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&MachineLICMID, false); 593ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&MachineCSEID, false); 5943fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineSinkingID); 595f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 596ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&PeepholeOptimizerID, false); 59737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Clean-up the dead code that may have been generated by peephole 59837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // rewriting. 59937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines addPass(&DeadMachineInstructionElimID); 600f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 601f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 6027461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick//===---------------------------------------------------------------------===// 603f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Register Allocation Pass Configuration 604eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 605f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 6068dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickbool TargetPassConfig::getOptimizeRegAlloc() const { 6078dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick switch (OptimizeRegAlloc) { 6088dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_UNSET: return getOptLevel() != CodeGenOpt::None; 6098dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_TRUE: return true; 6108dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_FALSE: return false; 6118dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick } 6128dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick llvm_unreachable("Invalid optimize-regalloc state"); 6138dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6148dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 615f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// RegisterRegAlloc's global Registry tracks allocator registration. 616eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterRegAlloc::Registry; 617eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 618f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// A dummy default pass factory indicates whether the register allocator is 619f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// overridden on the command line. 620dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic FunctionPass *useDefaultRegisterAllocator() { return nullptr; } 621700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesenstatic RegisterRegAlloc 622700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund OlesendefaultRegAlloc("default", 623700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen "pick register allocator based on -O option", 6248dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick useDefaultRegisterAllocator); 625eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 626f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// -regalloc=... command line option. 627844731a7f1909f55935e3514c9e713a62d67662eDan Gohmanstatic cl::opt<RegisterRegAlloc::FunctionPassCtor, false, 628844731a7f1909f55935e3514c9e713a62d67662eDan Gohman RegisterPassParser<RegisterRegAlloc> > 629844731a7f1909f55935e3514c9e713a62d67662eDan GohmanRegAlloc("regalloc", 6308dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick cl::init(&useDefaultRegisterAllocator), 631700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen cl::desc("Register allocator to use")); 63233a0a6ddf5427e05b1d9477075c6f6bf60aa7e62Jim Laskey 633eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 6348dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Instantiate the default register allocator pass for this target for either 6358dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// the optimized or unoptimized allocation path. This will be added to the pass 6368dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// manager by addFastRegAlloc in the unoptimized case or addOptimizedRegAlloc 6378dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// in the optimized case. 6388dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6398dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// A target that uses the standard regalloc pass order for fast or optimized 6408dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// allocation may still override this for per-target regalloc 6418dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// selection. But -regalloc=... always takes precedence. 6428dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickFunctionPass *TargetPassConfig::createTargetRegisterAllocator(bool Optimized) { 6438dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (Optimized) 6448dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createGreedyRegisterAllocator(); 6458dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick else 6468dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createFastRegisterAllocator(); 6478dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6488dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 6498dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Find and instantiate the register allocation pass requested by this target 6508dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// at the current optimization level. Different register allocators are 6518dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// defined as separate passes because they may require different analysis. 6528dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6538dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// This helper ensures that the regalloc= option is always available, 6548dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// even for targets that override the default allocator. 6558dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6568dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// FIXME: When MachinePassRegistry register pass IDs instead of function ptrs, 6578dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// this can be folded into addPass. 6588dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickFunctionPass *TargetPassConfig::createRegAllocPass(bool Optimized) { 6599ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey RegisterRegAlloc::FunctionPassCtor Ctor = RegisterRegAlloc::getDefault(); 660700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen 6618dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // Initialize the global default. 66213ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 663eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = RegAlloc; 664eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterRegAlloc::setDefault(RegAlloc); 66513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey } 6668dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (Ctor != useDefaultRegisterAllocator) 667700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen return Ctor(); 668700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen 6698dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // With no -regalloc= override, ask the target for a regalloc pass. 6708dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createTargetRegisterAllocator(Optimized); 6718dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6728dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 67337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines/// Return true if the default global register allocator is in use and 67437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines/// has not be overriden on the command line with '-regalloc=...' 67537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesbool TargetPassConfig::usingDefaultRegAlloc() const { 67637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return RegAlloc.getNumOccurrences() == 0; 67737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 67837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 6798dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Add the minimum set of target-independent passes that are required for 6808dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// register allocation. No coalescing or scheduling. 6818dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickvoid TargetPassConfig::addFastRegAlloc(FunctionPass *RegAllocPass) { 682ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&PHIEliminationID, false); 683ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&TwoAddressInstructionPassID, false); 6848dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 685564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(RegAllocPass); 68633a0a6ddf5427e05b1d9477075c6f6bf60aa7e62Jim Laskey} 687f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 688f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add standard target-independent passes that are tightly coupled with 6898dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// optimized register allocation, including coalescing, machine instruction 6908dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// scheduling, and register allocation itself. 6918dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickvoid TargetPassConfig::addOptimizedRegAlloc(FunctionPass *RegAllocPass) { 692ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&ProcessImplicitDefsID, false); 6935984d2b31fe3c69e46d2b81439a8c3ef0bdf9a91Jakob Stoklund Olesen 6948dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // LiveVariables currently requires pure SSA form. 6958dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // 6968dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // FIXME: Once TwoAddressInstruction pass no longer uses kill flags, 6978dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // LiveVariables can be removed completely, and LiveIntervals can be directly 6988dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // computed. (We still either need to regenerate kill flags after regalloc, or 6998dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // preferably fix the scavenger to not depend on them). 700ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&LiveVariablesID, false); 7018dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 70267b28826cdc7be697acdd3e536a05665fd2a9752Rafael Espindola // Edge splitting is smarter with machine loop info. 703ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&MachineLoopInfoID, false); 704ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&PHIEliminationID, false); 705dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 706dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen // Eventually, we want to run LiveIntervals before PHI elimination. 707dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen if (EarlyLiveIntervals) 708ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&LiveIntervalsID, false); 709dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 710ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&TwoAddressInstructionPassID, false); 7113fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&RegisterCoalescerID); 7128dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 7138dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // PreRA instruction scheduling. 714ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&MachineSchedulerID); 7158dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 7168dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // Add the selected register allocation pass. 717564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(RegAllocPass); 71834f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen 71934f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen // Allow targets to change the register assignments before rewriting. 720ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPreRewrite(); 721f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 72205ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Finally rewrite virtual registers. 7233fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&VirtRegRewriterID); 72405ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 725f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Perform stack slot coloring and post-ra machine LICM. 7268dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // 7278dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // FIXME: Re-enable coloring with register when it's capable of adding 7288dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // kill markers. 7293fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&StackSlotColoringID); 730900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick 731900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // Run post-ra machine LICM to hoist reloads / remats. 732900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // 733900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // FIXME: can this move into MachineLateOptimization? 7343fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PostRAMachineLICMID); 735f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 736f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 737f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick//===---------------------------------------------------------------------===// 738f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Post RegAlloc Pass Configuration 739f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick//===---------------------------------------------------------------------===// 740f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 741f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add passes that optimize machine instructions after register allocation. 742f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addMachineLateOptimization() { 743f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Branch folding must be run after regalloc and prolog/epilog insertion. 744ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&BranchFolderPassID); 745f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 746f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Tail duplication. 74736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Note that duplicating tail just increases code size and degrades 74836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // performance for targets that require Structured Control Flow. 74936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // In addition it can also make CFG irreducible. Thus we disable it. 750ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!TM->requiresStructuredCFG()) 751ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&TailDuplicateID); 752f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 753f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Copy propagation. 754ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&MachineCopyPropagationID); 755f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 756f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 757ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng/// Add standard GC passes. 758ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Chengbool TargetPassConfig::addGCPasses() { 759ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines addPass(&GCMachineCodeAnalysisID, false); 760ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng return true; 761ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng} 762ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng 763f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add standard basic block placement passes. 764f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addBlockPlacement() { 765ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (addPass(&MachineBlockPlacementID, false)) { 76679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick // Run a separate pass to collect block placement statistics. 76779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (EnableBlockPlacementStats) 7683fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineBlockPlacementStatsID); 769f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick } 770f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 771