12c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===- RegisterCoalescer.cpp - Generic Register Coalescing Interface -------==// 22c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 32c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// The LLVM Compiler Infrastructure 42c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 72c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 82c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===----------------------------------------------------------------------===// 92c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 102c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// This file implements the generic RegisterCoalescer interface which 112c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// is used as the common interface used by all clients and 122c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// implementations of register coalescing. 132c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 142c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===----------------------------------------------------------------------===// 152c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 164281e20aab7f1fe1b35b31c9237ad89c20937e02Jakob Stoklund Olesen#define DEBUG_TYPE "regalloc" 17fdf16ca44f130afe80c57481d0c08130aa08cc09Rafael Espindola#include "RegisterCoalescer.h" 18bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/OwningPtr.h" 19bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/STLExtras.h" 20bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/SmallSet.h" 21bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/Statistic.h" 22bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Analysis/AliasAnalysis.h" 232c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene#include "llvm/CodeGen/LiveIntervalAnalysis.h" 24bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/CodeGen/LiveRangeEdit.h" 25655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineFrameInfo.h" 26655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineInstr.h" 27655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineLoopInfo.h" 28655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineRegisterInfo.h" 29655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/Passes.h" 301525260b3e50cc578939ef41b60609689eecfdd2Andrew Trick#include "llvm/CodeGen/RegisterClassInfo.h" 311ead68d769f27f6d68d4aaeffe4199fa2cacbc95Jakob Stoklund Olesen#include "llvm/CodeGen/VirtRegMap.h" 320b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Value.h" 33d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Pass.h" 34655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/CommandLine.h" 35655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/Debug.h" 36655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/ErrorHandling.h" 37655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/raw_ostream.h" 38bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetInstrInfo.h" 39bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetMachine.h" 40bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetRegisterInfo.h" 41ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick#include "llvm/Target/TargetSubtargetInfo.h" 42655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <algorithm> 43655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <cmath> 442c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greeneusing namespace llvm; 452c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 46655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numJoins , "Number of interval joins performed"); 47655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numCrossRCs , "Number of cross class joins performed"); 48655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numCommutes , "Number of instruction commuting performed"); 49655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numExtends , "Number of copies extended"); 50655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(NumReMats , "Number of instructions re-materialized"); 514a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund OlesenSTATISTIC(NumInflated , "Number of register classes inflated"); 52d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesenSTATISTIC(NumLaneConflicts, "Number of dead lane conflicts tested"); 53d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesenSTATISTIC(NumLaneResolves, "Number of dead lane conflicts resolved"); 54655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 55655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolastatic cl::opt<bool> 56655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaEnableJoining("join-liveintervals", 57655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::desc("Coalesce copies (default=true)"), 58655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::init(true)); 59655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 603c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// Temporary flag to test critical edge unsplitting. 61a6aae0273af9963eaf58aa548f7a918f100e67c7Andrew Trickstatic cl::opt<bool> 623c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew TrickEnableJoinSplits("join-splitedges", 63a6aae0273af9963eaf58aa548f7a918f100e67c7Andrew Trick cl::desc("Coalesce copies on split edges (default=subtarget)"), cl::Hidden); 643c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 65265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick// Temporary flag to test global copy optimization. 66ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trickstatic cl::opt<cl::boolOrDefault> 67265058d9239e6867d06dc8aa40db5f33390abd17Andrew TrickEnableGlobalCopies("join-globalcopies", 68ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick cl::desc("Coalesce copies that span blocks (default=subtarget)"), 69ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick cl::init(cl::BOU_UNSET), cl::Hidden); 70265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 71655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolastatic cl::opt<bool> 72655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaVerifyCoalescing("verify-coalescing", 73655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::desc("Verify machine instrs before and after register coalescing"), 74655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::Hidden); 75655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 768e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesennamespace { 77bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen class RegisterCoalescer : public MachineFunctionPass, 78bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen private LiveRangeEdit::Delegate { 79c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineFunction* MF; 80c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineRegisterInfo* MRI; 81c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetMachine* TM; 82c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetRegisterInfo* TRI; 83c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetInstrInfo* TII; 84c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveIntervals *LIS; 85c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const MachineLoopInfo* Loops; 868e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen AliasAnalysis *AA; 878e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen RegisterClassInfo RegClassInfo; 888e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 89ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// \brief True if the coalescer should aggressively coalesce global copies 90ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// in favor of keeping local copies. 91ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick bool JoinGlobalCopies; 92ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 93ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// \brief True if the coalescer should aggressively coalesce fall-thru 94ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// blocks exclusively containing copies. 95ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick bool JoinSplitEdges; 96ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 97b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /// WorkList - Copy instructions yet to be coalesced. 98b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen SmallVector<MachineInstr*, 8> WorkList; 99265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick SmallVector<MachineInstr*, 8> LocalWorkList; 100b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 101bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// ErasedInstrs - Set of instruction pointers that have been erased, and 102bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// that may be present in WorkList. 103bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallPtrSet<MachineInstr*, 8> ErasedInstrs; 104bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 105bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// Dead instructions that are about to be deleted. 106bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallVector<MachineInstr*, 8> DeadDefs; 107bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 10803c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen /// Virtual registers to be considered for register class inflation. 10903c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen SmallVector<unsigned, 8> InflateRegs; 11003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen 111bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// Recursively eliminate dead defs in DeadDefs. 112bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen void eliminateDeadDefs(); 113bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 114bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// LiveRangeEdit callback. 115bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen void LRE_WillEraseInstruction(MachineInstr *MI); 116bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 117265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// coalesceLocals - coalesce the LocalWorkList. 118265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick void coalesceLocals(); 119265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 1209790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinAllIntervals - join compatible live intervals 1219790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen void joinAllIntervals(); 1228e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1239790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// copyCoalesceInMBB - Coalesce copies in the specified MBB, putting 124b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /// copies that cannot yet be coalesced into WorkList. 125b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen void copyCoalesceInMBB(MachineBasicBlock *MBB); 126b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 127265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// copyCoalesceWorkList - Try to coalesce all copies in CurrList. Return 128265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// true if any progress was made. 129265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick bool copyCoalesceWorkList(MutableArrayRef<MachineInstr*> CurrList); 1308e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1319790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, 1328e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// which are the src/dst of the copy instruction CopyMI. This returns 1338e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// true if the copy was successfully coalesced away. If it is not 1348e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// currently possible to coalesce this interval, but it may be possible if 1358e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// other things get coalesced, then it returns true by reference in 1368e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// 'Again'. 1379790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool joinCopy(MachineInstr *TheCopy, bool &Again); 1388e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1399790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinIntervals - Attempt to join these two intervals. On failure, this 1408e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// returns false. The output "SrcInt" will not have been modified, so we 1418e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// can use this information below to update aliases. 1429790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool joinIntervals(CoalescerPair &CP); 1438e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 144c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Attempt joining two virtual registers. Return true on success. 145c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool joinVirtRegs(CoalescerPair &CP); 146c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 14792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen /// Attempt joining with a reserved physreg. 14892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen bool joinReservedPhysReg(CoalescerPair &CP); 14992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 1509790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// adjustCopiesBackFrom - We found a non-trivially-coalescable copy. If 1518e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// the source value number is defined by a copy from the destination reg 1528e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// see if we can merge these two destination reg valno# into a single 1538e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// value number, eliminating a copy. 1549790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool adjustCopiesBackFrom(const CoalescerPair &CP, MachineInstr *CopyMI); 1558e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1569790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// hasOtherReachingDefs - Return true if there are definitions of IntB 1578e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// other than BValNo val# that can reach uses of AValno val# of IntA. 1589790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool hasOtherReachingDefs(LiveInterval &IntA, LiveInterval &IntB, 1598e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen VNInfo *AValNo, VNInfo *BValNo); 1608e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1619790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// removeCopyByCommutingDef - We found a non-trivially-coalescable copy. 1628e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// If the source value number is defined by a commutable instruction and 1638e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// its other operand is coalesced to the copy dest register, see if we 1648e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// can transform the copy into a noop by commuting the definition. 1659790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool removeCopyByCommutingDef(const CoalescerPair &CP,MachineInstr *CopyMI); 1668e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1679790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// reMaterializeTrivialDef - If the source of a copy is defined by a 1688e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// trivial computation, replace the copy by rematerialize the definition. 1691d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich bool reMaterializeTrivialDef(CoalescerPair &CP, MachineInstr *CopyMI); 1708e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 17134a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen /// canJoinPhys - Return true if a physreg copy should be joined. 17239c71da6db9f52cf48430282a27384563a77793eJakub Staszak bool canJoinPhys(const CoalescerPair &CP); 1738e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1749790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 1758e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// update the subregister number if it is not zero. If DstReg is a 1768e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// physical register and the existing subregister number of the def / use 1778e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// being updated is not zero, make sure to set it to the correct physical 1788e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// subregister. 179ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen void updateRegDefsUses(unsigned SrcReg, unsigned DstReg, unsigned SubIdx); 1808e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1818e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// eliminateUndefCopy - Handle copies of undef values. 1828e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen bool eliminateUndefCopy(MachineInstr *CopyMI, const CoalescerPair &CP); 1838e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1848e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen public: 1858e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen static char ID; // Class identification, replacement for typeinfo 1868e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen RegisterCoalescer() : MachineFunctionPass(ID) { 1878e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen initializeRegisterCoalescerPass(*PassRegistry::getPassRegistry()); 1888e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen } 1898e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1908e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void getAnalysisUsage(AnalysisUsage &AU) const; 1918e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1928e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void releaseMemory(); 1938e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1948e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// runOnMachineFunction - pass entry point 1958e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual bool runOnMachineFunction(MachineFunction&); 1968e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1978e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// print - Implement the dump method. 1988e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void print(raw_ostream &O, const Module* = 0) const; 1998e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen }; 2008e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen} /// end anonymous namespace 2018e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 2028dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickchar &llvm::RegisterCoalescerID = RegisterCoalescer::ID; 20327215676c7114132a0374f7b5c9ea73d9354d329Jakob Stoklund Olesen 2045b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_BEGIN(RegisterCoalescer, "simple-register-coalescing", 2055b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 206655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(LiveIntervals) 207655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(SlotIndexes) 208655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(MachineLoopInfo) 209655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_AG_DEPENDENCY(AliasAnalysis) 2105b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_END(RegisterCoalescer, "simple-register-coalescing", 2115b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 212655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2132c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greenechar RegisterCoalescer::ID = 0; 2142c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 21500258d17cd7152237141648d26e1b096cf0e882bRafael Espindolastatic bool isMoveInstr(const TargetRegisterInfo &tri, const MachineInstr *MI, 21600258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &Src, unsigned &Dst, 21700258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &SrcSub, unsigned &DstSub) { 218273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen if (MI->isCopy()) { 219273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 220273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen DstSub = MI->getOperand(0).getSubReg(); 221273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Src = MI->getOperand(1).getReg(); 222273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen SrcSub = MI->getOperand(1).getSubReg(); 2235c00e077952d14899c3fc26709c7b2dfd36d0209Jakob Stoklund Olesen } else if (MI->isSubregToReg()) { 22440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 22521caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen DstSub = tri.composeSubRegIndices(MI->getOperand(0).getSubReg(), 22621caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen MI->getOperand(3).getImm()); 22740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Src = MI->getOperand(2).getReg(); 22840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen SrcSub = MI->getOperand(2).getSubReg(); 22904c528a0c86ddf3d6a70681f72e1b2ec07b0b53aJakob Stoklund Olesen } else 23040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 23140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 23240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 23340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2343c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// Return true if this block should be vacated by the coalescer to eliminate 2353c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// branches. The important cases to handle in the coalescer are critical edges 2363c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// split during phi elimination which contain only copies. Simple blocks that 2373c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// contain non-branches should also be vacated, but this can be handled by an 2383c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// earlier pass similar to early if-conversion. 2393c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trickstatic bool isSplitEdge(const MachineBasicBlock *MBB) { 2403c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick if (MBB->pred_size() != 1 || MBB->succ_size() != 1) 2413c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick return false; 2423c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 2433c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick for (MachineBasicBlock::const_iterator MII = MBB->begin(), E = MBB->end(); 2443c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick MII != E; ++MII) { 2452344abc939b29ab80bbd247995a0ceb2efa5938bAndrew Trick if (!MII->isCopyLike() && !MII->isUnconditionalBranch()) 24643736c7cfaea3b0c3e2660b9cd5c01e306f7c0dfAndrew Trick return false; 2473c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick } 2483c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick return true; 2493c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick} 2503c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 25140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::setRegisters(const MachineInstr *MI) { 25294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcReg = DstReg = 0; 25394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx = DstIdx = 0; 254c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen NewRC = 0; 255c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = CrossClass = false; 25640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 25740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen unsigned Src, Dst, SrcSub, DstSub; 258c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!isMoveInstr(TRI, MI, Src, Dst, SrcSub, DstSub)) 25940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 260c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Partial = SrcSub || DstSub; 26140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 26240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // If one register is a physreg, it must be Dst. 26340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Src)) { 26440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Dst)) 26540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 26640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 26740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(SrcSub, DstSub); 268c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = true; 26940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 27040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 27140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen const MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo(); 27240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 27340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Dst)) { 27440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Eliminate DstSub on a physreg. 27540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (DstSub) { 276c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getSubReg(Dst, DstSub); 27740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!Dst) return false; 27840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen DstSub = 0; 27940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 28040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 28140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Eliminate SrcSub by picking a corresponding Dst superregister. 28240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (SrcSub) { 283c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getMatchingSuperReg(Dst, SrcSub, MRI.getRegClass(Src)); 28440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!Dst) return false; 28540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen SrcSub = 0; 28640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else if (!MRI.getRegClass(Src)->contains(Dst)) { 28740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 28840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 28940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 29040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Both registers are virtual. 291defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *SrcRC = MRI.getRegClass(Src); 292defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *DstRC = MRI.getRegClass(Dst); 29340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2948df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen // Both registers have subreg indices. 2958df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen if (SrcSub && DstSub) { 296ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Copies between different sub-registers are never coalescable. 297ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (Src == Dst && SrcSub != DstSub) 298ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen return false; 299ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen 300defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen NewRC = TRI.getCommonSuperRegClass(SrcRC, SrcSub, DstRC, DstSub, 30194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx, DstIdx); 302defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen if (!NewRC) 3038df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen return false; 30494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (DstSub) { 30594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // SrcReg will be merged with a sub-register of DstReg. 30694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx = DstSub; 30794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(DstRC, SrcRC, DstSub); 30894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (SrcSub) { 30994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // DstReg will be merged with a sub-register of SrcReg. 31094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen DstIdx = SrcSub; 31194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(SrcRC, DstRC, SrcSub); 31294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else { 31394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // This is a straight copy without sub-registers. 31494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getCommonSubClass(DstRC, SrcRC); 3158df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen } 31640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 31794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // The combined constraint may be impossible to satisfy. 31894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (!NewRC) 31994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen return false; 32094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen 32194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // Prefer SrcReg to be a sub-register of DstReg. 32294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // FIXME: Coalescer should support subregs symmetrically. 32394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (DstIdx && !SrcIdx) { 32440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 32594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 32694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen Flipped = !Flipped; 32740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 32840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 329c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen CrossClass = NewRC != DstRC || NewRC != SrcRC; 33040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 33140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Check our invariants 33240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Src) && "Src must be virtual"); 33340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(!(TargetRegisterInfo::isPhysicalRegister(Dst) && DstSub) && 33440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen "Cannot have a physical SubIdx"); 335c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SrcReg = Src; 336c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DstReg = Dst; 33740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 33840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 33940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 34040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::flip() { 34194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) 34240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 343c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen std::swap(SrcReg, DstReg); 34494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 345c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = !Flipped; 34640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 34740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 34840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 34940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::isCoalescable(const MachineInstr *MI) const { 35040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!MI) 35140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen unsigned Src, Dst, SrcSub, DstSub; 353c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!isMoveInstr(TRI, MI, Src, Dst, SrcSub, DstSub)) 35440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 356c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Find the virtual register that is SrcReg. 357c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (Dst == SrcReg) { 35840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 35940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(SrcSub, DstSub); 360c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen } else if (Src != SrcReg) { 36140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 36340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 364c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Now check that Dst matches DstReg. 365c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { 36640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(Dst)) 36740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen assert(!DstIdx && !SrcIdx && "Inconsistent CoalescerPair state."); 36940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // DstSub could be set for a physreg from INSERT_SUBREG. 37040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (DstSub) 371c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getSubReg(Dst, DstSub); 37240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Full copy of Src. 37340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!SrcSub) 374c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return DstReg == Dst; 37540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // This is a partial register copy. Check that the parts match. 376c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return TRI.getSubReg(DstReg, SrcSub) == Dst; 37740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 378c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // DstReg is virtual. 379c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (DstReg != Dst) 38040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 38140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Registers match, do the subregisters line up? 38221caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen return TRI.composeSubRegIndices(SrcIdx, SrcSub) == 38321caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI.composeSubRegIndices(DstIdx, DstSub); 38440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 38540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 38640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 3875b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::getAnalysisUsage(AnalysisUsage &AU) const { 388655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.setPreservesCFG(); 389655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<AliasAnalysis>(); 390655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<LiveIntervals>(); 391655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<LiveIntervals>(); 392655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<SlotIndexes>(); 393655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<MachineLoopInfo>(); 394655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<MachineLoopInfo>(); 395655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreservedID(MachineDominatorsID); 396655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineFunctionPass::getAnalysisUsage(AU); 397655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 398655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 399bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesenvoid RegisterCoalescer::eliminateDeadDefs() { 400bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallVector<LiveInterval*, 8> NewRegs; 401bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen LiveRangeEdit(0, NewRegs, *MF, *LIS, 0, this).eliminateDeadDefs(DeadDefs); 402bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen} 403bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 404bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen// Callback from eliminateDeadDefs(). 405bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesenvoid RegisterCoalescer::LRE_WillEraseInstruction(MachineInstr *MI) { 406bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // MI may be in WorkList. Make sure we don't visit it. 407bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.insert(MI); 408bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen} 409bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 4109790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// adjustCopiesBackFrom - We found a non-trivially-coalescable copy with IntA 411655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// being the source and IntB being the dest, thus this defines a value number 412655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// in IntB. If the source value number (in IntA) is defined by a copy from B, 413655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// see if we can merge these two pieces of B into a single value number, 414655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// eliminating a copy. For example: 415655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 416655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// A3 = B0 417655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 418655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = A3 <- this copy 419655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 420655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// In this case, B0 can be extended to where the B1 copy lives, allowing the B1 421655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// value number to be replaced with B0 (which simplifies the B liveinterval). 422655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 423655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// This returns true if an interval was modified. 424655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 4259790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::adjustCopiesBackFrom(const CoalescerPair &CP, 4269790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 427141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen assert(!CP.isPartial() && "This doesn't work for partial copies."); 4280984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen assert(!CP.isPhys() && "This doesn't work for physreg copies."); 429141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen 430655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntA = 431c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg()); 432655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntB = 433c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg()); 4342debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(); 435655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 436655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo is a value number in B that is defined by a copy from A. 'B3' in 437655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // the example above. 438655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator BLR = IntB.FindLiveRangeContaining(CopyIdx); 439655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BLR == IntB.end()) return false; 440655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *BValNo = BLR->valno; 441655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 442655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the location that B is defined at. Two options: either this value has 443655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // an unknown definition point or it is defined at CopyIdx. If unknown, we 444655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // can't process it. 4453b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen if (BValNo->def != CopyIdx) return false; 446655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 447655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // AValNo is the value number in A that defines the copy, A3 in the example. 4482debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyUseIdx = CopyIdx.getRegSlot(true); 449655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ALR = IntA.FindLiveRangeContaining(CopyUseIdx); 450655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // The live range might not exist after fun with physreg coalescing. 451655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ALR == IntA.end()) return false; 452655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *AValNo = ALR->valno; 453655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 454655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If AValNo is defined as a copy from IntB, we can potentially process this. 455655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the instruction that defines this value number. 4563b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen MachineInstr *ACopyMI = LIS->getInstructionFromIndex(AValNo->def); 457573303e62a913ec881fde3434d7babed0bd4da33Jakob Stoklund Olesen // Don't allow any partial copies, even if isCoalescable() allows them. 458573303e62a913ec881fde3434d7babed0bd4da33Jakob Stoklund Olesen if (!CP.isCoalescable(ACopyMI) || !ACopyMI->isFullCopy()) 459655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 460655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 461655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the LiveRange in IntB that this value number starts with. 462655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ValLR = 463655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.FindLiveRangeContaining(AValNo->def.getPrevSlot()); 464655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ValLR == IntB.end()) 465655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 466655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 467655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure that the end of the live range is inside the same block as 468655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI. 469655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *ValLREndInst = 470c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInstructionFromIndex(ValLR->end.getPrevSlot()); 471655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!ValLREndInst || ValLREndInst->getParent() != CopyMI->getParent()) 472655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 473655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 474655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, we now know that ValLR ends in the same block that the CopyMI 475655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // live-range starts. If there are no intervening live ranges between them in 476655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // IntB, we can merge them. 477655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ValLR+1 != BLR) return false; 478655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 479b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << "Extending: " << PrintReg(IntB.reg, TRI)); 480655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 481655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola SlotIndex FillerStart = ValLR->end, FillerEnd = BLR->start; 482655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // We are about to delete CopyMI, so need to remove it as the 'instruction 483655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // that defines this value #'. Update the valnum with the new defining 484655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // instruction #. 4853b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen BValNo->def = FillerStart; 486655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 487655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, we can merge them. We need to insert a new liverange: 488655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // [ValLR.end, BLR.begin) of either value number, then we merge the 489655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // two value numbers. 490655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.addRange(LiveRange(FillerStart, FillerEnd, BValNo)); 491655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 492655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, merge "B1" into the same value number as "B0". 493bf60aa9db5953dd99c561dfa9323b1e3293a5a85Jakob Stoklund Olesen if (BValNo != ValLR->valno) 494655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.MergeValueNumberInto(BValNo, ValLR->valno); 495b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << " result = " << IntB << '\n'); 496655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 497655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If the source instruction was killing the source register before the 498655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // merge, unset the isKill marker given the live range has been extended. 499655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola int UIdx = ValLREndInst->findRegisterUseOperandIdx(IntB.reg, true); 500655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UIdx != -1) { 501655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ValLREndInst->getOperand(UIdx).setIsKill(false); 502655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 5038dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 5043b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // Rewrite the copy. If the copy instruction was killing the destination 5053b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // register before the merge, find the last use and trim the live range. That 5063b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // will also add the isKill marker. 507141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen CopyMI->substituteRegister(IntA.reg, IntB.reg, 0, *TRI); 508655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ALR->end == CopyIdx) 509c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->shrinkToUses(&IntA); 510655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 511655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numExtends; 512655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 513655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 514655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5159790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// hasOtherReachingDefs - Return true if there are definitions of IntB 5169b82d50d209adf915d3c7f871dc82cb73349db80Jakob Stoklund Olesen/// other than BValNo val# that can reach uses of AValno val# of IntA. 5179790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::hasOtherReachingDefs(LiveInterval &IntA, 5189790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen LiveInterval &IntB, 5199790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen VNInfo *AValNo, 5209790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen VNInfo *BValNo) { 5210ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen // If AValNo has PHI kills, conservatively assume that IntB defs can reach 5220ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen // the PHI values. 5230ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen if (LIS->hasPHIKill(IntA, AValNo)) 5240ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen return true; 5250ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen 526655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (LiveInterval::iterator AI = IntA.begin(), AE = IntA.end(); 527655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AI != AE; ++AI) { 5289b82d50d209adf915d3c7f871dc82cb73349db80Jakob Stoklund Olesen if (AI->valno != AValNo) continue; 529655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::Ranges::iterator BI = 530655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola std::upper_bound(IntB.ranges.begin(), IntB.ranges.end(), AI->start); 531655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI != IntB.ranges.begin()) 532655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola --BI; 533655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (; BI != IntB.ranges.end() && AI->end >= BI->start; ++BI) { 534655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->valno == BValNo) 535655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 536655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->start <= AI->start && BI->end > AI->start) 537655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 538655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->start > AI->start && BI->start < AI->end) 539655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 540655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 541655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 542655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 543655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 544655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5459790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// removeCopyByCommutingDef - We found a non-trivially-coalescable copy with 546655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// IntA being the source and IntB being the dest, thus this defines a value 547655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// number in IntB. If the source value number (in IntA) is defined by a 548655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// commutable instruction and its other operand is coalesced to the copy dest 549655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// register, see if we can transform the copy into a noop by commuting the 550655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// definition. For example, 551655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 552655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// A3 = op A2 B0<kill> 553655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 554655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = A3 <- this copy 555655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 556655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// = op A3 <- more uses 557655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 558655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ==> 559655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 560655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B2 = op B0 A2<kill> 561655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 562655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = B2 <- now an identify copy 563655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 564655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// = op B2 <- more uses 565655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 566655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// This returns true if an interval was modified. 567655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 5689790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::removeCopyByCommutingDef(const CoalescerPair &CP, 5699790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 5700984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen assert (!CP.isPhys()); 571655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5722debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(); 573655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 574655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntA = 575c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg()); 576655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntB = 577c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg()); 578655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 579655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo is a value number in B that is defined by a copy from A. 'B3' in 580655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // the example above. 581655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *BValNo = IntB.getVNInfoAt(CopyIdx); 5823b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen if (!BValNo || BValNo->def != CopyIdx) 583655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 584655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 585655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(BValNo->def == CopyIdx && "Copy doesn't define the value?"); 586655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 587655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // AValNo is the value number in A that defines the copy, A3 in the example. 5882debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *AValNo = IntA.getVNInfoAt(CopyIdx.getRegSlot(true)); 589655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(AValNo && "COPY source not live"); 5900ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen if (AValNo->isPHIDef() || AValNo->isUnused()) 591655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 592c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *DefMI = LIS->getInstructionFromIndex(AValNo->def); 593655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI) 594655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 5955a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!DefMI->isCommutable()) 596655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 597655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If DefMI is a two-address instruction then commuting it will change the 598655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // destination register. 599655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola int DefIdx = DefMI->findRegisterDefOperandIdx(IntA.reg); 600655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DefIdx != -1); 601655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned UseOpIdx; 602655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isRegTiedToUseOperand(DefIdx, &UseOpIdx)) 603655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 604655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned Op1, Op2, NewDstIdx; 605c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->findCommutedOpIndices(DefMI, Op1, Op2)) 606655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 607655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (Op1 == UseOpIdx) 608655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op2; 609655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else if (Op2 == UseOpIdx) 610655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op1; 611655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 612655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 613655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 614655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &NewDstMO = DefMI->getOperand(NewDstIdx); 615655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned NewReg = NewDstMO.getReg(); 616ab9baf7ff4b58b3905bccad68c8d2ab59ea4202bJakob Stoklund Olesen if (NewReg != IntB.reg || !LiveRangeQuery(IntB, AValNo->def).isKill()) 617655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 618655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 619655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure there are no other definitions of IntB that would reach the 620655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // uses which the new definition can reach. 6219790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (hasOtherReachingDefs(IntA, IntB, AValNo, BValNo)) 622655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 623655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 624655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If some of the uses of IntA.reg is already coalesced away, return false. 625655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // It's not possible to determine whether it's safe to perform the coalescing. 626b1afbac64b7c4c06959350acc175fb3552012f57Andrew Trick for (MachineRegisterInfo::use_nodbg_iterator UI = 627c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI->use_nodbg_begin(IntA.reg), 628c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UE = MRI->use_nodbg_end(); UI != UE; ++UI) { 629655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = &*UI; 630c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI); 631655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ULR = IntA.FindLiveRangeContaining(UseIdx); 63256366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen if (ULR == IntA.end() || ULR->valno != AValNo) 633655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 63456366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen // If this use is tied to a def, we can't rewrite the register. 63556366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen if (UseMI->isRegTiedToDefOperand(UI.getOperandNo())) 636655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 637655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 638655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 6399790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen DEBUG(dbgs() << "\tremoveCopyByCommutingDef: " << AValNo->def << '\t' 640655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola << *DefMI); 641655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 642655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // At this point we have decided that it is legal to do this 643655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // transformation. Start by commuting the instruction. 644655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = DefMI->getParent(); 645c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *NewMI = TII->commuteInstruction(DefMI); 646655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!NewMI) 647655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 648655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isVirtualRegister(IntA.reg) && 649655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola TargetRegisterInfo::isVirtualRegister(IntB.reg) && 650c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen !MRI->constrainRegClass(IntB.reg, MRI->getRegClass(IntA.reg))) 651655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 652655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (NewMI != DefMI) { 653c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->ReplaceMachineInstrInMaps(DefMI, NewMI); 6547c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MachineBasicBlock::iterator Pos = DefMI; 6557c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MBB->insert(Pos, NewMI); 656655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MBB->erase(DefMI); 657655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 658655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned OpIdx = NewMI->findRegisterUseOperandIdx(IntA.reg, false); 659655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewMI->getOperand(OpIdx).setIsKill(); 660655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 661655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If ALR and BLR overlaps and end of BLR extends beyond end of ALR, e.g. 662655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // A = or A, B 663655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 664655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // B = A 665655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 666655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // C = A<kill> 667655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 668655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // = B 669655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 670655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update uses of IntA of the specific Val# with IntB. 671c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(IntA.reg), 672c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UE = MRI->use_end(); UI != UE;) { 673655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &UseMO = UI.getOperand(); 674655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = &*UI; 675655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++UI; 676655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->isDebugValue()) { 677655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // FIXME These don't have an instruction index. Not clear we have enough 678655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // info to decide whether to do this replacement or not. For now do it. 679655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 680655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 681655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 6822debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI).getRegSlot(true); 683655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ULR = IntA.FindLiveRangeContaining(UseIdx); 684655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ULR == IntA.end() || ULR->valno != AValNo) 685655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 68634af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen // Kill flags are no longer accurate. They are recomputed after RA. 68734af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen UseMO.setIsKill(false); 688655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isPhysicalRegister(NewReg)) 689c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UseMO.substPhysReg(NewReg, *TRI); 690655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 691655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 692655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI == CopyMI) 693655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 694655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isCopy()) 695655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 696655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->getOperand(0).getReg() != IntB.reg || 697655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMI->getOperand(0).getSubReg()) 698655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 699655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 700655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // This copy will become a noop. If it's defining a new val#, merge it into 701655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo. 7022debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex DefIdx = UseIdx.getRegSlot(); 703655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *DVNI = IntB.getVNInfoAt(DefIdx); 704655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DVNI) 705655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 706655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\tnoop: " << DefIdx << '\t' << *UseMI); 707655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DVNI->def == DefIdx); 708655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola BValNo = IntB.MergeValueNumberInto(BValNo, DVNI); 709ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen ErasedInstrs.insert(UseMI); 710ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(UseMI); 711ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen UseMI->eraseFromParent(); 712655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 713655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 714655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Extend BValNo by merging in IntA live ranges of AValNo. Val# definition 715655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // is updated. 716655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *ValNo = BValNo; 717655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ValNo->def = AValNo->def; 718655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (LiveInterval::iterator AI = IntA.begin(), AE = IntA.end(); 719655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AI != AE; ++AI) { 720655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (AI->valno != AValNo) continue; 721655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.addRange(LiveRange(AI->start, AI->end, ValNo)); 722655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 723655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\textended: " << IntB << '\n'); 724655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 725655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntA.removeValNo(AValNo); 726655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\ttrimmed: " << IntA << '\n'); 727655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCommutes; 728655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 729655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 730655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 7319790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// reMaterializeTrivialDef - If the source of a copy is defined by a trivial 732655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// computation, replace the copy by rematerialize the definition. 7331d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarichbool RegisterCoalescer::reMaterializeTrivialDef(CoalescerPair &CP, 7349790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 7351d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned SrcReg = CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg(); 7361d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned DstReg = CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg(); 7371d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (TargetRegisterInfo::isPhysicalRegister(SrcReg)) 7381d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich return false; 7391d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich 7401d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich LiveInterval &SrcInt = LIS->getInterval(SrcReg); 7412debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(true); 742655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator SrcLR = SrcInt.FindLiveRangeContaining(CopyIdx); 743655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(SrcLR != SrcInt.end() && "Live range not found!"); 744655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *ValNo = SrcLR->valno; 7454ea24e993f179113a9bb76ee152cc490e738c936Jakob Stoklund Olesen if (ValNo->isPHIDef() || ValNo->isUnused()) 746655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 747c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *DefMI = LIS->getInstructionFromIndex(ValNo->def); 748655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI) 749655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 750655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DefMI && "Defining instruction disappeared"); 7515a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!DefMI->isAsCheapAsAMove()) 752655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 753c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->isTriviallyReMaterializable(DefMI, AA)) 754655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 755655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool SawStore = false; 756c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!DefMI->isSafeToMove(TII, AA, SawStore)) 757655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 7585a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng const MCInstrDesc &MCID = DefMI->getDesc(); 759e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MCID.getNumDefs() != 1) 760655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 761c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // Only support subregister destinations when the def is read-undef. 762c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich MachineOperand &DstOperand = CopyMI->getOperand(0); 763c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich if (DstOperand.getSubReg() && !DstOperand.isUndef()) 764c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich return false; 765655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isImplicitDef()) { 766655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure the copy destination register class fits the instruction 767655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // definition register class. The mismatch can happen as a result of earlier 768655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // extract_subreg, insert_subreg, subreg_to_reg coalescing. 769397fc4874efe9c17e737d4c5c50bd19dc3bf27f5Jakob Stoklund Olesen const TargetRegisterClass *RC = TII->getRegClass(MCID, 0, TRI, *MF); 770655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isVirtualRegister(DstReg)) { 7711f258a6d53b29f6dfb60436da4aa76e996644d84Cameron Zwarich if (!MRI->constrainRegClass(DstReg, RC)) 772655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 773655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } else if (!RC->contains(DstReg)) 774655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 775655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 776655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 777655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = CopyMI->getParent(); 778655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock::iterator MII = 779655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola llvm::next(MachineBasicBlock::iterator(CopyMI)); 7806e39290baf236020f130d8695f7624004706bb08Jakob Stoklund Olesen TII->reMaterialize(*MBB, MII, DstReg, 0, DefMI, *TRI); 781655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *NewMI = prior(MII); 782655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 783c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // The original DefMI may have been a subregister def, but the full register 784c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // class of its destination matches the destination of CopyMI, and CopyMI is 785c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // either a full register def or is read-undef. Therefore we can clear the 786c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // subregister index on the rematerialized instruction. 787c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich NewMI->getOperand(0).setSubReg(0); 788c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich 789eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI may have dead implicit defs (E.g. EFLAGS for MOV<bits>r0 on X86). 790eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // We need to remember these so we can add intervals once we insert 791eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI into SlotIndexes. 792eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SmallVector<unsigned, 4> NewMIImplDefs; 793eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = NewMI->getDesc().getNumOperands(), 794eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames e = NewMI->getNumOperands(); i != e; ++i) { 795eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames MachineOperand &MO = NewMI->getOperand(i); 796eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames if (MO.isReg()) { 797275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isDef() && MO.isImplicit() && MO.isDead() && 798275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames TargetRegisterInfo::isPhysicalRegister(MO.getReg())); 799eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames NewMIImplDefs.push_back(MO.getReg()); 800eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 801eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 802eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 803655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI may have implicit operands, transfer them over to the newly 804655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerialized instruction. And update implicit def interval valnos. 805655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = CopyMI->getDesc().getNumOperands(), 806655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola e = CopyMI->getNumOperands(); i != e; ++i) { 807655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = CopyMI->getOperand(i); 808275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (MO.isReg()) { 809275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isImplicit() && "No explicit operands after implict operands."); 810275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames // Discard VReg implicit defs. 811275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) { 812275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames NewMI->addOperand(MO); 813275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 814275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 815655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 816655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 817c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->ReplaceMachineInstrInMaps(CopyMI, NewMI); 818eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 819eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI); 820eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = 0, e = NewMIImplDefs.size(); i != e; ++i) { 82171b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen unsigned Reg = NewMIImplDefs[i]; 82271b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen for (MCRegUnitIterator Units(Reg, TRI); Units.isValid(); ++Units) 82371b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen if (LiveInterval *LI = LIS->getCachedRegUnit(*Units)) 82471b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen LI->createDeadDef(NewMIIdx.getRegSlot(), LIS->getVNInfoAllocator()); 825eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 826eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 827655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola CopyMI->eraseFromParent(); 828bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.insert(CopyMI); 829655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "Remat: " << *NewMI); 830655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++NumReMats; 831655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 832655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // The source interval can become smaller because we removed a use. 8331dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen LIS->shrinkToUses(&SrcInt, &DeadDefs); 8341dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen if (!DeadDefs.empty()) 8351dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen eliminateDeadDefs(); 836655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 837655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 838655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 839655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 840e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// eliminateUndefCopy - ProcessImpicitDefs may leave some copies of <undef> 841e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// values, it only removes local variables. When we have a copy like: 842e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 843e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// %vreg1 = COPY %vreg2<undef> 844e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 845e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// We delete the copy and remove the corresponding value number from %vreg1. 846e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// Any uses of that value number are marked as <undef>. 847e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesenbool RegisterCoalescer::eliminateUndefCopy(MachineInstr *CopyMI, 848e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen const CoalescerPair &CP) { 849c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(CopyMI); 850c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *SrcInt = &LIS->getInterval(CP.getSrcReg()); 851e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (SrcInt->liveAt(Idx)) 852e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 853c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *DstInt = &LIS->getInterval(CP.getDstReg()); 854e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 855e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 856e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 857e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // No intervals are live-in to CopyMI - it is undef. 858e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (CP.isFlipped()) 859e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt = SrcInt; 860e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen SrcInt = 0; 861e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 8622debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *DeadVNI = DstInt->getVNInfoAt(Idx.getRegSlot()); 863e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen assert(DeadVNI && "No value defined in DstInt"); 864e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt->removeValNo(DeadVNI); 865e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 866e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // Find new undef uses. 867e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen for (MachineRegisterInfo::reg_nodbg_iterator 868c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen I = MRI->reg_nodbg_begin(DstInt->reg), E = MRI->reg_nodbg_end(); 869e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen I != E; ++I) { 870e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MachineOperand &MO = I.getOperand(); 871e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (MO.isDef() || MO.isUndef()) 872e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 873e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MachineInstr *MI = MO.getParent(); 874c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(MI); 875e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 876e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 877e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MO.setIsUndef(true); 878e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DEBUG(dbgs() << "\tnew undef: " << Idx << '\t' << *MI); 879e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 880e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return true; 881e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen} 882e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 8839790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 884655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// update the subregister number if it is not zero. If DstReg is a 885655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// physical register and the existing subregister number of the def / use 886655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// being updated is not zero, make sure to set it to the correct physical 887655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// subregister. 888ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesenvoid RegisterCoalescer::updateRegDefsUses(unsigned SrcReg, 889ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned DstReg, 890ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned SubIdx) { 891ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen bool DstIsPhys = TargetRegisterInfo::isPhysicalRegister(DstReg); 892324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen LiveInterval *DstInt = DstIsPhys ? 0 : &LIS->getInterval(DstReg); 893655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 89489bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen SmallPtrSet<MachineInstr*, 8> Visited; 895c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen for (MachineRegisterInfo::reg_iterator I = MRI->reg_begin(SrcReg); 896655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = I.skipInstruction();) { 89789bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // Each instruction can only be rewritten once because sub-register 89889bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // composition is not always idempotent. When SrcReg != DstReg, rewriting 89989bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // the UseMI operands removes them from the SrcReg use-def chain, but when 90089bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // SrcReg is DstReg we could encounter UseMI twice if it has multiple 90189bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // operands mentioning the virtual register. 90289bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen if (SrcReg == DstReg && !Visited.insert(UseMI)) 90389bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen continue; 90489bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen 905655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola SmallVector<unsigned,8> Ops; 906655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool Reads, Writes; 907655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola tie(Reads, Writes) = UseMI->readsWritesVirtualRegister(SrcReg, &Ops); 908655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 90907a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // If SrcReg wasn't read, it may still be the case that DstReg is live-in 91007a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // because SrcReg is a sub-register. 911324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen if (DstInt && !Reads && SubIdx) 912324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen Reads = DstInt->liveAt(LIS->getInstructionIndex(UseMI)); 91307a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen 914655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Replace SrcReg with DstReg in all UseMI operands. 915655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = 0, e = Ops.size(); i != e; ++i) { 916655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = UseMI->getOperand(Ops[i]); 917655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 91807a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // Adjust <undef> flags in case of sub-register joins. We don't want to 91907a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // turn a full def into a read-modify-write sub-register def and vice 92007a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // versa. 921ec096b492549d625e4be608fcaea265b96dabc03Jakob Stoklund Olesen if (SubIdx && MO.isDef()) 92207a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen MO.setIsUndef(!Reads); 923b077cf338bd85a6a7397ec88d65278f02f0ed06fJakob Stoklund Olesen 924655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (DstIsPhys) 925c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substPhysReg(DstReg, *TRI); 926655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 927c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substVirtReg(DstReg, SubIdx, *TRI); 928655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 929655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 930655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG({ 931655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << "\t\tupdated: "; 932655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isDebugValue()) 933c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen dbgs() << LIS->getInstructionIndex(UseMI) << "\t"; 934655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << *UseMI; 935655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola }); 936655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 937655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 938655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 93934a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen/// canJoinPhys - Return true if a copy involving a physreg should be joined. 94039c71da6db9f52cf48430282a27384563a77793eJakub Staszakbool RegisterCoalescer::canJoinPhys(const CoalescerPair &CP) { 941655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// Always join simple intervals that are defined by a single copy from a 942655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// reserved register. This doesn't increase register pressure, so it is 943655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// always beneficial. 94414d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen if (!MRI->isReserved(CP.getDstReg())) { 94534a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCan only merge into reserved registers.\n"); 946655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 947655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 948655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 94934a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen LiveInterval &JoinVInt = LIS->getInterval(CP.getSrcReg()); 95034a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (CP.isFlipped() && JoinVInt.containsOneValue()) 95134a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return true; 952655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 95334a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCannot join defs into reserved register.\n"); 95434a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return false; 955655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 956655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 9579790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, 958655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// which are the src/dst of the copy instruction CopyMI. This returns true 959655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// if the copy was successfully coalesced away. If it is not currently 960655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// possible to coalesce this interval, but it may be possible if other 961655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// things get coalesced, then it returns true by reference in 'Again'. 9629790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinCopy(MachineInstr *CopyMI, bool &Again) { 963655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 964655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = false; 965c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DEBUG(dbgs() << LIS->getInstructionIndex(CopyMI) << '\t' << *CopyMI); 966655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 967a7542d5f870c5d98960d1676e23ac1d1d975d7e5Benjamin Kramer CoalescerPair CP(*TRI); 968655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!CP.setRegisters(CopyMI)) { 969655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tNot coalescable.\n"); 970655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 971655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 972655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 973bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Dead code elimination. This really should be handled by MachineDCE, but 974bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // sometimes dead copies slip through, and we can't generate invalid live 975bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // ranges. 976bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen if (!CP.isPhys() && CopyMI->allDefsAreDead()) { 977bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy is dead.\n"); 978bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.push_back(CopyMI); 979bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen eliminateDeadDefs(); 980bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen return true; 981bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 982bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 983e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Eliminate undefs. 984e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (!CP.isPhys() && eliminateUndefCopy(CopyMI, CP)) { 985e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tEliminated copy of <undef> value.\n"); 9863662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 9873662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 988655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; // Not coalescable. 989655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 990655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 991e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Coalesced copies are normally removed immediately, but transformations 992e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // like removeCopyByCommutingDef() can inadvertently create identity copies. 993e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // When that happens, just join the values and remove the copy. 994e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (CP.getSrcReg() == CP.getDstReg()) { 995e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LiveInterval &LI = LIS->getInterval(CP.getSrcReg()); 996e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy already coalesced: " << LI << '\n'); 997e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LiveRangeQuery LRQ(LI, LIS->getInstructionIndex(CopyMI)); 998e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (VNInfo *DefVNI = LRQ.valueDefined()) { 999e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen VNInfo *ReadVNI = LRQ.valueIn(); 1000e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI && "No value before copy and no <undef> flag."); 1001e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI != DefVNI && "Cannot read and define the same value."); 1002e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LI.MergeValueNumberInto(DefVNI, ReadVNI); 1003e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tMerged values: " << LI << '\n'); 1004e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen } 10053662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 10063662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1007e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen return true; 1008e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 1009e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 1010655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Enforce policies. 1011655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isPhys()) { 1012ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen DEBUG(dbgs() << "\tConsidering merging " << PrintReg(CP.getSrcReg(), TRI) 1013ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with " << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) 1014ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << '\n'); 101534a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (!canJoinPhys(CP)) { 1016655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Before giving up coalescing, if definition of source is defined by 1017655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // trivial computation, try rematerializing it. 10181d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (reMaterializeTrivialDef(CP, CopyMI)) 1019655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1020655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1021655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1022655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } else { 102340a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen DEBUG({ 1024ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << "\tConsidering merging to " << CP.getNewRC()->getName() 1025ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with "; 1026ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx() && CP.getSrcIdx()) 1027ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getDstReg()) << " in " 1028ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getDstIdx()) << " and " 1029ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getSrcReg()) << " in " 1030ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getSrcIdx()) << '\n'; 1031ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen else 1032ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getSrcReg(), TRI) << " in " 1033ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) << '\n'; 103440a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen }); 1035655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1036655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // When possible, let DstReg be the larger interval. 1037ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (!CP.isPartial() && LIS->getInterval(CP.getSrcReg()).ranges.size() > 1038c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.getDstReg()).ranges.size()) 1039655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola CP.flip(); 1040655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1041655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1042655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, attempt to join these two intervals. On failure, this returns false. 1043655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, if one of the intervals being joined is a physreg, this method 1044655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // always canonicalizes DstInt to be it. The output "SrcInt" will not have 1045655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // been modified, so we can use this information below to update aliases. 10469790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (!joinIntervals(CP)) { 1047655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing failed. 1048655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1049655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If definition of source is defined by trivial computation, try 1050655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerializing it. 10511d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (reMaterializeTrivialDef(CP, CopyMI)) 1052655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1053655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1054655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If we can eliminate the copy without merging the live ranges, do so now. 10550984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen if (!CP.isPartial() && !CP.isPhys()) { 10569790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (adjustCopiesBackFrom(CP, CopyMI) || 10579790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen removeCopyByCommutingDef(CP, CopyMI)) { 1058ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1059ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen CopyMI->eraseFromParent(); 1060655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tTrivial!\n"); 1061655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1062655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1063655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1064655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1065655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, we are unable to join the intervals. 1066655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tInterference!\n"); 1067655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = true; // May be possible to coalesce later. 1068655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1069655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1070655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1071655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing to a virtual register that is of a sub-register class of the 1072655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // other. Make sure the resulting register is set to the right register class. 1073655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isCrossClass()) { 1074655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCrossRCs; 1075c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI->setRegClass(CP.getDstReg(), CP.getNewRC()); 1076655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1077655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 107803c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register copies can ease the register class constraints. 107903c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Make sure we attempt to inflate the register class of DstReg. 108003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen if (!CP.isPhys() && RegClassInfo.isProperSubClass(CP.getNewRC())) 108103c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.push_back(CP.getDstReg()); 108203c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen 10837ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // CopyMI has been erased by joinIntervals at this point. Remove it from 10847ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // ErasedInstrs since copyCoalesceWorkList() won't add a successful join back 10857ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // to the work list. This keeps ErasedInstrs from growing needlessly. 10867ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen ErasedInstrs.erase(CopyMI); 1087655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1088ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Rewrite all SrcReg operands to DstReg. 1089ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Also update DstReg operands to include DstIdx if it is set. 1090ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx()) 1091ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getDstReg(), CP.getDstReg(), CP.getDstIdx()); 1092ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getSrcReg(), CP.getDstReg(), CP.getSrcIdx()); 1093655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1094e02a17c4efb843b8627f3d819c62f88a7f2fb457Lang Hames // SrcReg is guaranteed to be the register whose live interval that is 1095655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // being merged. 1096c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->removeInterval(CP.getSrcReg()); 1097655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1098655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update regalloc hint. 1099c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI->UpdateRegAllocHint(CP.getSrcReg(), CP.getDstReg(), *MF); 1100655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 110104ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen DEBUG({ 110204ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << "\tJoined. Result = " << PrintReg(CP.getDstReg(), TRI); 110304ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen if (!CP.isPhys()) 110404ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << LIS->getInterval(CP.getDstReg()); 110504ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << '\n'; 110604ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen }); 1107655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1108655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numJoins; 1109655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1110655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1111655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 111292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen/// Attempt joining with a reserved physreg. 111392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesenbool RegisterCoalescer::joinReservedPhysReg(CoalescerPair &CP) { 111492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isPhys() && "Must be a physreg copy"); 111514d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen assert(MRI->isReserved(CP.getDstReg()) && "Not a reserved register"); 111692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 1117b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << "\t\tRHS = " << PrintReg(CP.getSrcReg()) << ' ' << RHS 1118b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen << '\n'); 111992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 112092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isFlipped() && RHS.containsOneValue() && 112192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen "Invalid join with reserved register"); 112292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 112392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Optimization for reserved registers like ESP. We can only merge with a 112492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved physreg if RHS has a single value that is a copy of CP.DstReg(). 112592ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // The live range of the reserved register will look like a set of dead defs 112692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // - we don't properly track the live range of reserved registers. 112792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 112892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Deny any overlapping intervals. This depends on all the reserved 112992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live ranges to look like dead defs. 1130241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen for (MCRegUnitIterator UI(CP.getDstReg(), TRI); UI.isValid(); ++UI) 1131241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen if (RHS.overlaps(LIS->getRegUnit(*UI))) { 1132241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tInterference: " << PrintRegUnit(*UI, TRI) << '\n'); 1133241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen return false; 113492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen } 1135241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen 113692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Skip any value computations, we are not adding new values to the 113792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved register. Also skip merging the live ranges, the reserved 113892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live range doesn't need to be accurate as long as all the 113992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // defs are there. 1140857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 1141e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen // Delete the identity copy. 1142e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen MachineInstr *CopyMI = MRI->getVRegDef(RHS.reg); 1143e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1144e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1145e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen 1146857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen // We don't track kills for reserved registers. 1147857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen MRI->clearKillFlags(CP.getSrcReg()); 1148857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 114992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen return true; 115092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen} 115192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 1152c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1153c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// Interference checking and interval joining 1154c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1155c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1156c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// In the easiest case, the two live ranges being joined are disjoint, and 1157c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// there is no interference to consider. It is quite common, though, to have 1158c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping live ranges, and we need to check if the interference can be 1159c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// resolved. 1160c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1161c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of a single SSA value forms a sub-tree of the dominator tree. 1162c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This means that two SSA values overlap if and only if the def of one value 1163c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is contained in the live range of the other value. As a special case, the 1164c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping values can be defined at the same index. 1165c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1166c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The interference from an overlapping def can be resolved in these cases: 1167c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1168c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1. Coalescable copies. The value is defined by a copy that would become an 1169c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// identity copy after joining SrcReg and DstReg. The copy instruction will 1170c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// be removed, and the value will be merged with the source value. 1171c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1172c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// There can be several copies back and forth, causing many values to be 1173c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merged into one. We compute a list of ultimate values in the joined live 1174c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// range as well as a mappings from the old value numbers. 1175c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1176c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 2. IMPLICIT_DEF. This instruction is only inserted to ensure all PHI 1177c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// predecessors have a live out value. It doesn't cause real interference, 1178c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// and can be merged into the value it overlaps. Like a coalescable copy, it 1179c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// can be erased after joining. 1180c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1181c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 3. Copy of external value. The overlapping def may be a copy of a value that 1182c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is already in the other register. This is like a coalescable copy, but 1183c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// the live range of the source register must be trimmed after erasing the 1184c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// copy instruction: 1185c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1186c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = COPY %ext 1187c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst = COPY %ext <-- Remove this COPY, trim the live range of %ext. 1188c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1189c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 4. Clobbering undefined lanes. Vector registers are sometimes built by 1190c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// defining one lane at a time: 1191c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1192c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub0<def,read-undef> = FOO 1193c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1194c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1195c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1196c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of %src overlaps the %dst value defined by FOO, but 1197c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merging %src into %dst:ssub1 is only going to clobber the ssub1 lane 1198c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// which was undef anyway. 1199c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1200c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The value mapping is more complicated in this case. The final live range 1201c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// will have different value numbers for both FOO and BAR, but there is no 1202c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// simple mapping from old to new values. It may even be necessary to add 1203c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// new PHI values. 1204c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1205c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 5. Clobbering dead lanes. A def may clobber a lane of a vector register that 1206c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is live, but never read. This can happen because we don't compute 1207c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// individual live ranges per lane. 1208c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1209c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst<def> = FOO 1210c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1211c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1212c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1213c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This kind of interference is only resolved locally. If the clobbered 1214c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// lane value escapes the block, the join is aborted. 1215c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1216c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesennamespace { 1217c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Track information about values in a single virtual register about to be 1218c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// joined. Objects of this class are always created in pairs - one for each 1219c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// side of the CoalescerPair. 1220c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenclass JoinVals { 1221c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LI; 1222c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1223c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Location of this register in the final joined register. 1224c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Either CP.DstIdx or CP.SrcIdx. 1225c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned SubIdx; 1226c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1227c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Values that will be present in the final live range. 1228c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &NewVNInfo; 1229c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1230c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &CP; 1231c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *LIS; 1232c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndexes *Indexes; 1233c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *TRI; 1234c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1235c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value number assignments. Maps value numbers in LI to entries in NewVNInfo. 1236c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is suitable for passing to LiveInterval::join(). 1237c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<int, 8> Assignments; 1238c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1239c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conflict resolution for overlapping values. 1240c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen enum ConflictResolution { 1241c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, simply keep this value. 1242c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Keep, 1243c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1244c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI and erase the defining instruction. 1245c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used for IMPLICIT_DEF, coalescable copies, and copies from external 1246c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values. 1247c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Erase, 1248c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1249c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI but keep the defining instruction. 1250c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is for the special case where OtherVNI is defined by the same 1251c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // instruction. 1252c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Merge, 1253c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1254c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, and have it replace OtherVNI where possible. This 1255c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // complicates value mapping since OtherVNI maps to two different values 1256c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // before and after this def. 1257c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used when clobbering undefined or dead lanes. 1258c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Replace, 1259c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1260c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolved conflict. Visit later when all values have been mapped. 1261c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Unresolved, 1262c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1263c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolvable conflict. Abort the join. 1264c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Impossible 1265c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1266c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1267c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Per-value info for LI. The lane bit masks are all relative to the final 1268c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // joined register, so they can be compared directly between SrcReg and 1269c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // DstReg. 1270c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen struct Val { 1271c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution Resolution; 1272c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1273c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes written by this def, 0 for unanalyzed values. 1274c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned WriteLanes; 1275c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1276c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes with defined values in this register. Other lanes are undef and 1277c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // safe to clobber. 1278c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned ValidLanes; 1279c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1280c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in LI being redefined by this def. 1281c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *RedefVNI; 1282c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1283c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in the other live range that overlaps this def, if any. 1284c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *OtherVNI; 1285c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1286251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Is this value an IMPLICIT_DEF that can be erased? 1287251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1288251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF values should only exist at the end of a basic block that 1289251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // is a predecessor to a phi-value. These IMPLICIT_DEF instructions can be 1290251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // safely erased if they are overlapping a live value in the other live 1291251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // interval. 1292251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1293251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Weird control flow graphs and incomplete PHI handling in 1294251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // ProcessImplicitDefs can very rarely create IMPLICIT_DEF values with 1295251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // longer live ranges. Such IMPLICIT_DEF values should be treated like 1296251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // normal values. 1297251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool ErasableImplicitDef; 1298795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 12992df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True when the live range of this value will be pruned because of an 13002df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // overlapping CR_Replace value in the other live range. 13012df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool Pruned; 13022df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 13032df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True once Pruned above has been computed. 13042df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool PrunedComputed; 13052df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 1306c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val() : Resolution(CR_Keep), WriteLanes(0), ValidLanes(0), 1307251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen RedefVNI(0), OtherVNI(0), ErasableImplicitDef(false), 1308251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Pruned(false), PrunedComputed(false) {} 1309c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1310c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool isAnalyzed() const { return WriteLanes != 0; } 1311c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1312c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1313c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One entry per value number in LI. 1314c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<Val, 8> Vals; 1315c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1316c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned computeWriteLanes(const MachineInstr *DefMI, bool &Redef); 1317c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *stripCopies(VNInfo *VNI); 1318c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution analyzeValue(unsigned ValNo, JoinVals &Other); 1319c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void computeAssignment(unsigned ValNo, JoinVals &Other); 1320d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool taintExtent(unsigned, unsigned, JoinVals&, 1321d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> >&); 1322d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool usesLanes(MachineInstr *MI, unsigned, unsigned, unsigned); 13232df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool isPrunedValue(unsigned ValNo, JoinVals &Other); 1324c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1325c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenpublic: 1326c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals(LiveInterval &li, unsigned subIdx, 1327c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &newVNInfo, 1328c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &cp, 1329c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *lis, 1330c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *tri) 1331c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen : LI(li), SubIdx(subIdx), NewVNInfo(newVNInfo), CP(cp), LIS(lis), 1332c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Indexes(LIS->getSlotIndexes()), TRI(tri), 1333c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments(LI.getNumValNums(), -1), Vals(LI.getNumValNums()) 1334c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen {} 1335c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1336c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Analyze defs in LI and compute a value mapping in NewVNInfo. 1337c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1338c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool mapValues(JoinVals &Other); 1339c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1340c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Try to resolve conflicts that require all values to be mapped. 1341c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1342c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool resolveConflicts(JoinVals &Other); 1343c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 134487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// Prune the live range of values in Other.LI where they would conflict with 134587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// CR_Replace values in LI. Collect end points for restoring the live range 134687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// after joining. 134787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen void pruneValues(JoinVals &Other, SmallVectorImpl<SlotIndex> &EndPoints); 134887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1349c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Erase any machine instructions that have been coalesced away. 1350c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add erased instructions to ErasedInstrs. 1351c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add foreign virtual registers to ShrinkRegs if their live range ended at 1352c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// the erased instrs. 1353c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1354c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs); 1355c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1356c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Get the value assignments suitable for passing to LiveInterval::join. 135756acf63e35440068935bca999d19a81f76e876d6Jakob Stoklund Olesen const int *getAssignments() const { return Assignments.data(); } 1358c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen}; 1359c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} // end anonymous namespace 1360c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1361c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the bitmask of lanes actually written by DefMI. 1362c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Set Redef if there are any partial register definitions that depend on the 1363c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// previous value of the register. 1364c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenunsigned JoinVals::computeWriteLanes(const MachineInstr *DefMI, bool &Redef) { 1365c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned L = 0; 1366c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (ConstMIOperands MO(DefMI); MO.isValid(); ++MO) { 1367c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MO->isReg() || MO->getReg() != LI.reg || !MO->isDef()) 1368c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 136921caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen L |= TRI->getSubRegIndexLaneMask( 137021caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg())); 1371c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (MO->readsReg()) 1372c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Redef = true; 1373c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1374c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return L; 1375c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1376c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1377c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Find the ultimate value that VNI was copied from. 1378c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenVNInfo *JoinVals::stripCopies(VNInfo *VNI) { 1379c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!VNI->isPHIDef()) { 1380c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(VNI->def); 1381c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(MI && "No defining instruction"); 1382c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MI->isFullCopy()) 1383c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1384c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1385c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 1386c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1387c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveRangeQuery LRQ(LIS->getInterval(Reg), VNI->def); 1388c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LRQ.valueIn()) 1389c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1390c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNI = LRQ.valueIn(); 1391c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1392c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return VNI; 1393c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1394c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1395c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Analyze ValNo in this live range, and set all fields of Vals[ValNo]. 1396c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Return a conflict resolution when possible, but leave the hard cases as 1397c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// CR_Unresolved. 1398c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Recursively calls computeAssignment() on this and Other, guaranteeing that 1399c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// both OtherVNI and RedefVNI have been analyzed and mapped before returning. 1400c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// The recursion always goes upwards in the dominator tree, making loops 1401c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// impossible. 1402c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::ConflictResolution 1403c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::analyzeValue(unsigned ValNo, JoinVals &Other) { 1404c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1405c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!V.isAnalyzed() && "Value has already been analyzed!"); 1406c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1407c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isUnused()) { 1408c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.WriteLanes = ~0u; 1409c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1410c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1411c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1412c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Get the instruction defining this value, compute the lanes written. 1413c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const MachineInstr *DefMI = 0; 1414c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) { 1415c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conservatively assume that all lanes in a PHI are valid. 1416c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = TRI->getSubRegIndexLaneMask(SubIdx); 1417c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } else { 1418c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DefMI = Indexes->getInstructionFromIndex(VNI->def); 1419c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool Redef = false; 1420c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = computeWriteLanes(DefMI, Redef); 1421c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1422c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // If this is a read-modify-write instruction, there may be more valid 1423c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // lanes than the ones written by this instruction. 1424c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This only covers partial redef operands. DefMI may have normal use 1425c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // operands reading the register. They don't contribute valid lanes. 1426c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1427c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This adds ssub1 to the set of valid lanes in %src: 1428c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1429c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def> = FOO 1430c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1431c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This leaves only ssub1 valid, making any other lanes undef: 1432c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1433c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def,read-undef> = FOO %src:ssub2 1434c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1435c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The <read-undef> flag on the def operand means that old lane values are 1436c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // not important. 1437c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Redef) { 1438c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.RedefVNI = LiveRangeQuery(LI, VNI->def).valueIn(); 1439c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.RedefVNI && "Instruction is reading nonexistent value"); 1440c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(V.RedefVNI->id, Other); 1441c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes |= Vals[V.RedefVNI->id].ValidLanes; 1442c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1443c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1444c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // An IMPLICIT_DEF writes undef values. 1445795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (DefMI->isImplicitDef()) { 1446251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // We normally expect IMPLICIT_DEF values to be live only until the end 1447251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // of their block. If the value is really live longer and gets pruned in 1448251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // another block, this flag is cleared again. 1449251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen V.ErasableImplicitDef = true; 1450c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes; 1451795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1452c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1453c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1454c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Find the value in Other that overlaps VNI->def, if any. 1455c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveRangeQuery OtherLRQ(Other.LI, VNI->def); 1456c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1457c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // It is possible that both values are defined by the same instruction, or 1458c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // the values are PHIs defined in the same block. When that happens, the two 1459c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values should be merged into one, but not into any preceding value. 1460c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The first value defined or visited gets CR_Keep, the other gets CR_Merge. 1461c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNInfo *OtherVNI = OtherLRQ.valueDefined()) { 1462c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ"); 1463c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1464c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One value stays, the other is merged. Keep the earlier one, or the first 1465c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // one we see. 1466c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherVNI->def < VNI->def) 1467c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(OtherVNI->id, *this); 1468c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else if (VNI->def < OtherVNI->def && OtherLRQ.valueIn()) { 1469c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is an early-clobber def overlapping a live-in value in the other 1470c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // register. Not mergeable. 1471c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1472c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Impossible; 1473c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1474c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherVNI; 1475c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &OtherV = Other.Vals[OtherVNI->id]; 1476c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, check for conflicts when analyzing OtherVNI. 1477c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!OtherV.isAnalyzed()) 1478c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1479e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Both sides have been analyzed now. 1480e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1481e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1482e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen if (VNI->isPHIDef()) 1483e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Merge; 1484c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.ValidLanes & OtherV.ValidLanes) 1485d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Overlapping lanes can't be resolved. 1486d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1487c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else 1488c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Merge; 1489c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1490c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1491c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No simultaneous def. Is Other live at the def? 1492c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1493c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!V.OtherVNI) 1494c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, no conflict. 1495c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1496c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1497c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ"); 1498c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1499c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // We have overlapping values, or possibly a kill of Other. 1500c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursively compute assignments up the dominator tree. 1501c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(V.OtherVNI->id, *this); 1502251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Val &OtherV = Other.Vals[V.OtherVNI->id]; 1503251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen 1504251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Check if OtherV is an IMPLICIT_DEF that extends beyond its basic block. 1505251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // This shouldn't normally happen, but ProcessImplicitDefs can leave such 1506251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF instructions behind, and there is nothing wrong with it 1507251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // technically. 1508251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1509251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // WHen it happens, treat that IMPLICIT_DEF as a normal value, and don't try 1510251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // to erase the IMPLICIT_DEF instruction. 1511251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (OtherV.ErasableImplicitDef && DefMI && 1512251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DefMI->getParent() != Indexes->getMBBFromIndex(V.OtherVNI->def)) { 1513251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DEBUG(dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def 1514251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << " extends into BB#" << DefMI->getParent()->getNumber() 1515251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << ", keeping it.\n"); 1516251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.ErasableImplicitDef = false; 1517251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen } 1518c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1519e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1520e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1521c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) 1522e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Replace; 1523c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1524c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Check for simple erasable conflicts. 1525c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isImplicitDef()) 1526c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1527c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1528c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Include the non-conflict where DefMI is a coalescable copy that kills 1529c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // OtherVNI. We still want the copy erased and value numbers merged. 1530c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (CP.isCoalescable(DefMI)) { 1531c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some of the lanes copied from OtherVNI may be undef, making them undef 1532c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // here too. 153387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes | OtherV.ValidLanes; 1534c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1535c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1536c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1537c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This may not be a real conflict if DefMI simply kills Other and defines 1538c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // VNI. 1539c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherLRQ.isKill() && OtherLRQ.endPoint() <= VNI->def) 1540c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1541c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1542c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Handle the case where VNI and OtherVNI can be proven to be identical: 1543c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1544c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %other = COPY %ext 1545c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %this = COPY %ext <-- Erase this copy 1546c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1547c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isFullCopy() && !CP.isPartial() && 1548c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen stripCopies(VNI) == stripCopies(V.OtherVNI)) 1549c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1550c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 155187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // If the lanes written by this instruction were all undef in OtherVNI, it is 155287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // still safe to join the live ranges. This can't be done with a simple value 155387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // mapping, though - OtherVNI will map to multiple values: 155487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 155587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 1 %dst:ssub0 = FOO <-- OtherVNI 155687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 2 %src = BAR <-- VNI 155787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 3 %dst:ssub1 = COPY %src<kill> <-- Eliminate this copy. 155887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 4 BAZ %dst<kill> 155987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 5 QUUX %src<kill> 156087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 156187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Here OtherVNI will map to itself in [1;2), but to VNI in [2;5). CR_Replace 156287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // handles this complex value mapping. 156387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if ((V.WriteLanes & OtherV.ValidLanes) == 0) 156487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return CR_Replace; 156587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1566163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // If the other live range is killed by DefMI and the live ranges are still 1567163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // overlapping, it must be because we're looking at an early clobber def: 1568163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1569163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // %dst<def,early-clobber> = ASM %src<kill> 1570163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1571163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // In this case, it is illegal to merge the two live ranges since the early 1572163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // clobber def would clobber %src before it was read. 1573163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen if (OtherLRQ.isKill()) { 1574163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // This case where the def doesn't overlap the kill is handled above. 1575163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen assert(VNI->def.isEarlyClobber() && 1576163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen "Only early clobber defs can overlap a kill"); 1577163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen return CR_Impossible; 1578163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen } 1579163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen 1580d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is clobbering live lanes in OtherVNI, but there is still the 1581d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // possibility that no instructions actually read the clobbered lanes. 1582d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // If we're clobbering all the lanes in OtherVNI, at least one must be read. 1583d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Otherwise Other.LI wouldn't be live here. 1584d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if ((TRI->getSubRegIndexLaneMask(Other.SubIdx) & ~V.WriteLanes) == 0) 1585d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1586d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1587d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // We need to verify that no instructions are reading the clobbered lanes. To 1588d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // save compile time, we'll only check that locally. Don't allow the tainted 1589d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // value to escape the basic block. 1590d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1591d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (OtherLRQ.endPoint() >= Indexes->getMBBEndIdx(MBB)) 1592d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1593d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1594d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // There are still some things that could go wrong besides clobbered lanes 1595d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // being read, for example OtherVNI may be only partially redefined in MBB, 1596d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // and some clobbered lanes could escape the block. Save this analysis for 1597d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // resolveConflicts() when all values have been mapped. We need to know 1598d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // RedefVNI and WriteLanes for any later defs in MBB, and we can't compute 1599d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // that now - the recursive analyzeValue() calls must go upwards in the 1600d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // dominator tree. 1601d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Unresolved; 1602c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1603c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1604c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the value assignment for ValNo in LI. 1605c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// This may be called recursively by analyzeValue(), but never for a ValNo on 1606c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// the stack. 1607c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::computeAssignment(unsigned ValNo, JoinVals &Other) { 1608c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1609c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.isAnalyzed()) { 1610c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursion should always move up the dominator tree, so ValNo is not 1611c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // supposed to reappear before it has been assigned. 1612c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Assignments[ValNo] != -1 && "Bad recursion?"); 1613c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return; 1614c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1615c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen switch ((V.Resolution = analyzeValue(ValNo, Other))) { 1616c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Erase: 1617c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Merge: 1618c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this ValNo into OtherVNI. 1619c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't merge."); 1620c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Other.Vals[V.OtherVNI->id].isAnalyzed() && "Missing recursion"); 1621c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = Other.Assignments[V.OtherVNI->id]; 1622c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tmerge " << PrintReg(LI.reg) << ':' << ValNo << '@' 1623c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << LI.getValNumInfo(ValNo)->def << " into " 1624c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << PrintReg(Other.LI.reg) << ':' << V.OtherVNI->id << '@' 1625c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << V.OtherVNI->def << " --> @" 1626c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << NewVNInfo[Assignments[ValNo]]->def << '\n'); 1627c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 16282df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Replace: 16292df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 16302df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // The other value is going to be pruned if this join is successful. 16312df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't prune"); 16322df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Other.Vals[V.OtherVNI->id].Pruned = true; 16332df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Fall through. 1634c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen default: 1635c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This value number needs to go in the final joined live range. 1636c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = NewVNInfo.size(); 1637c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen NewVNInfo.push_back(LI.getValNumInfo(ValNo)); 1638c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1639c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1640c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1641c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1642c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::mapValues(JoinVals &Other) { 1643c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1644c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(i, Other); 1645c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Vals[i].Resolution == CR_Impossible) { 1646c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tinterference at " << PrintReg(LI.reg) << ':' << i 1647c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1648c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1649c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1650c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1651c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1652c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1653c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1654d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Assuming ValNo is going to clobber some valid lanes in Other.LI, compute 1655d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// the extent of the tainted lanes in the block. 1656d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1657d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Multiple values in Other.LI can be affected since partial redefinitions can 1658d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// preserve previously tainted lanes. 1659d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1660d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1 %dst = VLOAD <-- Define all lanes in %dst 1661d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 2 %src = FOO <-- ValNo to be joined with %dst:ssub0 1662d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 3 %dst:ssub1 = BAR <-- Partial redef doesn't clear taint in ssub0 1663d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 4 %dst:ssub0 = COPY %src <-- Conflict resolved, ssub0 wasn't read 1664d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1665d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// For each ValNo in Other that is affected, add an (EndIndex, TaintedLanes) 1666d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// entry to TaintedVals. 1667d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1668d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Returns false if the tainted lanes extend beyond the basic block. 1669d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals:: 1670d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesentaintExtent(unsigned ValNo, unsigned TaintedLanes, JoinVals &Other, 1671d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> > &TaintExtent) { 1672d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1673d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1674d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex MBBEnd = Indexes->getMBBEndIdx(MBB); 1675d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1676d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Scan Other.LI from VNI.def to MBBEnd. 1677d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LiveInterval::iterator OtherI = Other.LI.find(VNI->def); 1678d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(OtherI != Other.LI.end() && "No conflict?"); 1679d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen do { 1680d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // OtherI is pointing to a tainted value. Abort the join if the tainted 1681d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // lanes escape the block. 1682d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex End = OtherI->end; 1683d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End >= MBBEnd) { 1684d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints global " << PrintReg(Other.LI.reg) << ':' 1685d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start << '\n'); 1686d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1687d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1688d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints local " << PrintReg(Other.LI.reg) << ':' 1689d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start 1690d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << " to " << End << '\n'); 1691d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // A dead def is not a problem. 1692d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End.isDead()) 1693d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1694d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintExtent.push_back(std::make_pair(End, TaintedLanes)); 1695d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1696d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Check for another def in the MBB. 1697d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++OtherI == Other.LI.end() || OtherI->start >= MBBEnd) 1698d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1699d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1700d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Lanes written by the new def are no longer tainted. 1701d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OV = Other.Vals[OtherI->valno->id]; 1702d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes &= ~OV.WriteLanes; 1703d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!OV.RedefVNI) 1704d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1705d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } while (TaintedLanes); 1706d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1707d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1708d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1709d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Return true if MI uses any of the given Lanes from Reg. 1710d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// This does not include partial redefinitions of Reg. 1711d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals::usesLanes(MachineInstr *MI, unsigned Reg, unsigned SubIdx, 1712d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned Lanes) { 1713d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (MI->isDebugValue()) 1714d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1715d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for (ConstMIOperands MO(MI); MO.isValid(); ++MO) { 1716d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->isReg() || MO->isDef() || MO->getReg() != Reg) 1717d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 1718d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->readsReg()) 1719d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 172021caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen if (Lanes & TRI->getSubRegIndexLaneMask( 172121caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg()))) 1722d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1723d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1724d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1725d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1726d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1727c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::resolveConflicts(JoinVals &Other) { 1728c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1729d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Val &V = Vals[i]; 1730d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert (V.Resolution != CR_Impossible && "Unresolvable conflict"); 1731d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (V.Resolution != CR_Unresolved) 1732c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 1733c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tconflict at " << PrintReg(LI.reg) << ':' << i 1734c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1735d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneConflicts; 1736d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(V.OtherVNI && "Inconsistent conflict resolution."); 1737d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(i); 1738d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OtherV = Other.Vals[V.OtherVNI->id]; 1739d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1740d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is known to clobber some lanes in OtherVNI. If we go ahead with the 1741d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // join, those lanes will be tainted with a wrong value. Get the extent of 1742d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // the tainted lanes. 1743d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintedLanes = V.WriteLanes & OtherV.ValidLanes; 1744d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVector<std::pair<SlotIndex, unsigned>, 8> TaintExtent; 1745d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!taintExtent(i, TaintedLanes, Other, TaintExtent)) 1746d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Tainted lanes would extend beyond the basic block. 1747d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1748d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1749d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!TaintExtent.empty() && "There should be at least one conflict."); 1750d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1751d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Now look at the instructions from VNI->def to TaintExtent (inclusive). 1752d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1753d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock::iterator MI = MBB->begin(); 1754d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!VNI->isPHIDef()) { 1755d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MI = Indexes->getInstructionFromIndex(VNI->def); 1756d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // No need to check the instruction defining VNI for reads. 1757d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1758d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1759d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, TaintExtent.front().first) && 1760d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen "Interference ends on VNI->def. Should have been handled earlier"); 1761d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineInstr *LastMI = 1762d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Indexes->getInstructionFromIndex(TaintExtent.front().first); 1763d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1764d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintNum = 0; 1765d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for(;;) { 1766d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(MI != MBB->end() && "Bad LastMI"); 1767d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (usesLanes(MI, Other.LI.reg, Other.SubIdx, TaintedLanes)) { 1768d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttainted lanes used by: " << *MI); 1769d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1770d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1771d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // LastMI is the last instruction to use the current value. 1772d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (&*MI == LastMI) { 1773d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++TaintNum == TaintExtent.size()) 1774d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1775d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LastMI = Indexes->getInstructionFromIndex(TaintExtent[TaintNum].first); 1776d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1777d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes = TaintExtent[TaintNum].second; 1778d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1779d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1780d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1781d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1782d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // The tainted lanes are unused. 1783d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen V.Resolution = CR_Replace; 1784d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneResolves; 1785c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1786c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1787c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1788c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 17892df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// Determine if ValNo is a copy of a value number in LI or Other.LI that will 17902df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// be pruned: 17912df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 17922df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src 17932df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %src = COPY %dst <-- This value to be pruned. 17942df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src <-- This value is a copy of a pruned value. 17952df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 17962df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesenbool JoinVals::isPrunedValue(unsigned ValNo, JoinVals &Other) { 17972df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Val &V = Vals[ValNo]; 17982df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Pruned || V.PrunedComputed) 17992df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18002df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18012df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Resolution != CR_Erase && V.Resolution != CR_Merge) 18022df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18032df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18042df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Follow copies up the dominator tree and check if any intermediate value 18052df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // has been pruned. 18062df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.PrunedComputed = true; 18072df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.Pruned = Other.isPrunedValue(V.OtherVNI->id, *this); 18082df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18092df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen} 18102df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 181187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesenvoid JoinVals::pruneValues(JoinVals &Other, 181287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVectorImpl<SlotIndex> &EndPoints) { 181387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 181487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 18152df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen switch (Vals[i].Resolution) { 18162df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Keep: 18172df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1818795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Replace: { 18192df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value takes precedence over the value in Other.LI. 18202df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&Other.LI, Def, &EndPoints); 1821795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Check if we're replacing an IMPLICIT_DEF value. The IMPLICIT_DEF 1822795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // instructions are only inserted to provide a live-out value for PHI 1823795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // predecessors, so the instruction should simply go away once its value 1824795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // has been replaced. 1825795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Val &OtherV = Other.Vals[Vals[i].OtherVNI->id]; 1826251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool EraseImpDef = OtherV.ErasableImplicitDef && 1827251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.Resolution == CR_Keep; 1828d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!Def.isBlock()) { 1829795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove <def,read-undef> flags. This def is now a partial redef. 1830d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // Also remove <def,dead> flags since the joined live range will 1831d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // continue past this instruction. 183283ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen for (MIOperands MO(Indexes->getInstructionFromIndex(Def)); 183383ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen MO.isValid(); ++MO) 1834d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (MO->isReg() && MO->isDef() && MO->getReg() == LI.reg) { 1835d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsUndef(EraseImpDef); 1836d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsDead(false); 1837d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen } 1838795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // This value will reach instructions below, but we need to make sure 1839795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // the live range also reaches the instruction at Def. 1840d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!EraseImpDef) 1841d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen EndPoints.push_back(Def); 184227cb347d0e765175efb2c4d388bcbba84cf1b95eJakob Stoklund Olesen } 18432df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned " << PrintReg(Other.LI.reg) << " at " << Def 18442df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << ": " << Other.LI << '\n'); 18452df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1846795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 18472df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Erase: 18482df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Merge: 18492df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (isPrunedValue(i, Other)) { 18502df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value is ultimately a copy of a pruned value in LI or Other.LI. 18512df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // We can no longer trust the value mapping computed by 18522df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // computeAssignment(), the value that was originally copied could have 18532df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // been replaced. 18542df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&LI, Def, &EndPoints); 18552df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned all of " << PrintReg(LI.reg) << " at " 18562df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << Def << ": " << LI << '\n'); 18572df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 18582df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 18592df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 18602df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Impossible: 18612df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen llvm_unreachable("Unresolved conflicts"); 18622df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 186387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen } 186487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen} 186587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1866c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1867c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs) { 1868c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1869795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Get the def location before markUnused() below invalidates it. 1870c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 1871795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen switch (Vals[i].Resolution) { 1872795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Keep: 1873795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // If an IMPLICIT_DEF value is pruned, it doesn't serve a purpose any 1874795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // longer. The IMPLICIT_DEF instructions are only inserted by 1875795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // PHIElimination to guarantee that all PHI predecessors have a value. 1876251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (!Vals[i].ErasableImplicitDef || !Vals[i].Pruned) 1877795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1878795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove value number i from LI. Note that this VNInfo is still present 1879795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // in NewVNInfo, so it will appear as an unused value number in the final 1880795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // joined interval. 1881795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.getValNumInfo(i)->markUnused(); 1882795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.removeValNo(LI.getValNumInfo(i)); 1883795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tremoved " << i << '@' << Def << ": " << LI << '\n'); 1884795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // FALL THROUGH. 1885795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 1886795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Erase: { 1887795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(Def); 1888795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen assert(MI && "No instruction to erase"); 1889795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (MI->isCopy()) { 1890795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1891795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg) && 1892795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Reg != CP.getSrcReg() && Reg != CP.getDstReg()) 1893795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ShrinkRegs.push_back(Reg); 1894795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1895795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ErasedInstrs.insert(MI); 1896795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\terased:\t" << Def << '\t' << *MI); 1897795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(MI); 1898795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MI->eraseFromParent(); 1899795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1900795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1901795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen default: 1902795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1903c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1904c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1905c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1906c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1907c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool RegisterCoalescer::joinVirtRegs(CoalescerPair &CP) { 1908c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<VNInfo*, 16> NewVNInfo; 1909c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 1910c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LHS = LIS->getInterval(CP.getDstReg()); 1911c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals RHSVals(RHS, CP.getSrcIdx(), NewVNInfo, CP, LIS, TRI); 1912c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals LHSVals(LHS, CP.getDstIdx(), NewVNInfo, CP, LIS, TRI); 1913c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1914c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tRHS = " << PrintReg(CP.getSrcReg()) << ' ' << RHS 1915c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << "\n\t\tLHS = " << PrintReg(CP.getDstReg()) << ' ' << LHS 1916c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '\n'); 1917c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1918c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // First compute NewVNInfo and the simple value mappings. 1919c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Detect impossible conflicts early. 1920c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.mapValues(RHSVals) || !RHSVals.mapValues(LHSVals)) 1921c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1922c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1923c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some conflicts can only be resolved after all values have been mapped. 1924c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.resolveConflicts(RHSVals) || !RHSVals.resolveConflicts(LHSVals)) 1925c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1926c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1927c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // All clear, the live ranges can be merged. 1928c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 192987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // The merging algorithm in LiveInterval::join() can't handle conflicting 193087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // value mappings, so we need to remove any live ranges that overlap a 193187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace resolution. Collect a set of end points that can be used to 193287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // restore the live range after joining. 193387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVector<SlotIndex, 8> EndPoints; 193487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen LHSVals.pruneValues(RHSVals, EndPoints); 193587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen RHSVals.pruneValues(LHSVals, EndPoints); 193687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1937c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Erase COPY and IMPLICIT_DEF instructions. This may cause some external 1938c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // registers to require trimming. 1939c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<unsigned, 8> ShrinkRegs; 1940c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 1941c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen RHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 1942c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!ShrinkRegs.empty()) 1943c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LIS->shrinkToUses(&LIS->getInterval(ShrinkRegs.pop_back_val())); 1944c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1945c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Join RHS into LHS. 1946c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LHS.join(RHS, LHSVals.getAssignments(), RHSVals.getAssignments(), NewVNInfo, 1947c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI); 1948c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1949c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Kill flags are going to be wrong if the live ranges were overlapping. 1950c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Eventually, we should simply clear all kill flags when computing live 1951c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // ranges. They are reinserted after register allocation. 1952c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(LHS.reg); 1953c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(RHS.reg); 195487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 195587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if (EndPoints.empty()) 195687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return true; 195787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 195887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Recompute the parts of the live range we had to remove because of 195987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace conflicts. 196087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen DEBUG(dbgs() << "\t\trestoring liveness to " << EndPoints.size() 196187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen << " points: " << LHS << '\n'); 196287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen LIS->extendToIndices(&LHS, EndPoints); 1963c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1964c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1965c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 19669790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinIntervals - Attempt to join these two intervals. On failure, this 1967655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// returns false. 19689790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinIntervals(CoalescerPair &CP) { 1969cdcdfd2cab67366b1debbe36bf46c29f7fecda67Jakob Stoklund Olesen return CP.isPhys() ? joinReservedPhysReg(CP) : joinVirtRegs(CP); 1970655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1971655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1972655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolanamespace { 1973cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// Information concerning MBB coalescing priority. 1974cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trickstruct MBBPriorityInfo { 1975cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MachineBasicBlock *MBB; 1976cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned Depth; 1977cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick bool IsSplit; 1978cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 1979cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MBBPriorityInfo(MachineBasicBlock *mbb, unsigned depth, bool issplit) 1980cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick : MBB(mbb), Depth(depth), IsSplit(issplit) {} 1981cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick}; 1982cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick} 1983655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1984cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// C-style comparator that sorts first based on the loop depth of the basic 1985cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// block (the unsigned), and then on the MBB number. 1986cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// 1987cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// EnableGlobalCopies assumes that the primary sort key is loop depth. 1988cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trickstatic int compareMBBPriority(const void *L, const void *R) { 1989cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick const MBBPriorityInfo *LHS = static_cast<const MBBPriorityInfo*>(L); 1990cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick const MBBPriorityInfo *RHS = static_cast<const MBBPriorityInfo*>(R); 1991cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Deeper loops first 1992cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->Depth != RHS->Depth) 1993cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->Depth > RHS->Depth ? -1 : 1; 1994cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 1995cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Try to unsplit critical edges next. 1996cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->IsSplit != RHS->IsSplit) 1997cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->IsSplit ? -1 : 1; 1998cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 1999cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Prefer blocks that are more connected in the CFG. This takes care of 2000cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // the most difficult copies first while intervals are short. 2001cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cl = LHS->MBB->pred_size() + LHS->MBB->succ_size(); 2002cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cr = RHS->MBB->pred_size() + RHS->MBB->succ_size(); 2003cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (cl != cr) 2004cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return cl > cr ? -1 : 1; 2005cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2006cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // As a last resort, sort by block number. 2007cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->MBB->getNumber() < RHS->MBB->getNumber() ? -1 : 1; 2008655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2009655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2010265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick/// \returns true if the given copy uses or defines a local live range. 2011265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickstatic bool isLocalCopy(MachineInstr *Copy, const LiveIntervals *LIS) { 2012265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!Copy->isCopy()) 2013265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2014265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2015265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned SrcReg = Copy->getOperand(1).getReg(); 2016265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned DstReg = Copy->getOperand(0).getReg(); 2017265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (TargetRegisterInfo::isPhysicalRegister(SrcReg) 2018265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || TargetRegisterInfo::isPhysicalRegister(DstReg)) 2019265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2020265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2021265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return LIS->intervalIsInOneMBB(LIS->getInterval(SrcReg)) 2022265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || LIS->intervalIsInOneMBB(LIS->getInterval(DstReg)); 2023265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2024265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2025b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Try joining WorkList copies starting from index From. 2026b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Null out any successful joins. 2027265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickbool RegisterCoalescer:: 2028265058d9239e6867d06dc8aa40db5f33390abd17Andrew TrickcopyCoalesceWorkList(MutableArrayRef<MachineInstr*> CurrList) { 2029b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Progress = false; 2030265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = CurrList.size(); i != e; ++i) { 2031265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!CurrList[i]) 2032b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen continue; 2033bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Skip instruction pointers that have already been erased, for example by 2034bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // dead code elimination. 2035265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (ErasedInstrs.erase(CurrList[i])) { 2036265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList[i] = 0; 2037bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen continue; 2038bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 2039b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Again = false; 2040265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick bool Success = joinCopy(CurrList[i], Again); 2041b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen Progress |= Success; 2042b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen if (Success || !Again) 2043265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList[i] = 0; 2044b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen } 2045b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen return Progress; 2046b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen} 2047b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 20489790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid 2049b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund OlesenRegisterCoalescer::copyCoalesceInMBB(MachineBasicBlock *MBB) { 2050655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << MBB->getName() << ":\n"); 2051655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2052846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // Collect all copy-like instructions in MBB. Don't start coalescing anything 2053846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // yet, it might invalidate the iterator. 2054b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen const unsigned PrevSize = WorkList.size(); 2055ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (JoinGlobalCopies) { 2056265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Coalesce copies bottom-up to coalesce local defs before local uses. They 2057265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // are not inherently easier to resolve, but slightly preferable until we 2058265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // have local live range splitting. In particular this is required by 2059265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // cmp+jmp macro fusion. 2060265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (MachineBasicBlock::reverse_iterator 2061265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MII = MBB->rbegin(), E = MBB->rend(); MII != E; ++MII) { 2062265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!MII->isCopyLike()) 2063265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick continue; 2064265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (isLocalCopy(&(*MII), LIS)) 2065265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.push_back(&(*MII)); 2066265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else 2067265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(&(*MII)); 2068265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2069265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2070265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else { 2071265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end(); 2072265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MII != E; ++MII) 2073265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (MII->isCopyLike()) 2074265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(MII); 2075265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2076b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // Try coalescing the collected copies immediately, and remove the nulls. 2077b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // This prevents the WorkList from getting too large since most copies are 2078b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // joinable on the first attempt. 2079265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MutableArrayRef<MachineInstr*> 2080265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList(WorkList.begin() + PrevSize, WorkList.end()); 2081265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (copyCoalesceWorkList(CurrList)) 2082b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.erase(std::remove(WorkList.begin() + PrevSize, WorkList.end(), 2083b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen (MachineInstr*)0), WorkList.end()); 2084655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2085655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2086265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickvoid RegisterCoalescer::coalesceLocals() { 2087265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick copyCoalesceWorkList(LocalWorkList); 2088265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned j = 0, je = LocalWorkList.size(); j != je; ++j) { 2089265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (LocalWorkList[j]) 2090265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(LocalWorkList[j]); 2091265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2092265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.clear(); 2093265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2094265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 20959790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid RegisterCoalescer::joinAllIntervals() { 2096655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** JOINING INTERVALS ***********\n"); 2097265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around."); 2098655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2099f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick std::vector<MBBPriorityInfo> MBBs; 21008762a6bc2b83dfc11e784772311ad0b8fa5211e2Jakub Staszak MBBs.reserve(MF->size()); 2101f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick for (MachineFunction::iterator I = MF->begin(), E = MF->end();I != E;++I){ 2102f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MachineBasicBlock *MBB = I; 2103f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MBBs.push_back(MBBPriorityInfo(MBB, Loops->getLoopDepth(MBB), 2104cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick JoinSplitEdges && isSplitEdge(MBB))); 2105655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 2106cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick array_pod_sort(MBBs.begin(), MBBs.end(), compareMBBPriority); 2107f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick 2108f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick // Coalesce intervals in MBB priority order. 2109265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned CurrDepth = UINT_MAX; 2110265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = MBBs.size(); i != e; ++i) { 2111265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Try coalescing the collected local copies for deeper loops. 2112c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick if (JoinGlobalCopies && MBBs[i].Depth < CurrDepth) { 2113265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2114c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick CurrDepth = MBBs[i].Depth; 2115c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick } 2116f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick copyCoalesceInMBB(MBBs[i].MBB); 2117265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2118265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2119655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2120655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Joining intervals can allow other intervals to be joined. Iteratively join 2121655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // until we make no progress. 2122265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick while (copyCoalesceWorkList(WorkList)) 2123b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /* empty */ ; 2124655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2125655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 21265b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::releaseMemory() { 2127bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.clear(); 2128b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.clear(); 2129bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.clear(); 213003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.clear(); 2131655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2132655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 21335b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolabool RegisterCoalescer::runOnMachineFunction(MachineFunction &fn) { 2134c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF = &fn; 2135c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI = &fn.getRegInfo(); 2136c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TM = &fn.getTarget(); 2137c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 2138c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TII = TM->getInstrInfo(); 2139c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS = &getAnalysis<LiveIntervals>(); 2140655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AA = &getAnalysis<AliasAnalysis>(); 2141c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Loops = &getAnalysis<MachineLoopInfo>(); 2142655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2143ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick const TargetSubtargetInfo &ST = TM->getSubtarget<TargetSubtargetInfo>(); 2144ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (EnableGlobalCopies == cl::BOU_UNSET) 2145ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick JoinGlobalCopies = ST.enableMachineScheduler(); 2146ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick else 2147ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick JoinGlobalCopies = (EnableGlobalCopies == cl::BOU_TRUE); 2148ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 21493106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // The MachineScheduler does not currently require JoinSplitEdges. This will 21503106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // either be enabled unconditionally or replaced by a more general live range 21513106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // splitting optimization. 21523106aa125eb2756083e950362b6769b87cb3430aAndrew Trick JoinSplitEdges = EnableJoinSplits; 2153ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 2154655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** SIMPLE REGISTER COALESCING **********\n" 2155986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie << "********** Function: " << MF->getName() << '\n'); 2156655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2157655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2158c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "Before register coalescing"); 2159655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2160655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola RegClassInfo.runOnMachineFunction(fn); 2161655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2162655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Join (coalesce) intervals if requested. 2163b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen if (EnableJoining) 21649790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen joinAllIntervals(); 2165655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 21664a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // After deleting a lot of copies, register classes may be less constrained. 216703c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register operands may allow GR32_ABCD -> GR32 and DPR_VFP2 -> 21684a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // DPR inflation. 21694a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen array_pod_sort(InflateRegs.begin(), InflateRegs.end()); 21704a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.erase(std::unique(InflateRegs.begin(), InflateRegs.end()), 21714a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.end()); 21724a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << "Trying to inflate " << InflateRegs.size() << " regs.\n"); 21734a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen for (unsigned i = 0, e = InflateRegs.size(); i != e; ++i) { 21744a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen unsigned Reg = InflateRegs[i]; 21754a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(Reg)) 21764a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen continue; 21774a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->recomputeRegClass(Reg, *TM)) { 21784a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << PrintReg(Reg) << " inflated to " 21794a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen << MRI->getRegClass(Reg)->getName() << '\n'); 21804a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen ++NumInflated; 21814a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 21824a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 21834a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen 2184655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dump()); 2185655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2186c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "After register coalescing"); 2187655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 2188655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2189655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2190655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// print - Implement the dump method. 21915b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::print(raw_ostream &O, const Module* m) const { 2192c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->print(O, m); 2193655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2194