Passes.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
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/GCStrategy.h" 18d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/CodeGen/MachineFunctionPass.h" 19d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/CodeGen/RegAllocRegistry.h" 2036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/IRPrintingPasses.h" 2136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/Verifier.h" 22564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson#include "llvm/MC/MCAsmInfo.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/PassManager.h" 24d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/Support/CommandLine.h" 25d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick#include "llvm/Support/Debug.h" 267461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick#include "llvm/Support/ErrorHandling.h" 27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetLowering.h" 28d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetSubtargetInfo.h" 29d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Transforms/Scalar.h" 3013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 31aa4c91ff9669244b873cadd37e86fb7e19c5e82cChris Lattnerusing namespace llvm; 32d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 3336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesnamespace llvm { 3436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesextern cl::opt<bool> EnableStackMapLiveness; 3536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesextern cl::opt<bool> EnablePatchPointLiveness; 3636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 3736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 38d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisablePostRA("disable-post-ra", cl::Hidden, 39d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Post Regalloc")); 40d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableBranchFold("disable-branch-fold", cl::Hidden, 41d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable branch folding")); 42d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableTailDuplicate("disable-tail-duplicate", cl::Hidden, 43d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable tail duplication")); 44d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableEarlyTailDup("disable-early-taildup", cl::Hidden, 45d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable pre-register allocation tail duplication")); 469e67db4af13abb967cae5858502207a43d26bf84Chandler Carruthstatic cl::opt<bool> DisableBlockPlacement("disable-block-placement", 4774a4533a4290b7c6f1fe04a30ca13ec25c529e0aBenjamin Kramer cl::Hidden, cl::desc("Disable probability-driven block placement")); 48d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> EnableBlockPlacementStats("enable-block-placement-stats", 49d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::Hidden, cl::desc("Collect probability-driven block placement stats")); 50d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableSSC("disable-ssc", cl::Hidden, 51d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Stack Slot Coloring")); 52d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineDCE("disable-machine-dce", cl::Hidden, 53d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Dead Code Elimination")); 540d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesenstatic cl::opt<bool> DisableEarlyIfConversion("disable-early-ifcvt", cl::Hidden, 550d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesen cl::desc("Disable Early If-conversion")); 56d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineLICM("disable-machine-licm", cl::Hidden, 57d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine LICM")); 58d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineCSE("disable-machine-cse", cl::Hidden, 59d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Common Subexpression Elimination")); 608dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickstatic cl::opt<cl::boolOrDefault> 618dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickOptimizeRegAlloc("optimize-regalloc", cl::Hidden, 628dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick cl::desc("Enable optimized register allocation compilation path.")); 63746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trickstatic cl::opt<cl::boolOrDefault> 6436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesEnableMachineSched("enable-misched", 658dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick cl::desc("Enable the machine instruction scheduling pass.")); 66d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm", 67d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::Hidden, 68d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine LICM")); 69d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableMachineSink("disable-machine-sink", cl::Hidden, 70d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Machine Sinking")); 71d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableLSR("disable-lsr", cl::Hidden, 72d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Loop Strength Reduction Pass")); 7336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic cl::opt<bool> DisableConstantHoisting("disable-constant-hoisting", 7436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines cl::Hidden, cl::desc("Disable ConstantHoisting")); 75d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableCGP("disable-cgp", cl::Hidden, 76d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Disable Codegen Prepare")); 77d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> DisableCopyProp("disable-copyprop", cl::Hidden, 7801b623c8c2d1bd015a8bb20eafee3322575eff8fEvan Cheng cl::desc("Disable Copy Propagation pass")); 79d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintLSR("print-lsr-output", cl::Hidden, 80d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Print LLVM IR produced by the loop-reduce pass")); 81d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintISelInput("print-isel-input", cl::Hidden, 82d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Print LLVM IR input to isel pass")); 83d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> PrintGCInfo("print-gc", cl::Hidden, 84d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Dump garbage collector data")); 85d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trickstatic cl::opt<bool> VerifyMachineCode("verify-machineinstrs", cl::Hidden, 86d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::desc("Verify generated machine code"), 87d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick cl::init(getenv("LLVM_VERIFY_MACHINEINSTRS")!=NULL)); 886e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilsonstatic cl::opt<std::string> 896e1b8128505711276a87e96f6bffb818b435cbd5Bob WilsonPrintMachineInstrs("print-machineinstrs", cl::ValueOptional, 906e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson cl::desc("Print machine instrs"), 916e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson cl::value_desc("pass-name"), cl::init("option-unspecified")); 92d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 9336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// Temporary option to allow experimenting with MachineScheduler as a post-RA 9436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// scheduler. Targets can "properly" enable this with 9536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// substitutePass(&PostRASchedulerID, &MachineSchedulerID); Ideally it wouldn't 9636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// be part of the standard pass pipeline, and the target would just add a PostRA 9736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines// scheduling pass wherever it wants. 9836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic cl::opt<bool> MISchedPostRA("misched-postra", cl::Hidden, 9936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines cl::desc("Run MachineScheduler post regalloc (independent of preRA sched)")); 10036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 101d7c7a686ac18f8f3c035d158d8b713077be83ea4Cameron Zwarich// Experimental option to run live interval analysis early. 102dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesenstatic cl::opt<bool> EarlyLiveIntervals("early-live-intervals", cl::Hidden, 103dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen cl::desc("Run live interval analysis earlier in the pipeline")); 104dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 10579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// Allow standard passes to be disabled by command line options. This supports 10679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// simple binary flags that either suppress the pass or do nothing. 10779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// i.e. -disable-mypass=false has no effect. 10879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// These should be converted to boolOrDefault in order to use applyOverride. 1095ed028385c39f3de4570fa6f77c734d968d26902Andrew Trickstatic IdentifyingPassPtr applyDisable(IdentifyingPassPtr PassID, 1105ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick bool Override) { 11179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (Override) 1125ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick return IdentifyingPassPtr(); 1133fb99a73686c39d9855b3f8881add977af3868cbBob Wilson return PassID; 11479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick} 11579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 11679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// Allow Pass selection to be overriden by command line options. This supports 11779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// flags with ternary conditions. TargetID is passed through by default. The 11879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// pass is suppressed when the option is false. When the option is true, the 11979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// StandardID is selected if the target provides no default. 1205ed028385c39f3de4570fa6f77c734d968d26902Andrew Trickstatic IdentifyingPassPtr applyOverride(IdentifyingPassPtr TargetID, 1215ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick cl::boolOrDefault Override, 1225ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick AnalysisID StandardID) { 123746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick switch (Override) { 124746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick case cl::BOU_UNSET: 12579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return TargetID; 126746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick case cl::BOU_TRUE: 1275ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (TargetID.isValid()) 12879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return TargetID; 1293fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if (StandardID == 0) 130746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick report_fatal_error("Target cannot enable pass"); 13179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return StandardID; 132746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick case cl::BOU_FALSE: 1335ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick return IdentifyingPassPtr(); 134746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick } 135746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick llvm_unreachable("Invalid command line option state"); 136746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick} 137746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick 13879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// Allow standard passes to be disabled by the command line, regardless of who 13979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// is adding the pass. 14079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 14179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// StandardID is the pass identified in the standard pass pipeline and provided 14279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// to addPass(). It may be a target-specific ID in the case that the target 14379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// directly adds its own pass, but in that case we harmlessly fall through. 14479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 14579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// TargetID is the pass that the target has configured to override StandardID. 14679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// 14779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// StandardID may be a pseudo ID. In that case TargetID is the name of the real 14879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// pass to run. This allows multiple options to control a single pass depending 14979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick/// on where in the pipeline that pass is added. 1505ed028385c39f3de4570fa6f77c734d968d26902Andrew Trickstatic IdentifyingPassPtr overridePass(AnalysisID StandardID, 1515ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID) { 15279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &PostRASchedulerID) 15379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisablePostRA); 15479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 15579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &BranchFolderPassID) 15679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableBranchFold); 15779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 15879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TailDuplicateID) 15979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableTailDuplicate); 16079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TargetPassConfig::EarlyTailDuplicateID) 16279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableEarlyTailDup); 16379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineBlockPlacementID) 16574a4533a4290b7c6f1fe04a30ca13ec25c529e0aBenjamin Kramer return applyDisable(TargetID, DisableBlockPlacement); 16679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 16779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &StackSlotColoringID) 16879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableSSC); 16979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 17079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &DeadMachineInstructionElimID) 17179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineDCE); 17279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 17333242fd3ed5586091e73254b58dd1825e9d53c60Jakob Stoklund Olesen if (StandardID == &EarlyIfConverterID) 1740d141f867d49dadc2f7580b149464f1e8e095f03Jakob Stoklund Olesen return applyDisable(TargetID, DisableEarlyIfConversion); 17533242fd3ed5586091e73254b58dd1825e9d53c60Jakob Stoklund Olesen 17679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineLICMID) 17779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineLICM); 17879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 17979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineCSEID) 18079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineCSE); 18179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 18279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineSchedulerID) 18379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyOverride(TargetID, EnableMachineSched, StandardID); 18479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 18579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &TargetPassConfig::PostRAMachineLICMID) 18679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisablePostRAMachineLICM); 18779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 18879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineSinkingID) 18979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableMachineSink); 19079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 19179bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (StandardID == &MachineCopyPropagationID) 19279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return applyDisable(TargetID, DisableCopyProp); 19379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 19479bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick return TargetID; 19579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick} 19679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 197eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 1987461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// TargetPassConfig 1997461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick//===---------------------------------------------------------------------===// 2007461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 2017461334084aa77286b6f9af596fb0f6ba0465685Andrew TrickINITIALIZE_PASS(TargetPassConfig, "targetpassconfig", 2027461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick "Target Pass Configuration", false, false) 2037461334084aa77286b6f9af596fb0f6ba0465685Andrew Trickchar TargetPassConfig::ID = 0; 2047461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 20579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick// Pseudo Pass IDs. 20679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trickchar TargetPassConfig::EarlyTailDuplicateID = 0; 20779bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trickchar TargetPassConfig::PostRAMachineLICMID = 0; 20879bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 2095e108eeeef34dd2afa00d1da77bca47188de4244Andrew Tricknamespace llvm { 2105e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trickclass PassConfigImpl { 2115e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trickpublic: 2125e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // List of passes explicitly substituted by this target. Normally this is 2135e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // empty, but it is a convenient way to suppress or replace specific passes 2145e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // that are part of a standard pass pipeline without overridding the entire 2155e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // pipeline. This mechanism allows target options to inherit a standard pass's 2165e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick // user interface. For example, a target may disable a standard pass by 2173fb99a73686c39d9855b3f8881add977af3868cbBob Wilson // default by substituting a pass ID of zero, and the user may still enable 2183fb99a73686c39d9855b3f8881add977af3868cbBob Wilson // that standard pass with an explicit command line option. 2195ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick DenseMap<AnalysisID,IdentifyingPassPtr> TargetPasses; 2206e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 2216e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson /// Store the pairs of <AnalysisID, AnalysisID> of which the second pass 2226e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson /// is inserted after each instance of the first one. 2235ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick SmallVector<std::pair<AnalysisID, IdentifyingPassPtr>, 4> InsertedPasses; 2245e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick}; 2255e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} // namespace llvm 2265e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 2277461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick// Out of line virtual method. 2285e108eeeef34dd2afa00d1da77bca47188de4244Andrew TrickTargetPassConfig::~TargetPassConfig() { 2295e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick delete Impl; 2305e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 2317461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 23261f1e3db43e556f495b6b9360d2f550291f78471Andrew Trick// Out of line constructor provides default values for pass options and 23361f1e3db43e556f495b6b9360d2f550291f78471Andrew Trick// registers all common codegen passes. 234061efcfb3e79899493d857f49e50d09f29037e0aAndrew TrickTargetPassConfig::TargetPassConfig(TargetMachine *tm, PassManagerBase &pm) 23530a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson : ImmutablePass(ID), PM(&pm), StartAfter(0), StopAfter(0), 23630a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson Started(true), Stopped(false), TM(tm), Impl(0), Initialized(false), 237ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick DisableVerify(false), 238ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick EnableTailMerge(true) { 239ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick 2405e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick Impl = new PassConfigImpl(); 2415e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 2427461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick // Register all target independent codegen passes to activate their PassIDs, 2437461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick // including this pass itself. 2447461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick initializeCodeGen(*PassRegistry::getPassRegistry()); 24579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 24679bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick // Substitute Pseudo Pass IDs for real ones. 2473fb99a73686c39d9855b3f8881add977af3868cbBob Wilson substitutePass(&EarlyTailDuplicateID, &TailDuplicateID); 2483fb99a73686c39d9855b3f8881add977af3868cbBob Wilson substitutePass(&PostRAMachineLICMID, &MachineLICMID); 24979bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick 25079bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick // Temporarily disable experimental passes. 251ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick const TargetSubtargetInfo &ST = TM->getSubtarget<TargetSubtargetInfo>(); 252b6ac11cd03e9dd97b45dc97787171f942ef8e344Andrew Trick if (!ST.useMachineScheduler()) 253ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick disablePass(&MachineSchedulerID); 2547461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2557461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 2566e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson/// Insert InsertedPassID pass after TargetPassID. 2573fb99a73686c39d9855b3f8881add977af3868cbBob Wilsonvoid TargetPassConfig::insertPass(AnalysisID TargetPassID, 2585ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr InsertedPassID) { 259fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer assert(((!InsertedPassID.isInstance() && 260fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer TargetPassID != InsertedPassID.getID()) || 261fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer (InsertedPassID.isInstance() && 262fdca22129033ff830a8a9574f0e24a49caedfa96Benjamin Kramer TargetPassID != InsertedPassID.getInstance()->getPassID())) && 2635ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick "Insert a pass after itself!"); 2645ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick std::pair<AnalysisID, IdentifyingPassPtr> P(TargetPassID, InsertedPassID); 2656e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson Impl->InsertedPasses.push_back(P); 2666e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson} 2676e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 2687461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// createPassConfig - Create a pass configuration object to be used by 2697461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// addPassToEmitX methods for generating a pipeline of CodeGen passes. 2707461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// 2717461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick/// Targets may override this to extend TargetPassConfig. 272061efcfb3e79899493d857f49e50d09f29037e0aAndrew TrickTargetPassConfig *LLVMTargetMachine::createPassConfig(PassManagerBase &PM) { 273061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick return new TargetPassConfig(this, PM); 2747461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2757461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 2767461334084aa77286b6f9af596fb0f6ba0465685Andrew TrickTargetPassConfig::TargetPassConfig() 2777c4ce30ea6a9d0410f306e805403dd224c3df65cBill Wendling : ImmutablePass(ID), PM(0) { 2787461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick llvm_unreachable("TargetPassConfig should not be constructed on-the-fly"); 2797461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick} 2807461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick 281ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick// Helper to verify the analysis is really immutable. 282ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trickvoid TargetPassConfig::setOpt(bool &Opt, bool Val) { 283ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick assert(!Initialized && "PassConfig is immutable"); 284ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick Opt = Val; 285ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick} 286ffea03f2165c5a4fda672495bf853aa2d8c7d1b5Andrew Trick 2873fb99a73686c39d9855b3f8881add977af3868cbBob Wilsonvoid TargetPassConfig::substitutePass(AnalysisID StandardID, 2885ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID) { 2893fb99a73686c39d9855b3f8881add977af3868cbBob Wilson Impl->TargetPasses[StandardID] = TargetID; 2905e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 291746f24b732830f434032de5d2d321e6ad1f8e782Andrew Trick 2925ed028385c39f3de4570fa6f77c734d968d26902Andrew TrickIdentifyingPassPtr TargetPassConfig::getPassSubstitution(AnalysisID ID) const { 2935ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick DenseMap<AnalysisID, IdentifyingPassPtr>::const_iterator 2945e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick I = Impl->TargetPasses.find(ID); 2955e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick if (I == Impl->TargetPasses.end()) 2965e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return ID; 2975e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return I->second; 2985e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick} 2995e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick 30030a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// Add a pass to the PassManager if that pass is supposed to be run. If the 30130a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// Started/Stopped flags indicate either that the compilation should start at 30230a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// a later pass or that it should stop after an earlier pass, then do not add 30330a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// the pass. Finally, compare the current pass against the StartAfter 30430a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson/// and StopAfter options and change the Started/Stopped flags accordingly. 305564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilsonvoid TargetPassConfig::addPass(Pass *P) { 3066b2bb15bf7c77918adc433646846f6847d421257Bob Wilson assert(!Initialized && "PassConfig is immutable"); 3076b2bb15bf7c77918adc433646846f6847d421257Bob Wilson 3086068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // Cache the Pass ID here in case the pass manager finds this pass is 3096068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // redundant with ones already scheduled / available, and deletes it. 3106068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // Fundamentally, once we add the pass to the manager, we no longer own it 3116068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth // and shouldn't reference it. 3126068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth AnalysisID PassID = P->getPassID(); 3136068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth 31430a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson if (Started && !Stopped) 31530a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson PM->add(P); 316f8e16c6f5a3a0d2cc6f7ae6dae0a8f55a89cfb2fBenjamin Kramer else 317f8e16c6f5a3a0d2cc6f7ae6dae0a8f55a89cfb2fBenjamin Kramer delete P; 3186068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth if (StopAfter == PassID) 31930a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson Stopped = true; 3206068c48498e9af1076b1b5f2499e176e7e9c0f34Chandler Carruth if (StartAfter == PassID) 32130a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson Started = true; 32230a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson if (Stopped && !Started) 32330a507a1f5d6a5646dd3481eba6958424415c886Bob Wilson report_fatal_error("Cannot stop compilation after pass that is not run"); 324564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson} 325564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 3265e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick/// Add a CodeGen pass at this point in the pipeline after checking for target 3275e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick/// and command line overrides. 3285ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// 3295ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// addPass cannot return a pointer to the pass instance because is internal the 3305ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick/// PassManager and the instance we create here may already be freed. 3313fb99a73686c39d9855b3f8881add977af3868cbBob WilsonAnalysisID TargetPassConfig::addPass(AnalysisID PassID) { 3325ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr TargetID = getPassSubstitution(PassID); 3335ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick IdentifyingPassPtr FinalPtr = overridePass(PassID, TargetID); 3345ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (!FinalPtr.isValid()) 3355ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick return 0; 3365ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick 3375ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick Pass *P; 3385ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (FinalPtr.isInstance()) 3395ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick P = FinalPtr.getInstance(); 3405ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick else { 3415ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick P = Pass::createPass(FinalPtr.getID()); 3425ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if (!P) 3435ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick llvm_unreachable("Pass ID not registered"); 3445ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick } 3455ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick AnalysisID FinalID = P->getPassID(); 3465ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick addPass(P); // Ends the lifetime of P. 3475ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick 3486e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // Add the passes after the pass P if there is any. 349f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper for (SmallVectorImpl<std::pair<AnalysisID, IdentifyingPassPtr> >::iterator 3506e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson I = Impl->InsertedPasses.begin(), E = Impl->InsertedPasses.end(); 3516e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson I != E; ++I) { 3523fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if ((*I).first == PassID) { 3535ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick assert((*I).second.isValid() && "Illegal Pass ID!"); 3545ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick Pass *NP; 3555ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick if ((*I).second.isInstance()) 3565ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick NP = (*I).second.getInstance(); 3575ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick else { 3585ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick NP = Pass::createPass((*I).second.getID()); 3595ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick assert(NP && "Pass ID not registered"); 3605ed028385c39f3de4570fa6f77c734d968d26902Andrew Trick } 361564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(NP); 3626e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 3636e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 3645e108eeeef34dd2afa00d1da77bca47188de4244Andrew Trick return FinalID; 365061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 366d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 367564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilsonvoid TargetPassConfig::printAndVerify(const char *Banner) { 368d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (TM->shouldPrintMachineCode()) 369564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createMachineFunctionPrinterPass(dbgs(), Banner)); 370d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 371d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (VerifyMachineCode) 372564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createMachineVerifierPass(Banner)); 373d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick} 374d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 375061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick/// Add common target configurable passes that perform LLVM IR to IR transforms 376061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick/// following machine independent optimization. 377061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trickvoid TargetPassConfig::addIRPasses() { 378d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Basic AliasAnalysis support. 379d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that 380d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // BasicAliasAnalysis wins if they disagree. This is intended to help 381d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // support "obvious" type-punning idioms. 382564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createTypeBasedAliasAnalysisPass()); 383564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createBasicAliasAnalysisPass()); 384d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 385d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Before running any passes, run the verifier to determine if the input 386d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // coming from the front-end and/or optimizer is valid. 387d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (!DisableVerify) 388564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createVerifierPass()); 389d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 390d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run loop strength reduction before anything else. 391d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None && !DisableLSR) { 392e4ba75f43e2ab1480d119d2d4eb878256274e0fbChandler Carruth addPass(createLoopStrengthReducePass()); 393d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (PrintLSR) 39436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createPrintFunctionPass(dbgs(), "\n\n*** Code after LSR ***\n")); 395d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 396d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 397564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createGCLoweringPass()); 398d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 399d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Make sure that no unreachable blocks are instruction selected. 400564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createUnreachableBlockEliminationPass()); 40136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 40236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Prepare expensive constants for SelectionDAG. 40336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (getOptLevel() != CodeGenOpt::None && !DisableConstantHoisting) 40436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createConstantHoistingPass()); 405564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson} 406564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 407564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson/// Turn exception handling constructs into something the code generators can 408564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson/// handle. 409564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilsonvoid TargetPassConfig::addPassesToHandleExceptions() { 410564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson switch (TM->getMCAsmInfo()->getExceptionHandlingType()) { 411564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::SjLj: 412564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both 413564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // Dwarf EH prepare needs to be run after SjLj prepare. Otherwise, 414564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // catch info can get misplaced when a selector ends up more than one block 415564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // removed from the parent invoke(s). This could happen when a landing 416564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // pad is shared by multiple invokes and is also a target of a normal 417564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // edge from elsewhere. 418ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling addPass(createSjLjEHPreparePass(TM)); 419564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // FALLTHROUGH 420564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::DwarfCFI: 421564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::ARM: 422564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::Win64: 423ea44281d5da5096de50ce1cb358ff0c6f20e1a2aBill Wendling addPass(createDwarfEHPass(TM)); 424564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson break; 425564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson case ExceptionHandling::None: 42636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createLowerInvokePass()); 427564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson 428564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson // The lower invoke pass may create unreachable code. Remove it. 429564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createUnreachableBlockEliminationPass()); 430564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson break; 431564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson } 432061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 433d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 43408510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// Add pass to prepare the LLVM IR for code generation. This should be done 43508510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// before exception handling preparation passes. 43608510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendlingvoid TargetPassConfig::addCodeGenPrepare() { 437d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None && !DisableCGP) 438f9fd58a44bbc7d9371ce39eb20eec16b0f1f7395Bill Wendling addPass(createCodeGenPreparePass(TM)); 43908510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling} 440d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 44108510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// Add common passes that perform LLVM IR to IR transforms in preparation for 44208510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendling/// instruction selection. 44308510b14d4fe5d9b1a979fbee8a7aad11dbc6ceaBill Wendlingvoid TargetPassConfig::addISelPrepare() { 444d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick addPreISel(); 445d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 44636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createStackProtectorPass(TM)); 44736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 448d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (PrintISelInput) 44936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(createPrintFunctionPass( 45036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines dbgs(), "\n\n*** Final LLVM Code input to ISel ***\n")); 451d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 452d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // All passes which modify the LLVM IR are now complete; run the verifier 453d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // to ensure that the IR is valid. 454d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (!DisableVerify) 455564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(createVerifierPass()); 456061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trick} 457d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 458f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add the complete set of target-independent postISel code generator passes. 459f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 460f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// This can be read as the standard order of major LLVM CodeGen stages. Stages 461f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// with nontrivial configuration or multiple passes are broken out below in 462f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// add%Stage routines. 463f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 464f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Any TargetPassConfig::addXX routine may be overriden by the Target. The 465f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// addPre/Post methods with empty header implementations allow injecting 466f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// target-specific fixups just before or after major stages. Additionally, 467f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// targets have the flexibility to change pass order within a stage by 468f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// overriding default implementation of add%Stage routines below. Each 469f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// technique has maintainability tradeoffs because alternate pass orders are 470f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// not well supported. addPre/Post works better if the target pass is easily 471f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// tied to a common pass. But if it has subtle dependencies on multiple passes, 47206efdd238ed7d14eaabc3b074c3b0b292c1c3127Andrew Trick/// the target should override the stage instead. 473f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// 474f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// TODO: We could use a single addPre/Post(ID) hook to allow pass injection 475f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// before/after any target-independent pass. But it's currently overkill. 476061efcfb3e79899493d857f49e50d09f29037e0aAndrew Trickvoid TargetPassConfig::addMachinePasses() { 4776e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // Insert a machine instr printer pass after the specified pass. 4786e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson // If -print-machineinstrs specified, print machineinstrs after all passes. 4796e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson if (StringRef(PrintMachineInstrs.getValue()).equals("")) 4806e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson TM->Options.PrintMachineCode = true; 4816e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson else if (!StringRef(PrintMachineInstrs.getValue()) 4826e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson .equals("option-unspecified")) { 4836e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson const PassRegistry *PR = PassRegistry::getPassRegistry(); 4846e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson const PassInfo *TPI = PR->getPassInfo(PrintMachineInstrs.getValue()); 4856e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson const PassInfo *IPI = PR->getPassInfo(StringRef("print-machineinstrs")); 4866e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson assert (TPI && IPI && "Pass ID not registered!"); 48759324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky const char *TID = (const char *)(TPI->getTypeInfo()); 48859324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky const char *IID = (const char *)(IPI->getTypeInfo()); 4893fb99a73686c39d9855b3f8881add977af3868cbBob Wilson insertPass(TID, IID); 4906e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson } 4916e1b8128505711276a87e96f6bffb818b435cbd5Bob Wilson 492f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen // Print the instruction selected machine code... 493f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen printAndVerify("After Instruction Selection"); 494f86c00f1f89082c800dbb78870fc5537eb3702f6Jakob Stoklund Olesen 495d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Expand pseudo-instructions emitted by ISel. 496228e3f5fac0ceef9f6fe22d1621ac32bae5d3177Jakob Stoklund Olesen if (addPass(&ExpandISelPseudosID)) 497228e3f5fac0ceef9f6fe22d1621ac32bae5d3177Jakob Stoklund Olesen printAndVerify("After ExpandISelPseudos"); 498d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 499f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Add passes that optimize machine instructions in SSA form. 500d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (getOptLevel() != CodeGenOpt::None) { 501f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addMachineSSAOptimization(); 5028f54a53f0ed2091e05d5ca87d239487da292cbbcCraig Topper } else { 503f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // If the target requests it, assign local variables to stack slots relative 504f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // to one another and simplify frame index references where possible. 5053fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&LocalStackSlotAllocationID); 506d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 507d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 508d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run pre-ra passes. 509d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (addPreRegAlloc()) 510d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick printAndVerify("After PreRegAlloc passes"); 511d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 512f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Run register allocation and passes that are tightly coupled with it, 513f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // including phi elimination and scheduling. 5148dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (getOptimizeRegAlloc()) 5158dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick addOptimizedRegAlloc(createRegAllocPass(true)); 5168dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick else 5178dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick addFastRegAlloc(createRegAllocPass(false)); 518d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 519d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run post-ra passes. 520d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (addPostRegAlloc()) 521d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick printAndVerify("After PostRegAlloc passes"); 522d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 523d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Insert prolog/epilog code. Eliminate abstract frame index references... 5243fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PrologEpilogCodeInserterID); 525d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick printAndVerify("After PrologEpilogCodeInserter"); 526d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 527f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick /// Add passes that optimize machine instructions after register allocation. 528f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick if (getOptLevel() != CodeGenOpt::None) 529f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addMachineLateOptimization(); 530d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 531d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Expand pseudo instructions before second scheduling pass. 5323fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&ExpandPostRAPseudosID); 5332ef5bf6b34cb0041648e7cb857d2c6e673d0550bJakob Stoklund Olesen printAndVerify("After ExpandPostRAPseudos"); 534d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 535d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick // Run pre-sched2 passes. 536d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (addPreSched2()) 53778811669d5872b28c447ea9f7cfc3963c7f72841Jakob Stoklund Olesen printAndVerify("After PreSched2 passes"); 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); 5458b4c502098d8a8aee52f2251db5614d9d26c83e2Jakob Stoklund Olesen printAndVerify("After PostRAScheduler"); 546d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick } 547d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 548f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // GC 549ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng if (addGCPasses()) { 550ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng if (PrintGCInfo) 551ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng addPass(createGCInfoPrinter(dbgs())); 552ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng } 553d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 554f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Basic block placement. 55579bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (getOptLevel() != CodeGenOpt::None) 556f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick addBlockPlacement(); 557d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 558d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick if (addPreEmitPass()) 5598b4c502098d8a8aee52f2251db5614d9d26c83e2Jakob Stoklund Olesen printAndVerify("After PreEmit passes"); 56036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 56136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (EnableStackMapLiveness || EnablePatchPointLiveness) 56236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines addPass(&StackMapLivenessID); 563d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick} 564d5422654016b3ac7494db1d2ba16bd8febadb0a8Andrew Trick 565f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add passes that optimize machine instructions in SSA form. 566f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addMachineSSAOptimization() { 567f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Pre-ra tail duplication. 5683fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if (addPass(&EarlyTailDuplicateID)) 569f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick printAndVerify("After Pre-RegAlloc TailDuplicate"); 570f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 571f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Optimize PHIs before DCE: removing dead PHI cycles may make more 572f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // instructions dead. 5733fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&OptimizePHIsID); 574f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 575c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem // This pass merges large allocas. StackSlotColoring is a different pass 576c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem // which merges spill slots. 577c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem addPass(&StackColoringID); 578c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem 579f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // If the target requests it, assign local variables to stack slots relative 580f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // to one another and simplify frame index references where possible. 5813fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&LocalStackSlotAllocationID); 582f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 583f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // With optimization, dead code should already be eliminated. However 584f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // there is one known exception: lowered code for arguments that are only 585f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // used by tail calls, where the tail calls reuse the incoming stack 586f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // arguments directly (see t11 in test/CodeGen/X86/sibcall.ll). 5873fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&DeadMachineInstructionElimID); 588f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick printAndVerify("After codegen DCE pass"); 589f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 59002c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // Allow targets to insert passes that improve instruction level parallelism, 59102c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // like if-conversion. Such passes will typically need dominator trees and 59202c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen // loop info, just like LICM and CSE below. 59302c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen if (addILPOpts()) 59402c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen printAndVerify("After ILP optimizations"); 59502c6325a4592fefebc837b677eaf87dc532ecb7cJakob Stoklund Olesen 5963fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineLICMID); 5973fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineCSEID); 5983fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineSinkingID); 599f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick printAndVerify("After Machine LICM, CSE and Sinking passes"); 600f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 6013fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PeepholeOptimizerID); 602f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick printAndVerify("After codegen peephole optimization pass"); 603f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 604f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 6057461334084aa77286b6f9af596fb0f6ba0465685Andrew Trick//===---------------------------------------------------------------------===// 606f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Register Allocation Pass Configuration 607eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 608f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 6098dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickbool TargetPassConfig::getOptimizeRegAlloc() const { 6108dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick switch (OptimizeRegAlloc) { 6118dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_UNSET: return getOptLevel() != CodeGenOpt::None; 6128dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_TRUE: return true; 6138dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick case cl::BOU_FALSE: return false; 6148dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick } 6158dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick llvm_unreachable("Invalid optimize-regalloc state"); 6168dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6178dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 618f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// RegisterRegAlloc's global Registry tracks allocator registration. 619eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterRegAlloc::Registry; 620eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 621f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// A dummy default pass factory indicates whether the register allocator is 622f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// overridden on the command line. 6238dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickstatic FunctionPass *useDefaultRegisterAllocator() { return 0; } 624700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesenstatic RegisterRegAlloc 625700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund OlesendefaultRegAlloc("default", 626700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen "pick register allocator based on -O option", 6278dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick useDefaultRegisterAllocator); 628eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 629f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// -regalloc=... command line option. 630844731a7f1909f55935e3514c9e713a62d67662eDan Gohmanstatic cl::opt<RegisterRegAlloc::FunctionPassCtor, false, 631844731a7f1909f55935e3514c9e713a62d67662eDan Gohman RegisterPassParser<RegisterRegAlloc> > 632844731a7f1909f55935e3514c9e713a62d67662eDan GohmanRegAlloc("regalloc", 6338dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick cl::init(&useDefaultRegisterAllocator), 634700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen cl::desc("Register allocator to use")); 63533a0a6ddf5427e05b1d9477075c6f6bf60aa7e62Jim Laskey 636eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 6378dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Instantiate the default register allocator pass for this target for either 6388dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// the optimized or unoptimized allocation path. This will be added to the pass 6398dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// manager by addFastRegAlloc in the unoptimized case or addOptimizedRegAlloc 6408dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// in the optimized case. 6418dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6428dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// A target that uses the standard regalloc pass order for fast or optimized 6438dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// allocation may still override this for per-target regalloc 6448dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// selection. But -regalloc=... always takes precedence. 6458dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickFunctionPass *TargetPassConfig::createTargetRegisterAllocator(bool Optimized) { 6468dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (Optimized) 6478dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createGreedyRegisterAllocator(); 6488dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick else 6498dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createFastRegisterAllocator(); 6508dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6518dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 6528dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Find and instantiate the register allocation pass requested by this target 6538dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// at the current optimization level. Different register allocators are 6548dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// defined as separate passes because they may require different analysis. 6558dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6568dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// This helper ensures that the regalloc= option is always available, 6578dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// even for targets that override the default allocator. 6588dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// 6598dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// FIXME: When MachinePassRegistry register pass IDs instead of function ptrs, 6608dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// this can be folded into addPass. 6618dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew TrickFunctionPass *TargetPassConfig::createRegAllocPass(bool Optimized) { 6629ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey RegisterRegAlloc::FunctionPassCtor Ctor = RegisterRegAlloc::getDefault(); 663700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen 6648dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // Initialize the global default. 66513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 666eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = RegAlloc; 667eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterRegAlloc::setDefault(RegAlloc); 66813ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey } 6698dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick if (Ctor != useDefaultRegisterAllocator) 670700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen return Ctor(); 671700bfada6375546f82000bdd1b4cdbe87beebea5Jakob Stoklund Olesen 6728dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // With no -regalloc= override, ask the target for a regalloc pass. 6738dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick return createTargetRegisterAllocator(Optimized); 6748dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick} 6758dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 6768dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// Add the minimum set of target-independent passes that are required for 6778dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// register allocation. No coalescing or scheduling. 6788dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickvoid TargetPassConfig::addFastRegAlloc(FunctionPass *RegAllocPass) { 6793fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PHIEliminationID); 6803fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&TwoAddressInstructionPassID); 6818dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 682564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(RegAllocPass); 6838dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick printAndVerify("After Register Allocation"); 68433a0a6ddf5427e05b1d9477075c6f6bf60aa7e62Jim Laskey} 685f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 686f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add standard target-independent passes that are tightly coupled with 6878dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// optimized register allocation, including coalescing, machine instruction 6888dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick/// scheduling, and register allocation itself. 6898dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickvoid TargetPassConfig::addOptimizedRegAlloc(FunctionPass *RegAllocPass) { 6903fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&ProcessImplicitDefsID); 6915984d2b31fe3c69e46d2b81439a8c3ef0bdf9a91Jakob Stoklund Olesen 6928dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // LiveVariables currently requires pure SSA form. 6938dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // 6948dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // FIXME: Once TwoAddressInstruction pass no longer uses kill flags, 6958dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // LiveVariables can be removed completely, and LiveIntervals can be directly 6968dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // computed. (We still either need to regenerate kill flags after regalloc, or 6978dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // preferably fix the scavenger to not depend on them). 6983fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&LiveVariablesID); 6998dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 70067b28826cdc7be697acdd3e536a05665fd2a9752Rafael Espindola // Edge splitting is smarter with machine loop info. 70167b28826cdc7be697acdd3e536a05665fd2a9752Rafael Espindola addPass(&MachineLoopInfoID); 70267b28826cdc7be697acdd3e536a05665fd2a9752Rafael Espindola addPass(&PHIEliminationID); 703dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 704dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen // Eventually, we want to run LiveIntervals before PHI elimination. 705dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen if (EarlyLiveIntervals) 706dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen addPass(&LiveIntervalsID); 707dcc4436cddc9b5d155040ed3ed38e9070ec4e3b8Jakob Stoklund Olesen 7083fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&TwoAddressInstructionPassID); 7093fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&RegisterCoalescerID); 7108dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 7118dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // PreRA instruction scheduling. 7123fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if (addPass(&MachineSchedulerID)) 71317d35e57a585e869dc3084666abd17f173723735Andrew Trick printAndVerify("After Machine Scheduling"); 7148dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 7158dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // Add the selected register allocation pass. 716564fbf6aff8fb95646a1290078a37c2d4dbe629fBob Wilson addPass(RegAllocPass); 71734f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen printAndVerify("After Register Allocation, before rewriter"); 71834f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen 71934f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen // Allow targets to change the register assignments before rewriting. 72034f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen if (addPreRewrite()) 72134f5a2b596236a5452ddc664066138ca7a0c7af2Jakob Stoklund Olesen printAndVerify("After pre-rewrite passes"); 722f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 72305ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen // Finally rewrite virtual registers. 7243fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&VirtRegRewriterID); 72505ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen printAndVerify("After Virtual Register Rewriter"); 72605ec712e7f75635abbdd84dced69f4a45fe0f541Jakob Stoklund Olesen 727f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Perform stack slot coloring and post-ra machine LICM. 7288dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // 7298dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // FIXME: Re-enable coloring with register when it's capable of adding 7308dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick // kill markers. 7313fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&StackSlotColoringID); 732900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick 733900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // Run post-ra machine LICM to hoist reloads / remats. 734900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // 735900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick // FIXME: can this move into MachineLateOptimization? 7363fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&PostRAMachineLICMID); 737900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick 738900d7b78e6cacca6c6062abf803d7ab1a4e39b38Andrew Trick printAndVerify("After StackSlotColoring and postra Machine LICM"); 739f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 740f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 741f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick//===---------------------------------------------------------------------===// 742f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Post RegAlloc Pass Configuration 743f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick//===---------------------------------------------------------------------===// 744f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 745f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add passes that optimize machine instructions after register allocation. 746f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addMachineLateOptimization() { 747f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Branch folding must be run after regalloc and prolog/epilog insertion. 7483fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if (addPass(&BranchFolderPassID)) 749663ee20cc4b13b6d37ad1578050d8c3cc31eeff5Jakob Stoklund Olesen printAndVerify("After BranchFolding"); 750f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 751f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Tail duplication. 75236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Note that duplicating tail just increases code size and degrades 75336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // performance for targets that require Structured Control Flow. 75436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // In addition it can also make CFG irreducible. Thus we disable it. 75536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!TM->requiresStructuredCFG() && addPass(&TailDuplicateID)) 756663ee20cc4b13b6d37ad1578050d8c3cc31eeff5Jakob Stoklund Olesen printAndVerify("After TailDuplicate"); 757f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 758f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick // Copy propagation. 7593fb99a73686c39d9855b3f8881add977af3868cbBob Wilson if (addPass(&MachineCopyPropagationID)) 760663ee20cc4b13b6d37ad1578050d8c3cc31eeff5Jakob Stoklund Olesen printAndVerify("After copy propagation pass"); 761f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 762f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 763ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng/// Add standard GC passes. 764ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Chengbool TargetPassConfig::addGCPasses() { 765ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng addPass(&GCMachineCodeAnalysisID); 766ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng return true; 767ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng} 768ab37b2c4bb23ab80f92429b59d812ed491c14ea6Evan Cheng 769f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick/// Add standard basic block placement passes. 770f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trickvoid TargetPassConfig::addBlockPlacement() { 77174a4533a4290b7c6f1fe04a30ca13ec25c529e0aBenjamin Kramer if (addPass(&MachineBlockPlacementID)) { 77279bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick // Run a separate pass to collect block placement statistics. 77379bf288584215f3f3c49050ac1691a6b29c56fecAndrew Trick if (EnableBlockPlacementStats) 7743fb99a73686c39d9855b3f8881add977af3868cbBob Wilson addPass(&MachineBlockPlacementStatsID); 775f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick 7768b4c502098d8a8aee52f2251db5614d9d26c83e2Jakob Stoklund Olesen printAndVerify("After machine block placement."); 777f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick } 778f7b96311d20dc19647833ec23fc6d7870b2ffb10Andrew Trick} 779