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 16fdf16ca44f130afe80c57481d0c08130aa08cc09Rafael Espindola#include "RegisterCoalescer.h" 17bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/STLExtras.h" 18bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/SmallSet.h" 19bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/Statistic.h" 20bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Analysis/AliasAnalysis.h" 212c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene#include "llvm/CodeGen/LiveIntervalAnalysis.h" 22bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/CodeGen/LiveRangeEdit.h" 23655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineFrameInfo.h" 24655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineInstr.h" 25655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineLoopInfo.h" 26655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineRegisterInfo.h" 27655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/Passes.h" 281525260b3e50cc578939ef41b60609689eecfdd2Andrew Trick#include "llvm/CodeGen/RegisterClassInfo.h" 291ead68d769f27f6d68d4aaeffe4199fa2cacbc95Jakob Stoklund Olesen#include "llvm/CodeGen/VirtRegMap.h" 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Value.h" 31d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Pass.h" 32655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/CommandLine.h" 33655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/Debug.h" 34655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/ErrorHandling.h" 35655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/raw_ostream.h" 36bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetInstrInfo.h" 37bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetMachine.h" 38bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetRegisterInfo.h" 39ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick#include "llvm/Target/TargetSubtargetInfo.h" 40655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <algorithm> 41655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <cmath> 422c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greeneusing namespace llvm; 432c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 44dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "regalloc" 45dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 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. 11536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void LRE_WillEraseInstruction(MachineInstr *MI) override; 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. 169b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick bool reMaterializeTrivialDef(CoalescerPair &CP, MachineInstr *CopyMI, 170b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick bool &IsDefCopy); 1718e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 17234a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen /// canJoinPhys - Return true if a physreg copy should be joined. 17339c71da6db9f52cf48430282a27384563a77793eJakub Staszak bool canJoinPhys(const CoalescerPair &CP); 1748e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1759790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 1768e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// update the subregister number if it is not zero. If DstReg is a 1778e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// physical register and the existing subregister number of the def / use 1788e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// being updated is not zero, make sure to set it to the correct physical 1798e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// subregister. 180ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen void updateRegDefsUses(unsigned SrcReg, unsigned DstReg, unsigned SubIdx); 1818e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1828e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// eliminateUndefCopy - Handle copies of undef values. 1838e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen bool eliminateUndefCopy(MachineInstr *CopyMI, const CoalescerPair &CP); 1848e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1858e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen public: 1868e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen static char ID; // Class identification, replacement for typeinfo 1878e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen RegisterCoalescer() : MachineFunctionPass(ID) { 1888e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen initializeRegisterCoalescerPass(*PassRegistry::getPassRegistry()); 1898e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen } 1908e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 19136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override; 1928e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 19336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void releaseMemory() override; 1948e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1958e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// runOnMachineFunction - pass entry point 19636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool runOnMachineFunction(MachineFunction&) override; 1978e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1988e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// print - Implement the dump method. 199dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void print(raw_ostream &O, const Module* = nullptr) const override; 2008e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen }; 2018e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen} /// end anonymous namespace 2028e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 2038dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickchar &llvm::RegisterCoalescerID = RegisterCoalescer::ID; 20427215676c7114132a0374f7b5c9ea73d9354d329Jakob Stoklund Olesen 2055b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_BEGIN(RegisterCoalescer, "simple-register-coalescing", 2065b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 207655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(LiveIntervals) 208655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(SlotIndexes) 209655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(MachineLoopInfo) 210655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_AG_DEPENDENCY(AliasAnalysis) 2115b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_END(RegisterCoalescer, "simple-register-coalescing", 2125b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 213655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2142c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greenechar RegisterCoalescer::ID = 0; 2152c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 21600258d17cd7152237141648d26e1b096cf0e882bRafael Espindolastatic bool isMoveInstr(const TargetRegisterInfo &tri, const MachineInstr *MI, 21700258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &Src, unsigned &Dst, 21800258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &SrcSub, unsigned &DstSub) { 219273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen if (MI->isCopy()) { 220273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 221273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen DstSub = MI->getOperand(0).getSubReg(); 222273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Src = MI->getOperand(1).getReg(); 223273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen SrcSub = MI->getOperand(1).getSubReg(); 2245c00e077952d14899c3fc26709c7b2dfd36d0209Jakob Stoklund Olesen } else if (MI->isSubregToReg()) { 22540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 22621caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen DstSub = tri.composeSubRegIndices(MI->getOperand(0).getSubReg(), 22721caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen MI->getOperand(3).getImm()); 22840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Src = MI->getOperand(2).getReg(); 22940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen SrcSub = MI->getOperand(2).getSubReg(); 23004c528a0c86ddf3d6a70681f72e1b2ec07b0b53aJakob Stoklund Olesen } else 23140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 23240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 23340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 23440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2353c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// Return true if this block should be vacated by the coalescer to eliminate 2363c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// branches. The important cases to handle in the coalescer are critical edges 2373c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// split during phi elimination which contain only copies. Simple blocks that 2383c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// contain non-branches should also be vacated, but this can be handled by an 2393c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// earlier pass similar to early if-conversion. 2403c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trickstatic bool isSplitEdge(const MachineBasicBlock *MBB) { 2413c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick if (MBB->pred_size() != 1 || MBB->succ_size() != 1) 2423c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick return false; 2433c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 244dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &MI : *MBB) { 245dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!MI.isCopyLike() && !MI.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; 254dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines NewRC = nullptr; 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 } else if (!MRI.getRegClass(Src)->contains(Dst)) { 28640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 28740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 28840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 28940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Both registers are virtual. 290defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *SrcRC = MRI.getRegClass(Src); 291defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *DstRC = MRI.getRegClass(Dst); 29240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2938df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen // Both registers have subreg indices. 2948df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen if (SrcSub && DstSub) { 295ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Copies between different sub-registers are never coalescable. 296ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (Src == Dst && SrcSub != DstSub) 297ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen return false; 298ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen 299defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen NewRC = TRI.getCommonSuperRegClass(SrcRC, SrcSub, DstRC, DstSub, 30094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx, DstIdx); 301defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen if (!NewRC) 3028df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen return false; 30394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (DstSub) { 30494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // SrcReg will be merged with a sub-register of DstReg. 30594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx = DstSub; 30694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(DstRC, SrcRC, DstSub); 30794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (SrcSub) { 30894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // DstReg will be merged with a sub-register of SrcReg. 30994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen DstIdx = SrcSub; 31094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(SrcRC, DstRC, SrcSub); 31194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else { 31294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // This is a straight copy without sub-registers. 31394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getCommonSubClass(DstRC, SrcRC); 3148df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen } 31540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 31694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // The combined constraint may be impossible to satisfy. 31794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (!NewRC) 31894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen return false; 31994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen 32094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // Prefer SrcReg to be a sub-register of DstReg. 32194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // FIXME: Coalescer should support subregs symmetrically. 32294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (DstIdx && !SrcIdx) { 32340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 32494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 32594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen Flipped = !Flipped; 32640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 32740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 328c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen CrossClass = NewRC != DstRC || NewRC != SrcRC; 32940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 33040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Check our invariants 33140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Src) && "Src must be virtual"); 33240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(!(TargetRegisterInfo::isPhysicalRegister(Dst) && DstSub) && 33340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen "Cannot have a physical SubIdx"); 334c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SrcReg = Src; 335c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DstReg = Dst; 33640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 33740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 33840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 33940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::flip() { 34094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) 34140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 342c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen std::swap(SrcReg, DstReg); 34394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 344c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = !Flipped; 34540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 34640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 34740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 34840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::isCoalescable(const MachineInstr *MI) const { 34940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!MI) 35040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen unsigned Src, Dst, SrcSub, DstSub; 352c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!isMoveInstr(TRI, MI, Src, Dst, SrcSub, DstSub)) 35340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 355c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Find the virtual register that is SrcReg. 356c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (Dst == SrcReg) { 35740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 35840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(SrcSub, DstSub); 359c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen } else if (Src != SrcReg) { 36040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 36240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 363c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Now check that Dst matches DstReg. 364c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { 36540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(Dst)) 36640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen assert(!DstIdx && !SrcIdx && "Inconsistent CoalescerPair state."); 36840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // DstSub could be set for a physreg from INSERT_SUBREG. 36940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (DstSub) 370c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getSubReg(Dst, DstSub); 37140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Full copy of Src. 37240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!SrcSub) 373c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return DstReg == Dst; 37440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // This is a partial register copy. Check that the parts match. 375c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return TRI.getSubReg(DstReg, SrcSub) == Dst; 37640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 377c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // DstReg is virtual. 378c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (DstReg != Dst) 37940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 38040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Registers match, do the subregisters line up? 38121caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen return TRI.composeSubRegIndices(SrcIdx, SrcSub) == 38221caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI.composeSubRegIndices(DstIdx, DstSub); 38340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 38440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 38540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 3865b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::getAnalysisUsage(AnalysisUsage &AU) const { 387655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.setPreservesCFG(); 388655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<AliasAnalysis>(); 389655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<LiveIntervals>(); 390655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<LiveIntervals>(); 391655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<SlotIndexes>(); 392655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<MachineLoopInfo>(); 393655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<MachineLoopInfo>(); 394655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreservedID(MachineDominatorsID); 395655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineFunctionPass::getAnalysisUsage(AU); 396655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 397655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 398bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesenvoid RegisterCoalescer::eliminateDeadDefs() { 3991feb5854aeeda897e9318c8193d187673c8576b8Mark Lacey SmallVector<unsigned, 8> NewRegs; 400dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LiveRangeEdit(nullptr, NewRegs, *MF, *LIS, 401dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines nullptr, 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 4360bb5a66b0388d2c52a887eaafe3749aaceb6a754Matthias Braun // BValNo is a value number in B that is defined by a copy from A. 'B1' in 437655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // the example above. 438331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LiveInterval::iterator BS = IntB.FindSegmentContaining(CopyIdx); 439331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (BS == IntB.end()) return false; 440331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun VNInfo *BValNo = BS->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); 449331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LiveInterval::iterator AS = IntA.FindSegmentContaining(CopyUseIdx); 450331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // The live segment might not exist after fun with physreg coalescing. 451331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (AS == IntA.end()) return false; 452331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun VNInfo *AValNo = AS->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 461331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Get the Segment in IntB that this value number starts with. 462331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LiveInterval::iterator ValS = 463331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun IntB.FindSegmentContaining(AValNo->def.getPrevSlot()); 464331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (ValS == IntB.end()) 465655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 466655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 467331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Make sure that the end of the live segment is inside the same block as 468655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI. 469331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun MachineInstr *ValSEndInst = 470331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LIS->getInstructionFromIndex(ValS->end.getPrevSlot()); 471331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (!ValSEndInst || ValSEndInst->getParent() != CopyMI->getParent()) 472655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 473655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 474331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Okay, we now know that ValS ends in the same block that the CopyMI 475331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // live-range starts. If there are no intervening live segments between them 476331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // in IntB, we can merge them. 477331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (ValS+1 != BS) return false; 478655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 479b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << "Extending: " << PrintReg(IntB.reg, TRI)); 480655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 481331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun SlotIndex FillerStart = ValS->end, FillerEnd = BS->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: 488331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // [ValS.end, BS.begin) of either value number, then we merge the 489655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // two value numbers. 490331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun IntB.addSegment(LiveInterval::Segment(FillerStart, FillerEnd, BValNo)); 491655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 492655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, merge "B1" into the same value number as "B0". 493331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (BValNo != ValS->valno) 494331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun IntB.MergeValueNumberInto(BValNo, ValS->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. 499331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun int UIdx = ValSEndInst->findRegisterUseOperandIdx(IntB.reg, true); 500655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UIdx != -1) { 501331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun ValSEndInst->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); 508331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (AS->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; 529b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun LiveInterval::iterator BI = 530b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun std::upper_bound(IntB.begin(), IntB.end(), AI->start); 531b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun if (BI != IntB.begin()) 532655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola --BI; 533b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun for (; BI != IntB.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 579c725865bbcfb935f3698f26b6608fdbd2b2d3fd4Matthias Braun // BValNo is a value number in B that is defined by a copy from A. 'B1' 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 // AValNo is the value number in A that defines the copy, A3 in the example. 5862debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *AValNo = IntA.getVNInfoAt(CopyIdx.getRegSlot(true)); 587655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(AValNo && "COPY source not live"); 5880ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen if (AValNo->isPHIDef() || AValNo->isUnused()) 589655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 590c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *DefMI = LIS->getInstructionFromIndex(AValNo->def); 591655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI) 592655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 5935a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!DefMI->isCommutable()) 594655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 595655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If DefMI is a two-address instruction then commuting it will change the 596655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // destination register. 597655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola int DefIdx = DefMI->findRegisterDefOperandIdx(IntA.reg); 598655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DefIdx != -1); 599655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned UseOpIdx; 600655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isRegTiedToUseOperand(DefIdx, &UseOpIdx)) 601655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 602655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned Op1, Op2, NewDstIdx; 603c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->findCommutedOpIndices(DefMI, Op1, Op2)) 604655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 605655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (Op1 == UseOpIdx) 606655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op2; 607655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else if (Op2 == UseOpIdx) 608655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op1; 609655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 610655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 611655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 612655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &NewDstMO = DefMI->getOperand(NewDstIdx); 613655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned NewReg = NewDstMO.getReg(); 6145649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun if (NewReg != IntB.reg || !IntB.Query(AValNo->def).isKill()) 615655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 616655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 617655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure there are no other definitions of IntB that would reach the 618655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // uses which the new definition can reach. 6199790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (hasOtherReachingDefs(IntA, IntB, AValNo, BValNo)) 620655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 621655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 622655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If some of the uses of IntA.reg is already coalesced away, return false. 623655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // It's not possible to determine whether it's safe to perform the coalescing. 62436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (MachineOperand &MO : MRI->use_nodbg_operands(IntA.reg)) { 62536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineInstr *UseMI = MO.getParent(); 62636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned OpNo = &MO - &UseMI->getOperand(0); 627c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI); 628331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LiveInterval::iterator US = IntA.FindSegmentContaining(UseIdx); 629331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (US == IntA.end() || US->valno != AValNo) 630655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 63156366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen // If this use is tied to a def, we can't rewrite the register. 63236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (UseMI->isRegTiedToDefOperand(OpNo)) 633655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 634655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 635655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 6369790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen DEBUG(dbgs() << "\tremoveCopyByCommutingDef: " << AValNo->def << '\t' 637655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola << *DefMI); 638655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 639655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // At this point we have decided that it is legal to do this 640655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // transformation. Start by commuting the instruction. 641655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = DefMI->getParent(); 642c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *NewMI = TII->commuteInstruction(DefMI); 643655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!NewMI) 644655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 645655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isVirtualRegister(IntA.reg) && 646655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola TargetRegisterInfo::isVirtualRegister(IntB.reg) && 647c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen !MRI->constrainRegClass(IntB.reg, MRI->getRegClass(IntA.reg))) 648655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 649655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (NewMI != DefMI) { 650c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->ReplaceMachineInstrInMaps(DefMI, NewMI); 6517c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MachineBasicBlock::iterator Pos = DefMI; 6527c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MBB->insert(Pos, NewMI); 653655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MBB->erase(DefMI); 654655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 655655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned OpIdx = NewMI->findRegisterUseOperandIdx(IntA.reg, false); 656655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewMI->getOperand(OpIdx).setIsKill(); 657655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 658655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If ALR and BLR overlaps and end of BLR extends beyond end of ALR, e.g. 659655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // A = or A, B 660655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 661655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // B = A 662655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 663655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // C = A<kill> 664655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 665655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // = B 666655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 667655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update uses of IntA of the specific Val# with IntB. 668c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(IntA.reg), 669c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UE = MRI->use_end(); UI != UE;) { 67036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineOperand &UseMO = *UI; 67136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineInstr *UseMI = UseMO.getParent(); 672655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++UI; 673655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->isDebugValue()) { 674655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // FIXME These don't have an instruction index. Not clear we have enough 675655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // info to decide whether to do this replacement or not. For now do it. 676655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 677655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 678655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 6792debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI).getRegSlot(true); 680331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun LiveInterval::iterator US = IntA.FindSegmentContaining(UseIdx); 681331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun if (US == IntA.end() || US->valno != AValNo) 682655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 68334af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen // Kill flags are no longer accurate. They are recomputed after RA. 68434af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen UseMO.setIsKill(false); 685655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isPhysicalRegister(NewReg)) 686c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UseMO.substPhysReg(NewReg, *TRI); 687655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 688655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 689655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI == CopyMI) 690655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 691655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isCopy()) 692655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 693655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->getOperand(0).getReg() != IntB.reg || 694655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMI->getOperand(0).getSubReg()) 695655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 696655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 697655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // This copy will become a noop. If it's defining a new val#, merge it into 698655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo. 6992debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex DefIdx = UseIdx.getRegSlot(); 700655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *DVNI = IntB.getVNInfoAt(DefIdx); 701655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DVNI) 702655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 703655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\tnoop: " << DefIdx << '\t' << *UseMI); 704655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DVNI->def == DefIdx); 705655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola BValNo = IntB.MergeValueNumberInto(BValNo, DVNI); 706ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen ErasedInstrs.insert(UseMI); 707ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(UseMI); 708ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen UseMI->eraseFromParent(); 709655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 710655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 711331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // Extend BValNo by merging in IntA live segments of AValNo. Val# definition 712655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // is updated. 713655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *ValNo = BValNo; 714655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ValNo->def = AValNo->def; 715655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (LiveInterval::iterator AI = IntA.begin(), AE = IntA.end(); 716655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AI != AE; ++AI) { 717655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (AI->valno != AValNo) continue; 718331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun IntB.addSegment(LiveInterval::Segment(AI->start, AI->end, ValNo)); 719655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 720655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\textended: " << IntB << '\n'); 721655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 722655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntA.removeValNo(AValNo); 723655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\ttrimmed: " << IntA << '\n'); 724655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCommutes; 725655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 726655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 727655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 7289790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// reMaterializeTrivialDef - If the source of a copy is defined by a trivial 729655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// computation, replace the copy by rematerialize the definition. 7301d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarichbool RegisterCoalescer::reMaterializeTrivialDef(CoalescerPair &CP, 731b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick MachineInstr *CopyMI, 732b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick bool &IsDefCopy) { 733b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick IsDefCopy = false; 7341d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned SrcReg = CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg(); 735aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned SrcIdx = CP.isFlipped() ? CP.getDstIdx() : CP.getSrcIdx(); 7361d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned DstReg = CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg(); 737aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned DstIdx = CP.isFlipped() ? CP.getSrcIdx() : CP.getDstIdx(); 7381d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (TargetRegisterInfo::isPhysicalRegister(SrcReg)) 7391d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich return false; 7401d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich 7411d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich LiveInterval &SrcInt = LIS->getInterval(SrcReg); 742202eb7b18e220205ec86a03ddf18f2066c70ab15Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI); 7435649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun VNInfo *ValNo = SrcInt.Query(CopyIdx).valueIn(); 744202eb7b18e220205ec86a03ddf18f2066c70ab15Jakob Stoklund Olesen assert(ValNo && "CopyMI input register not live"); 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; 750b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick if (DefMI->isCopyLike()) { 751b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick IsDefCopy = true; 752b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick return false; 753b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick } 75422c310d78ce9630af15b0de94c18a409705b7496Tim Murray if (!TII->isAsCheapAsAMove(DefMI)) 755655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 756c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->isTriviallyReMaterializable(DefMI, AA)) 757655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 758655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool SawStore = false; 759c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!DefMI->isSafeToMove(TII, AA, SawStore)) 760655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 7615a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng const MCInstrDesc &MCID = DefMI->getDesc(); 762e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MCID.getNumDefs() != 1) 763655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 764c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // Only support subregister destinations when the def is read-undef. 765c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich MachineOperand &DstOperand = CopyMI->getOperand(0); 766d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover unsigned CopyDstReg = DstOperand.getReg(); 767c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich if (DstOperand.getSubReg() && !DstOperand.isUndef()) 768c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich return false; 769aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 77036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // If both SrcIdx and DstIdx are set, correct rematerialization would widen 77136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // the register substantially (beyond both source and dest size). This is bad 77236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // for performance since it can cascade through a function, introducing many 77336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // extra spills and fills (e.g. ARM can easily end up copying QQQQPR registers 77436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // around after a few subreg copies). 77536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (SrcIdx && DstIdx) 77636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 77736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 778aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover const TargetRegisterClass *DefRC = TII->getRegClass(MCID, 0, TRI, *MF); 779655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isImplicitDef()) { 780aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { 781aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewDstReg = DstReg; 782aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 783aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewDstIdx = TRI->composeSubRegIndices(CP.getSrcIdx(), 784aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover DefMI->getOperand(0).getSubReg()); 785aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewDstIdx) 786aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewDstReg = TRI->getSubReg(DstReg, NewDstIdx); 787aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 788aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // Finally, make sure that the physical subregister that will be 789aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // constructed later is permitted for the instruction. 790aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (!DefRC->contains(NewDstReg)) 791655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 792aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } else { 793aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // Theoretically, some stack frame reference could exist. Just make sure 794aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // it hasn't actually happened. 795aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover assert(TargetRegisterInfo::isVirtualRegister(DstReg) && 796aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover "Only expect to deal with virtual or physical registers"); 797aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } 798655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 799655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 800655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = CopyMI->getParent(); 801655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock::iterator MII = 80236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::next(MachineBasicBlock::iterator(CopyMI)); 803aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover TII->reMaterialize(*MBB, MII, DstReg, SrcIdx, DefMI, *TRI); 80436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineInstr *NewMI = std::prev(MII); 805655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 806aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover LIS->ReplaceMachineInstrInMaps(CopyMI, NewMI); 807aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover CopyMI->eraseFromParent(); 808aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover ErasedInstrs.insert(CopyMI); 809c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich 810eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI may have dead implicit defs (E.g. EFLAGS for MOV<bits>r0 on X86). 811eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // We need to remember these so we can add intervals once we insert 812eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI into SlotIndexes. 813eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SmallVector<unsigned, 4> NewMIImplDefs; 814eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = NewMI->getDesc().getNumOperands(), 815eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames e = NewMI->getNumOperands(); i != e; ++i) { 816eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames MachineOperand &MO = NewMI->getOperand(i); 817eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames if (MO.isReg()) { 818275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isDef() && MO.isImplicit() && MO.isDead() && 819275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames TargetRegisterInfo::isPhysicalRegister(MO.getReg())); 820eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames NewMIImplDefs.push_back(MO.getReg()); 821eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 822eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 823eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 824aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (TargetRegisterInfo::isVirtualRegister(DstReg)) { 82536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const TargetRegisterClass *NewRC = CP.getNewRC(); 826aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewIdx = NewMI->getOperand(0).getSubReg(); 82736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 828aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewIdx) 82936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines NewRC = TRI->getMatchingSuperRegClass(NewRC, DefRC, NewIdx); 83036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines else 83136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines NewRC = TRI->getCommonSubClass(NewRC, DefRC); 83236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 83336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(NewRC && "subreg chosen for remat incompatible with instruction"); 83436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MRI->setRegClass(DstReg, NewRC); 83536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 83636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines updateRegDefsUses(DstReg, DstReg, DstIdx); 83736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines NewMI->getOperand(0).setSubReg(NewIdx); 838d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover } else if (NewMI->getOperand(0).getReg() != CopyDstReg) { 839aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // The New instruction may be defining a sub-register of what's actually 840aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // been asked for. If so it must implicitly define the whole thing. 841aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover assert(TargetRegisterInfo::isPhysicalRegister(DstReg) && 842aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover "Only expect virtual or physical registers in remat"); 84389dbe9744255864445b1c9f9a613ae333d3f79c8Tim Northover NewMI->getOperand(0).setIsDead(true); 844d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover NewMI->addOperand(MachineOperand::CreateReg(CopyDstReg, 845aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover true /*IsDef*/, 846aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover true /*IsImp*/, 847aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover false /*IsKill*/)); 848dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Record small dead def live-ranges for all the subregisters 849dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // of the destination register. 850dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Otherwise, variables that live through may miss some 851dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // interferences, thus creating invalid allocation. 852dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // E.g., i386 code: 853dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // vreg1 = somedef ; vreg1 GR8 854dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // vreg2 = remat ; vreg2 GR32 855dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // CL = COPY vreg2.sub_8bit 856dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // = somedef vreg1 ; vreg1 GR8 857dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // => 858dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // vreg1 = somedef ; vreg1 GR8 859dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // ECX<def, dead> = remat ; CL<imp-def> 860dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // = somedef vreg1 ; vreg1 GR8 861dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // vreg1 will see the inteferences with CL but not with CH since 862dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // no live-ranges would have been created for ECX. 863dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Fix that! 864dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI); 865dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (MCRegUnitIterator Units(NewMI->getOperand(0).getReg(), TRI); 866dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Units.isValid(); ++Units) 867dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (LiveRange *LR = LIS->getCachedRegUnit(*Units)) 868dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LR->createDeadDef(NewMIIdx.getRegSlot(), LIS->getVNInfoAllocator()); 869aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } 870aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 871aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewMI->getOperand(0).getSubReg()) 872aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewMI->getOperand(0).setIsUndef(); 873aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 874655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI may have implicit operands, transfer them over to the newly 875655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerialized instruction. And update implicit def interval valnos. 876655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = CopyMI->getDesc().getNumOperands(), 877655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola e = CopyMI->getNumOperands(); i != e; ++i) { 878655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = CopyMI->getOperand(i); 879275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (MO.isReg()) { 880275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isImplicit() && "No explicit operands after implict operands."); 881275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames // Discard VReg implicit defs. 882275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) { 883275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames NewMI->addOperand(MO); 884275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 885275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 886655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 887655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 888eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI); 889eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = 0, e = NewMIImplDefs.size(); i != e; ++i) { 89071b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen unsigned Reg = NewMIImplDefs[i]; 89171b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen for (MCRegUnitIterator Units(Reg, TRI); Units.isValid(); ++Units) 8924f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun if (LiveRange *LR = LIS->getCachedRegUnit(*Units)) 8934f3b5e8c9232e43d1291aab8db5f5698d7ee0ea4Matthias Braun LR->createDeadDef(NewMIIdx.getRegSlot(), LIS->getVNInfoAllocator()); 894eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 895eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 896655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "Remat: " << *NewMI); 897655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++NumReMats; 898655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 899655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // The source interval can become smaller because we removed a use. 9001dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen LIS->shrinkToUses(&SrcInt, &DeadDefs); 9011dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen if (!DeadDefs.empty()) 9021dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen eliminateDeadDefs(); 903655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 904655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 905655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 906655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 907e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// eliminateUndefCopy - ProcessImpicitDefs may leave some copies of <undef> 908e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// values, it only removes local variables. When we have a copy like: 909e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 910e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// %vreg1 = COPY %vreg2<undef> 911e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 912e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// We delete the copy and remove the corresponding value number from %vreg1. 913e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// Any uses of that value number are marked as <undef>. 914e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesenbool RegisterCoalescer::eliminateUndefCopy(MachineInstr *CopyMI, 915e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen const CoalescerPair &CP) { 916c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(CopyMI); 917c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *SrcInt = &LIS->getInterval(CP.getSrcReg()); 918e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (SrcInt->liveAt(Idx)) 919e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 920c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *DstInt = &LIS->getInterval(CP.getDstReg()); 921e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 922e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 923e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 924e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // No intervals are live-in to CopyMI - it is undef. 925e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (CP.isFlipped()) 926e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt = SrcInt; 927dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SrcInt = nullptr; 928e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 9292debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *DeadVNI = DstInt->getVNInfoAt(Idx.getRegSlot()); 930e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen assert(DeadVNI && "No value defined in DstInt"); 931e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt->removeValNo(DeadVNI); 932e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 933e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // Find new undef uses. 93436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (MachineOperand &MO : MRI->reg_nodbg_operands(DstInt->reg)) { 935e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (MO.isDef() || MO.isUndef()) 936e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 937e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MachineInstr *MI = MO.getParent(); 938c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(MI); 939e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 940e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 941e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MO.setIsUndef(true); 942e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DEBUG(dbgs() << "\tnew undef: " << Idx << '\t' << *MI); 943e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 944e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return true; 945e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen} 946e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 9479790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 948655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// update the subregister number if it is not zero. If DstReg is a 949655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// physical register and the existing subregister number of the def / use 950655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// being updated is not zero, make sure to set it to the correct physical 951655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// subregister. 952ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesenvoid RegisterCoalescer::updateRegDefsUses(unsigned SrcReg, 953ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned DstReg, 954ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned SubIdx) { 955ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen bool DstIsPhys = TargetRegisterInfo::isPhysicalRegister(DstReg); 956dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LiveInterval *DstInt = DstIsPhys ? nullptr : &LIS->getInterval(DstReg); 957655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 95889bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen SmallPtrSet<MachineInstr*, 8> Visited; 95936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (MachineRegisterInfo::reg_instr_iterator 96036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I = MRI->reg_instr_begin(SrcReg), E = MRI->reg_instr_end(); 96136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I != E; ) { 96236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineInstr *UseMI = &*(I++); 96336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 96489bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // Each instruction can only be rewritten once because sub-register 96589bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // composition is not always idempotent. When SrcReg != DstReg, rewriting 96689bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // the UseMI operands removes them from the SrcReg use-def chain, but when 96789bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // SrcReg is DstReg we could encounter UseMI twice if it has multiple 96889bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // operands mentioning the virtual register. 96989bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen if (SrcReg == DstReg && !Visited.insert(UseMI)) 97089bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen continue; 97189bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen 972655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola SmallVector<unsigned,8> Ops; 973655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool Reads, Writes; 97436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::tie(Reads, Writes) = UseMI->readsWritesVirtualRegister(SrcReg, &Ops); 975655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 97607a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // If SrcReg wasn't read, it may still be the case that DstReg is live-in 97707a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // because SrcReg is a sub-register. 978324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen if (DstInt && !Reads && SubIdx) 979324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen Reads = DstInt->liveAt(LIS->getInstructionIndex(UseMI)); 98007a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen 981655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Replace SrcReg with DstReg in all UseMI operands. 982655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = 0, e = Ops.size(); i != e; ++i) { 983655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = UseMI->getOperand(Ops[i]); 984655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 98507a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // Adjust <undef> flags in case of sub-register joins. We don't want to 98607a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // turn a full def into a read-modify-write sub-register def and vice 98707a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // versa. 988ec096b492549d625e4be608fcaea265b96dabc03Jakob Stoklund Olesen if (SubIdx && MO.isDef()) 98907a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen MO.setIsUndef(!Reads); 990b077cf338bd85a6a7397ec88d65278f02f0ed06fJakob Stoklund Olesen 991655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (DstIsPhys) 992c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substPhysReg(DstReg, *TRI); 993655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 994c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substVirtReg(DstReg, SubIdx, *TRI); 995655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 996655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 997655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG({ 998655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << "\t\tupdated: "; 999655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isDebugValue()) 1000c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen dbgs() << LIS->getInstructionIndex(UseMI) << "\t"; 1001655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << *UseMI; 1002655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola }); 1003655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1004655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1005655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 100634a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen/// canJoinPhys - Return true if a copy involving a physreg should be joined. 100739c71da6db9f52cf48430282a27384563a77793eJakub Staszakbool RegisterCoalescer::canJoinPhys(const CoalescerPair &CP) { 1008655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// Always join simple intervals that are defined by a single copy from a 1009655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// reserved register. This doesn't increase register pressure, so it is 1010655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// always beneficial. 101114d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen if (!MRI->isReserved(CP.getDstReg())) { 101234a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCan only merge into reserved registers.\n"); 1013655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1014655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1015655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 101634a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen LiveInterval &JoinVInt = LIS->getInterval(CP.getSrcReg()); 101734a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (CP.isFlipped() && JoinVInt.containsOneValue()) 101834a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return true; 1019655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 102034a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCannot join defs into reserved register.\n"); 102134a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return false; 1022655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1023655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 10249790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, 1025655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// which are the src/dst of the copy instruction CopyMI. This returns true 1026655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// if the copy was successfully coalesced away. If it is not currently 1027655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// possible to coalesce this interval, but it may be possible if other 1028655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// things get coalesced, then it returns true by reference in 'Again'. 10299790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinCopy(MachineInstr *CopyMI, bool &Again) { 1030655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1031655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = false; 1032c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DEBUG(dbgs() << LIS->getInstructionIndex(CopyMI) << '\t' << *CopyMI); 1033655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1034a7542d5f870c5d98960d1676e23ac1d1d975d7e5Benjamin Kramer CoalescerPair CP(*TRI); 1035655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!CP.setRegisters(CopyMI)) { 1036655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tNot coalescable.\n"); 1037655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1038655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1039655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1040bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Dead code elimination. This really should be handled by MachineDCE, but 1041bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // sometimes dead copies slip through, and we can't generate invalid live 1042bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // ranges. 1043bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen if (!CP.isPhys() && CopyMI->allDefsAreDead()) { 1044bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy is dead.\n"); 1045bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.push_back(CopyMI); 1046bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen eliminateDeadDefs(); 1047bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen return true; 1048bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 1049bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 1050e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Eliminate undefs. 1051e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (!CP.isPhys() && eliminateUndefCopy(CopyMI, CP)) { 1052e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tEliminated copy of <undef> value.\n"); 10533662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 10543662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1055655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; // Not coalescable. 1056655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1057655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1058e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Coalesced copies are normally removed immediately, but transformations 1059e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // like removeCopyByCommutingDef() can inadvertently create identity copies. 1060e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // When that happens, just join the values and remove the copy. 1061e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (CP.getSrcReg() == CP.getDstReg()) { 1062e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LiveInterval &LI = LIS->getInterval(CP.getSrcReg()); 1063e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy already coalesced: " << LI << '\n'); 10645649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun LiveQueryResult LRQ = LI.Query(LIS->getInstructionIndex(CopyMI)); 1065e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (VNInfo *DefVNI = LRQ.valueDefined()) { 1066e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen VNInfo *ReadVNI = LRQ.valueIn(); 1067e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI && "No value before copy and no <undef> flag."); 1068e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI != DefVNI && "Cannot read and define the same value."); 1069e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LI.MergeValueNumberInto(DefVNI, ReadVNI); 1070e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tMerged values: " << LI << '\n'); 1071e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen } 10723662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 10733662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1074e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen return true; 1075e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 1076e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 1077655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Enforce policies. 1078655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isPhys()) { 1079ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen DEBUG(dbgs() << "\tConsidering merging " << PrintReg(CP.getSrcReg(), TRI) 1080ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with " << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) 1081ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << '\n'); 108234a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (!canJoinPhys(CP)) { 1083655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Before giving up coalescing, if definition of source is defined by 1084655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // trivial computation, try rematerializing it. 1085b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick bool IsDefCopy; 1086b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick if (reMaterializeTrivialDef(CP, CopyMI, IsDefCopy)) 1087655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1088b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick if (IsDefCopy) 1089b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick Again = true; // May be possible to coalesce later. 1090655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1091655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1092655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } else { 109340a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen DEBUG({ 1094ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << "\tConsidering merging to " << CP.getNewRC()->getName() 1095ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with "; 1096ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx() && CP.getSrcIdx()) 1097ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getDstReg()) << " in " 1098ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getDstIdx()) << " and " 1099ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getSrcReg()) << " in " 1100ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getSrcIdx()) << '\n'; 1101ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen else 1102ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getSrcReg(), TRI) << " in " 1103ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) << '\n'; 110440a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen }); 1105655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1106655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // When possible, let DstReg be the larger interval. 1107b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun if (!CP.isPartial() && LIS->getInterval(CP.getSrcReg()).size() > 1108b63db853500b3dcb46a96af3f2d5aec003e41d77Matthias Braun LIS->getInterval(CP.getDstReg()).size()) 1109655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola CP.flip(); 1110655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1111655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1112655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, attempt to join these two intervals. On failure, this returns false. 1113655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, if one of the intervals being joined is a physreg, this method 1114655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // always canonicalizes DstInt to be it. The output "SrcInt" will not have 1115655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // been modified, so we can use this information below to update aliases. 11169790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (!joinIntervals(CP)) { 1117655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing failed. 1118655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1119655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If definition of source is defined by trivial computation, try 1120655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerializing it. 1121b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick bool IsDefCopy; 1122b5f906b98fe5c05c491c6cf2ec30fcf206b60b27Andrew Trick if (reMaterializeTrivialDef(CP, CopyMI, IsDefCopy)) 1123655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1124655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1125331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // If we can eliminate the copy without merging the live segments, do so 1126331de11a0acc6a095b98914b5f05ff242c9d7819Matthias Braun // now. 11270984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen if (!CP.isPartial() && !CP.isPhys()) { 11289790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (adjustCopiesBackFrom(CP, CopyMI) || 11299790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen removeCopyByCommutingDef(CP, CopyMI)) { 1130ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1131ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen CopyMI->eraseFromParent(); 1132655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tTrivial!\n"); 1133655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1134655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1135655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1136655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1137655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, we are unable to join the intervals. 1138655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tInterference!\n"); 1139655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = true; // May be possible to coalesce later. 1140655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1141655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1142655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1143655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing to a virtual register that is of a sub-register class of the 1144655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // other. Make sure the resulting register is set to the right register class. 1145655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isCrossClass()) { 1146655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCrossRCs; 1147c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI->setRegClass(CP.getDstReg(), CP.getNewRC()); 1148655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1149655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 115003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register copies can ease the register class constraints. 115103c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Make sure we attempt to inflate the register class of DstReg. 115203c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen if (!CP.isPhys() && RegClassInfo.isProperSubClass(CP.getNewRC())) 115303c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.push_back(CP.getDstReg()); 115403c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen 11557ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // CopyMI has been erased by joinIntervals at this point. Remove it from 11567ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // ErasedInstrs since copyCoalesceWorkList() won't add a successful join back 11577ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // to the work list. This keeps ErasedInstrs from growing needlessly. 11587ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen ErasedInstrs.erase(CopyMI); 1159655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1160ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Rewrite all SrcReg operands to DstReg. 1161ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Also update DstReg operands to include DstIdx if it is set. 1162ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx()) 1163ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getDstReg(), CP.getDstReg(), CP.getDstIdx()); 1164ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getSrcReg(), CP.getDstReg(), CP.getSrcIdx()); 1165655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1166e02a17c4efb843b8627f3d819c62f88a7f2fb457Lang Hames // SrcReg is guaranteed to be the register whose live interval that is 1167655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // being merged. 1168c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->removeInterval(CP.getSrcReg()); 1169655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1170655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update regalloc hint. 1171c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI->UpdateRegAllocHint(CP.getSrcReg(), CP.getDstReg(), *MF); 1172655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 117304ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen DEBUG({ 117403d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun dbgs() << "\tJoined. Result = "; 117503d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun if (CP.isPhys()) 117603d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun dbgs() << PrintReg(CP.getDstReg(), TRI); 117703d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun else 117804ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << LIS->getInterval(CP.getDstReg()); 117903d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun dbgs() << '\n'; 118004ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen }); 1181655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1182655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numJoins; 1183655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1184655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1185655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 118692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen/// Attempt joining with a reserved physreg. 118792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesenbool RegisterCoalescer::joinReservedPhysReg(CoalescerPair &CP) { 118892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isPhys() && "Must be a physreg copy"); 118914d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen assert(MRI->isReserved(CP.getDstReg()) && "Not a reserved register"); 119092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 119103d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun DEBUG(dbgs() << "\t\tRHS = " << RHS << '\n'); 119292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 119392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isFlipped() && RHS.containsOneValue() && 119492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen "Invalid join with reserved register"); 119592ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 119692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Optimization for reserved registers like ESP. We can only merge with a 119792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved physreg if RHS has a single value that is a copy of CP.DstReg(). 119892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // The live range of the reserved register will look like a set of dead defs 119992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // - we don't properly track the live range of reserved registers. 120092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 120192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Deny any overlapping intervals. This depends on all the reserved 120292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live ranges to look like dead defs. 1203241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen for (MCRegUnitIterator UI(CP.getDstReg(), TRI); UI.isValid(); ++UI) 1204241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen if (RHS.overlaps(LIS->getRegUnit(*UI))) { 1205241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tInterference: " << PrintRegUnit(*UI, TRI) << '\n'); 1206241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen return false; 120792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen } 1208241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen 120992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Skip any value computations, we are not adding new values to the 121092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved register. Also skip merging the live ranges, the reserved 121192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live range doesn't need to be accurate as long as all the 121292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // defs are there. 1213857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 1214e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen // Delete the identity copy. 1215e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen MachineInstr *CopyMI = MRI->getVRegDef(RHS.reg); 1216e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1217e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1218e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen 1219857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen // We don't track kills for reserved registers. 1220857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen MRI->clearKillFlags(CP.getSrcReg()); 1221857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 122292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen return true; 122392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen} 122492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 1225c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1226c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// Interference checking and interval joining 1227c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1228c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1229c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// In the easiest case, the two live ranges being joined are disjoint, and 1230c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// there is no interference to consider. It is quite common, though, to have 1231c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping live ranges, and we need to check if the interference can be 1232c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// resolved. 1233c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1234c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of a single SSA value forms a sub-tree of the dominator tree. 1235c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This means that two SSA values overlap if and only if the def of one value 1236c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is contained in the live range of the other value. As a special case, the 1237c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping values can be defined at the same index. 1238c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1239c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The interference from an overlapping def can be resolved in these cases: 1240c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1241c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1. Coalescable copies. The value is defined by a copy that would become an 1242c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// identity copy after joining SrcReg and DstReg. The copy instruction will 1243c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// be removed, and the value will be merged with the source value. 1244c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1245c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// There can be several copies back and forth, causing many values to be 1246c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merged into one. We compute a list of ultimate values in the joined live 1247c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// range as well as a mappings from the old value numbers. 1248c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1249c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 2. IMPLICIT_DEF. This instruction is only inserted to ensure all PHI 1250c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// predecessors have a live out value. It doesn't cause real interference, 1251c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// and can be merged into the value it overlaps. Like a coalescable copy, it 1252c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// can be erased after joining. 1253c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1254c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 3. Copy of external value. The overlapping def may be a copy of a value that 1255c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is already in the other register. This is like a coalescable copy, but 1256c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// the live range of the source register must be trimmed after erasing the 1257c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// copy instruction: 1258c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1259c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = COPY %ext 1260c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst = COPY %ext <-- Remove this COPY, trim the live range of %ext. 1261c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1262c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 4. Clobbering undefined lanes. Vector registers are sometimes built by 1263c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// defining one lane at a time: 1264c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1265c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub0<def,read-undef> = FOO 1266c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1267c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1268c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1269c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of %src overlaps the %dst value defined by FOO, but 1270c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merging %src into %dst:ssub1 is only going to clobber the ssub1 lane 1271c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// which was undef anyway. 1272c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1273c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The value mapping is more complicated in this case. The final live range 1274c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// will have different value numbers for both FOO and BAR, but there is no 1275c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// simple mapping from old to new values. It may even be necessary to add 1276c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// new PHI values. 1277c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1278c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 5. Clobbering dead lanes. A def may clobber a lane of a vector register that 1279c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is live, but never read. This can happen because we don't compute 1280c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// individual live ranges per lane. 1281c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1282c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst<def> = FOO 1283c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1284c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1285c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1286c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This kind of interference is only resolved locally. If the clobbered 1287c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// lane value escapes the block, the join is aborted. 1288c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1289c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesennamespace { 1290c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Track information about values in a single virtual register about to be 1291c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// joined. Objects of this class are always created in pairs - one for each 1292c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// side of the CoalescerPair. 1293c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenclass JoinVals { 1294c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LI; 1295c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1296c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Location of this register in the final joined register. 1297c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Either CP.DstIdx or CP.SrcIdx. 1298c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned SubIdx; 1299c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1300c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Values that will be present in the final live range. 1301c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &NewVNInfo; 1302c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1303c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &CP; 1304c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *LIS; 1305c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndexes *Indexes; 1306c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *TRI; 1307c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1308c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value number assignments. Maps value numbers in LI to entries in NewVNInfo. 1309c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is suitable for passing to LiveInterval::join(). 1310c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<int, 8> Assignments; 1311c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1312c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conflict resolution for overlapping values. 1313c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen enum ConflictResolution { 1314c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, simply keep this value. 1315c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Keep, 1316c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1317c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI and erase the defining instruction. 1318c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used for IMPLICIT_DEF, coalescable copies, and copies from external 1319c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values. 1320c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Erase, 1321c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1322c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI but keep the defining instruction. 1323c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is for the special case where OtherVNI is defined by the same 1324c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // instruction. 1325c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Merge, 1326c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1327c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, and have it replace OtherVNI where possible. This 1328c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // complicates value mapping since OtherVNI maps to two different values 1329c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // before and after this def. 1330c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used when clobbering undefined or dead lanes. 1331c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Replace, 1332c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1333c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolved conflict. Visit later when all values have been mapped. 1334c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Unresolved, 1335c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1336c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolvable conflict. Abort the join. 1337c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Impossible 1338c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1339c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1340c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Per-value info for LI. The lane bit masks are all relative to the final 1341c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // joined register, so they can be compared directly between SrcReg and 1342c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // DstReg. 1343c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen struct Val { 1344c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution Resolution; 1345c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1346c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes written by this def, 0 for unanalyzed values. 1347c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned WriteLanes; 1348c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1349c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes with defined values in this register. Other lanes are undef and 1350c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // safe to clobber. 1351c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned ValidLanes; 1352c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1353c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in LI being redefined by this def. 1354c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *RedefVNI; 1355c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1356c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in the other live range that overlaps this def, if any. 1357c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *OtherVNI; 1358c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1359251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Is this value an IMPLICIT_DEF that can be erased? 1360251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1361251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF values should only exist at the end of a basic block that 1362251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // is a predecessor to a phi-value. These IMPLICIT_DEF instructions can be 1363251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // safely erased if they are overlapping a live value in the other live 1364251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // interval. 1365251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1366251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Weird control flow graphs and incomplete PHI handling in 1367251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // ProcessImplicitDefs can very rarely create IMPLICIT_DEF values with 1368251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // longer live ranges. Such IMPLICIT_DEF values should be treated like 1369251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // normal values. 1370251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool ErasableImplicitDef; 1371795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 13722df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True when the live range of this value will be pruned because of an 13732df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // overlapping CR_Replace value in the other live range. 13742df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool Pruned; 13752df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 13762df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True once Pruned above has been computed. 13772df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool PrunedComputed; 13782df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 1379c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val() : Resolution(CR_Keep), WriteLanes(0), ValidLanes(0), 1380dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RedefVNI(nullptr), OtherVNI(nullptr), ErasableImplicitDef(false), 1381251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Pruned(false), PrunedComputed(false) {} 1382c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1383c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool isAnalyzed() const { return WriteLanes != 0; } 1384c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1385c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1386c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One entry per value number in LI. 1387c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<Val, 8> Vals; 1388c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1389c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned computeWriteLanes(const MachineInstr *DefMI, bool &Redef); 1390c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *stripCopies(VNInfo *VNI); 1391c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution analyzeValue(unsigned ValNo, JoinVals &Other); 1392c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void computeAssignment(unsigned ValNo, JoinVals &Other); 1393d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool taintExtent(unsigned, unsigned, JoinVals&, 1394d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> >&); 1395d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool usesLanes(MachineInstr *MI, unsigned, unsigned, unsigned); 13962df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool isPrunedValue(unsigned ValNo, JoinVals &Other); 1397c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1398c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenpublic: 1399c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals(LiveInterval &li, unsigned subIdx, 1400c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &newVNInfo, 1401c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &cp, 1402c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *lis, 1403c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *tri) 1404c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen : LI(li), SubIdx(subIdx), NewVNInfo(newVNInfo), CP(cp), LIS(lis), 1405c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Indexes(LIS->getSlotIndexes()), TRI(tri), 1406c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments(LI.getNumValNums(), -1), Vals(LI.getNumValNums()) 1407c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen {} 1408c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1409c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Analyze defs in LI and compute a value mapping in NewVNInfo. 1410c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1411c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool mapValues(JoinVals &Other); 1412c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1413c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Try to resolve conflicts that require all values to be mapped. 1414c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1415c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool resolveConflicts(JoinVals &Other); 1416c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 141787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// Prune the live range of values in Other.LI where they would conflict with 141887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// CR_Replace values in LI. Collect end points for restoring the live range 141987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// after joining. 142087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen void pruneValues(JoinVals &Other, SmallVectorImpl<SlotIndex> &EndPoints); 142187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1422c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Erase any machine instructions that have been coalesced away. 1423c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add erased instructions to ErasedInstrs. 1424c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add foreign virtual registers to ShrinkRegs if their live range ended at 1425c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// the erased instrs. 1426c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1427c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs); 1428c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1429c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Get the value assignments suitable for passing to LiveInterval::join. 143056acf63e35440068935bca999d19a81f76e876d6Jakob Stoklund Olesen const int *getAssignments() const { return Assignments.data(); } 1431c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen}; 1432c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} // end anonymous namespace 1433c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1434c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the bitmask of lanes actually written by DefMI. 1435c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Set Redef if there are any partial register definitions that depend on the 1436c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// previous value of the register. 1437c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenunsigned JoinVals::computeWriteLanes(const MachineInstr *DefMI, bool &Redef) { 1438c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned L = 0; 1439c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (ConstMIOperands MO(DefMI); MO.isValid(); ++MO) { 1440c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MO->isReg() || MO->getReg() != LI.reg || !MO->isDef()) 1441c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 144221caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen L |= TRI->getSubRegIndexLaneMask( 144321caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg())); 1444c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (MO->readsReg()) 1445c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Redef = true; 1446c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1447c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return L; 1448c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1449c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1450c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Find the ultimate value that VNI was copied from. 1451c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenVNInfo *JoinVals::stripCopies(VNInfo *VNI) { 1452c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!VNI->isPHIDef()) { 1453c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(VNI->def); 1454c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(MI && "No defining instruction"); 1455c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MI->isFullCopy()) 1456c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1457c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1458c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 1459c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 14605649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun LiveQueryResult LRQ = LIS->getInterval(Reg).Query(VNI->def); 1461c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LRQ.valueIn()) 1462c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1463c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNI = LRQ.valueIn(); 1464c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1465c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return VNI; 1466c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1467c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1468c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Analyze ValNo in this live range, and set all fields of Vals[ValNo]. 1469c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Return a conflict resolution when possible, but leave the hard cases as 1470c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// CR_Unresolved. 1471c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Recursively calls computeAssignment() on this and Other, guaranteeing that 1472c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// both OtherVNI and RedefVNI have been analyzed and mapped before returning. 1473c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// The recursion always goes upwards in the dominator tree, making loops 1474c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// impossible. 1475c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::ConflictResolution 1476c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::analyzeValue(unsigned ValNo, JoinVals &Other) { 1477c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1478c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!V.isAnalyzed() && "Value has already been analyzed!"); 1479c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1480c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isUnused()) { 1481c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.WriteLanes = ~0u; 1482c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1483c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1484c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1485c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Get the instruction defining this value, compute the lanes written. 1486dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MachineInstr *DefMI = nullptr; 1487c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) { 1488c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conservatively assume that all lanes in a PHI are valid. 1489c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = TRI->getSubRegIndexLaneMask(SubIdx); 1490c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } else { 1491c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DefMI = Indexes->getInstructionFromIndex(VNI->def); 1492c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool Redef = false; 1493c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = computeWriteLanes(DefMI, Redef); 1494c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1495c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // If this is a read-modify-write instruction, there may be more valid 1496c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // lanes than the ones written by this instruction. 1497c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This only covers partial redef operands. DefMI may have normal use 1498c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // operands reading the register. They don't contribute valid lanes. 1499c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1500c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This adds ssub1 to the set of valid lanes in %src: 1501c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1502c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def> = FOO 1503c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1504c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This leaves only ssub1 valid, making any other lanes undef: 1505c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1506c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def,read-undef> = FOO %src:ssub2 1507c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1508c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The <read-undef> flag on the def operand means that old lane values are 1509c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // not important. 1510c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Redef) { 15115649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun V.RedefVNI = LI.Query(VNI->def).valueIn(); 1512c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.RedefVNI && "Instruction is reading nonexistent value"); 1513c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(V.RedefVNI->id, Other); 1514c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes |= Vals[V.RedefVNI->id].ValidLanes; 1515c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1516c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1517c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // An IMPLICIT_DEF writes undef values. 1518795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (DefMI->isImplicitDef()) { 1519251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // We normally expect IMPLICIT_DEF values to be live only until the end 1520251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // of their block. If the value is really live longer and gets pruned in 1521251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // another block, this flag is cleared again. 1522251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen V.ErasableImplicitDef = true; 1523c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes; 1524795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1525c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1526c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1527c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Find the value in Other that overlaps VNI->def, if any. 15285649e25ce86b9d89d228ae7c392413571b0f8c19Matthias Braun LiveQueryResult OtherLRQ = Other.LI.Query(VNI->def); 1529c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1530c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // It is possible that both values are defined by the same instruction, or 1531c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // the values are PHIs defined in the same block. When that happens, the two 1532c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values should be merged into one, but not into any preceding value. 1533c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The first value defined or visited gets CR_Keep, the other gets CR_Merge. 1534c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNInfo *OtherVNI = OtherLRQ.valueDefined()) { 1535c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ"); 1536c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1537c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One value stays, the other is merged. Keep the earlier one, or the first 1538c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // one we see. 1539c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherVNI->def < VNI->def) 1540c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(OtherVNI->id, *this); 1541c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else if (VNI->def < OtherVNI->def && OtherLRQ.valueIn()) { 1542c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is an early-clobber def overlapping a live-in value in the other 1543c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // register. Not mergeable. 1544c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1545c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Impossible; 1546c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1547c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherVNI; 1548c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &OtherV = Other.Vals[OtherVNI->id]; 1549c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, check for conflicts when analyzing OtherVNI. 1550c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!OtherV.isAnalyzed()) 1551c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1552e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Both sides have been analyzed now. 1553e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1554e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1555e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen if (VNI->isPHIDef()) 1556e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Merge; 1557c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.ValidLanes & OtherV.ValidLanes) 1558d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Overlapping lanes can't be resolved. 1559d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1560c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else 1561c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Merge; 1562c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1563c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1564c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No simultaneous def. Is Other live at the def? 1565c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1566c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!V.OtherVNI) 1567c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, no conflict. 1568c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1569c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1570c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ"); 1571c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1572c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // We have overlapping values, or possibly a kill of Other. 1573c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursively compute assignments up the dominator tree. 1574c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(V.OtherVNI->id, *this); 1575251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Val &OtherV = Other.Vals[V.OtherVNI->id]; 1576251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen 1577251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Check if OtherV is an IMPLICIT_DEF that extends beyond its basic block. 1578251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // This shouldn't normally happen, but ProcessImplicitDefs can leave such 1579251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF instructions behind, and there is nothing wrong with it 1580251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // technically. 1581251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1582251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // WHen it happens, treat that IMPLICIT_DEF as a normal value, and don't try 1583251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // to erase the IMPLICIT_DEF instruction. 1584251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (OtherV.ErasableImplicitDef && DefMI && 1585251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DefMI->getParent() != Indexes->getMBBFromIndex(V.OtherVNI->def)) { 1586251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DEBUG(dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def 1587251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << " extends into BB#" << DefMI->getParent()->getNumber() 1588251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << ", keeping it.\n"); 1589251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.ErasableImplicitDef = false; 1590251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen } 1591c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1592e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1593e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1594c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) 1595e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Replace; 1596c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1597c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Check for simple erasable conflicts. 1598c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isImplicitDef()) 1599c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1600c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1601c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Include the non-conflict where DefMI is a coalescable copy that kills 1602c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // OtherVNI. We still want the copy erased and value numbers merged. 1603c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (CP.isCoalescable(DefMI)) { 1604c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some of the lanes copied from OtherVNI may be undef, making them undef 1605c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // here too. 160687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes | OtherV.ValidLanes; 1607c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1608c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1609c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1610c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This may not be a real conflict if DefMI simply kills Other and defines 1611c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // VNI. 1612c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherLRQ.isKill() && OtherLRQ.endPoint() <= VNI->def) 1613c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1614c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1615c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Handle the case where VNI and OtherVNI can be proven to be identical: 1616c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1617c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %other = COPY %ext 1618c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %this = COPY %ext <-- Erase this copy 1619c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1620c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isFullCopy() && !CP.isPartial() && 1621c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen stripCopies(VNI) == stripCopies(V.OtherVNI)) 1622c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1623c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 162487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // If the lanes written by this instruction were all undef in OtherVNI, it is 162587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // still safe to join the live ranges. This can't be done with a simple value 162687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // mapping, though - OtherVNI will map to multiple values: 162787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 162887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 1 %dst:ssub0 = FOO <-- OtherVNI 162987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 2 %src = BAR <-- VNI 163087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 3 %dst:ssub1 = COPY %src<kill> <-- Eliminate this copy. 163187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 4 BAZ %dst<kill> 163287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 5 QUUX %src<kill> 163387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 163487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Here OtherVNI will map to itself in [1;2), but to VNI in [2;5). CR_Replace 163587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // handles this complex value mapping. 163687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if ((V.WriteLanes & OtherV.ValidLanes) == 0) 163787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return CR_Replace; 163887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1639163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // If the other live range is killed by DefMI and the live ranges are still 1640163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // overlapping, it must be because we're looking at an early clobber def: 1641163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1642163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // %dst<def,early-clobber> = ASM %src<kill> 1643163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1644163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // In this case, it is illegal to merge the two live ranges since the early 1645163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // clobber def would clobber %src before it was read. 1646163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen if (OtherLRQ.isKill()) { 1647163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // This case where the def doesn't overlap the kill is handled above. 1648163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen assert(VNI->def.isEarlyClobber() && 1649163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen "Only early clobber defs can overlap a kill"); 1650163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen return CR_Impossible; 1651163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen } 1652163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen 1653d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is clobbering live lanes in OtherVNI, but there is still the 1654d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // possibility that no instructions actually read the clobbered lanes. 1655d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // If we're clobbering all the lanes in OtherVNI, at least one must be read. 1656d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Otherwise Other.LI wouldn't be live here. 1657d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if ((TRI->getSubRegIndexLaneMask(Other.SubIdx) & ~V.WriteLanes) == 0) 1658d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1659d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1660d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // We need to verify that no instructions are reading the clobbered lanes. To 1661d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // save compile time, we'll only check that locally. Don't allow the tainted 1662d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // value to escape the basic block. 1663d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1664d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (OtherLRQ.endPoint() >= Indexes->getMBBEndIdx(MBB)) 1665d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1666d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1667d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // There are still some things that could go wrong besides clobbered lanes 1668d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // being read, for example OtherVNI may be only partially redefined in MBB, 1669d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // and some clobbered lanes could escape the block. Save this analysis for 1670d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // resolveConflicts() when all values have been mapped. We need to know 1671d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // RedefVNI and WriteLanes for any later defs in MBB, and we can't compute 1672d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // that now - the recursive analyzeValue() calls must go upwards in the 1673d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // dominator tree. 1674d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Unresolved; 1675c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1676c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1677c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the value assignment for ValNo in LI. 1678c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// This may be called recursively by analyzeValue(), but never for a ValNo on 1679c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// the stack. 1680c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::computeAssignment(unsigned ValNo, JoinVals &Other) { 1681c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1682c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.isAnalyzed()) { 1683c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursion should always move up the dominator tree, so ValNo is not 1684c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // supposed to reappear before it has been assigned. 1685c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Assignments[ValNo] != -1 && "Bad recursion?"); 1686c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return; 1687c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1688c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen switch ((V.Resolution = analyzeValue(ValNo, Other))) { 1689c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Erase: 1690c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Merge: 1691c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this ValNo into OtherVNI. 1692c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't merge."); 1693c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Other.Vals[V.OtherVNI->id].isAnalyzed() && "Missing recursion"); 1694c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = Other.Assignments[V.OtherVNI->id]; 1695c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tmerge " << PrintReg(LI.reg) << ':' << ValNo << '@' 1696c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << LI.getValNumInfo(ValNo)->def << " into " 1697c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << PrintReg(Other.LI.reg) << ':' << V.OtherVNI->id << '@' 1698c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << V.OtherVNI->def << " --> @" 1699c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << NewVNInfo[Assignments[ValNo]]->def << '\n'); 1700c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 17012df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Replace: 17022df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 17032df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // The other value is going to be pruned if this join is successful. 17042df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't prune"); 17052df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Other.Vals[V.OtherVNI->id].Pruned = true; 17062df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Fall through. 1707c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen default: 1708c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This value number needs to go in the final joined live range. 1709c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = NewVNInfo.size(); 1710c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen NewVNInfo.push_back(LI.getValNumInfo(ValNo)); 1711c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1712c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1713c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1714c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1715c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::mapValues(JoinVals &Other) { 1716c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1717c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(i, Other); 1718c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Vals[i].Resolution == CR_Impossible) { 1719c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tinterference at " << PrintReg(LI.reg) << ':' << i 1720c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1721c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1722c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1723c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1724c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1725c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1726c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1727d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Assuming ValNo is going to clobber some valid lanes in Other.LI, compute 1728d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// the extent of the tainted lanes in the block. 1729d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1730d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Multiple values in Other.LI can be affected since partial redefinitions can 1731d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// preserve previously tainted lanes. 1732d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1733d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1 %dst = VLOAD <-- Define all lanes in %dst 1734d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 2 %src = FOO <-- ValNo to be joined with %dst:ssub0 1735d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 3 %dst:ssub1 = BAR <-- Partial redef doesn't clear taint in ssub0 1736d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 4 %dst:ssub0 = COPY %src <-- Conflict resolved, ssub0 wasn't read 1737d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1738d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// For each ValNo in Other that is affected, add an (EndIndex, TaintedLanes) 1739d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// entry to TaintedVals. 1740d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1741d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Returns false if the tainted lanes extend beyond the basic block. 1742d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals:: 1743d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesentaintExtent(unsigned ValNo, unsigned TaintedLanes, JoinVals &Other, 1744d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> > &TaintExtent) { 1745d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1746d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1747d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex MBBEnd = Indexes->getMBBEndIdx(MBB); 1748d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1749d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Scan Other.LI from VNI.def to MBBEnd. 1750d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LiveInterval::iterator OtherI = Other.LI.find(VNI->def); 1751d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(OtherI != Other.LI.end() && "No conflict?"); 1752d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen do { 1753d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // OtherI is pointing to a tainted value. Abort the join if the tainted 1754d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // lanes escape the block. 1755d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex End = OtherI->end; 1756d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End >= MBBEnd) { 1757d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints global " << PrintReg(Other.LI.reg) << ':' 1758d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start << '\n'); 1759d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1760d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1761d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints local " << PrintReg(Other.LI.reg) << ':' 1762d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start 1763d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << " to " << End << '\n'); 1764d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // A dead def is not a problem. 1765d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End.isDead()) 1766d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1767d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintExtent.push_back(std::make_pair(End, TaintedLanes)); 1768d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1769d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Check for another def in the MBB. 1770d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++OtherI == Other.LI.end() || OtherI->start >= MBBEnd) 1771d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1772d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1773d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Lanes written by the new def are no longer tainted. 1774d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OV = Other.Vals[OtherI->valno->id]; 1775d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes &= ~OV.WriteLanes; 1776d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!OV.RedefVNI) 1777d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1778d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } while (TaintedLanes); 1779d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1780d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1781d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1782d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Return true if MI uses any of the given Lanes from Reg. 1783d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// This does not include partial redefinitions of Reg. 1784d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals::usesLanes(MachineInstr *MI, unsigned Reg, unsigned SubIdx, 1785d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned Lanes) { 1786d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (MI->isDebugValue()) 1787d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1788d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for (ConstMIOperands MO(MI); MO.isValid(); ++MO) { 1789d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->isReg() || MO->isDef() || MO->getReg() != Reg) 1790d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 1791d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->readsReg()) 1792d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 179321caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen if (Lanes & TRI->getSubRegIndexLaneMask( 179421caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg()))) 1795d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1796d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1797d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1798d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1799d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1800c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::resolveConflicts(JoinVals &Other) { 1801c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1802d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Val &V = Vals[i]; 1803d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert (V.Resolution != CR_Impossible && "Unresolvable conflict"); 1804d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (V.Resolution != CR_Unresolved) 1805c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 1806c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tconflict at " << PrintReg(LI.reg) << ':' << i 1807c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1808d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneConflicts; 1809d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(V.OtherVNI && "Inconsistent conflict resolution."); 1810d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(i); 1811d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OtherV = Other.Vals[V.OtherVNI->id]; 1812d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1813d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is known to clobber some lanes in OtherVNI. If we go ahead with the 1814d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // join, those lanes will be tainted with a wrong value. Get the extent of 1815d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // the tainted lanes. 1816d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintedLanes = V.WriteLanes & OtherV.ValidLanes; 1817d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVector<std::pair<SlotIndex, unsigned>, 8> TaintExtent; 1818d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!taintExtent(i, TaintedLanes, Other, TaintExtent)) 1819d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Tainted lanes would extend beyond the basic block. 1820d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1821d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1822d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!TaintExtent.empty() && "There should be at least one conflict."); 1823d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1824d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Now look at the instructions from VNI->def to TaintExtent (inclusive). 1825d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1826d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock::iterator MI = MBB->begin(); 1827d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!VNI->isPHIDef()) { 1828d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MI = Indexes->getInstructionFromIndex(VNI->def); 1829d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // No need to check the instruction defining VNI for reads. 1830d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1831d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1832d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, TaintExtent.front().first) && 1833d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen "Interference ends on VNI->def. Should have been handled earlier"); 1834d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineInstr *LastMI = 1835d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Indexes->getInstructionFromIndex(TaintExtent.front().first); 1836d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1837d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintNum = 0; 1838d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for(;;) { 1839d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(MI != MBB->end() && "Bad LastMI"); 1840d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (usesLanes(MI, Other.LI.reg, Other.SubIdx, TaintedLanes)) { 1841d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttainted lanes used by: " << *MI); 1842d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1843d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1844d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // LastMI is the last instruction to use the current value. 1845d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (&*MI == LastMI) { 1846d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++TaintNum == TaintExtent.size()) 1847d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1848d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LastMI = Indexes->getInstructionFromIndex(TaintExtent[TaintNum].first); 1849d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1850d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes = TaintExtent[TaintNum].second; 1851d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1852d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1853d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1854d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1855d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // The tainted lanes are unused. 1856d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen V.Resolution = CR_Replace; 1857d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneResolves; 1858c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1859c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1860c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1861c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 18622df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// Determine if ValNo is a copy of a value number in LI or Other.LI that will 18632df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// be pruned: 18642df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 18652df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src 18662df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %src = COPY %dst <-- This value to be pruned. 18672df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src <-- This value is a copy of a pruned value. 18682df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 18692df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesenbool JoinVals::isPrunedValue(unsigned ValNo, JoinVals &Other) { 18702df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Val &V = Vals[ValNo]; 18712df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Pruned || V.PrunedComputed) 18722df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18732df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18742df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Resolution != CR_Erase && V.Resolution != CR_Merge) 18752df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18762df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18772df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Follow copies up the dominator tree and check if any intermediate value 18782df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // has been pruned. 18792df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.PrunedComputed = true; 18802df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.Pruned = Other.isPrunedValue(V.OtherVNI->id, *this); 18812df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18822df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen} 18832df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 188487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesenvoid JoinVals::pruneValues(JoinVals &Other, 188587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVectorImpl<SlotIndex> &EndPoints) { 188687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 188787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 18882df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen switch (Vals[i].Resolution) { 18892df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Keep: 18902df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1891795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Replace: { 18922df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value takes precedence over the value in Other.LI. 18932df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&Other.LI, Def, &EndPoints); 1894795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Check if we're replacing an IMPLICIT_DEF value. The IMPLICIT_DEF 1895795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // instructions are only inserted to provide a live-out value for PHI 1896795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // predecessors, so the instruction should simply go away once its value 1897795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // has been replaced. 1898795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Val &OtherV = Other.Vals[Vals[i].OtherVNI->id]; 1899251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool EraseImpDef = OtherV.ErasableImplicitDef && 1900251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.Resolution == CR_Keep; 1901d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!Def.isBlock()) { 1902795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove <def,read-undef> flags. This def is now a partial redef. 1903d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // Also remove <def,dead> flags since the joined live range will 1904d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // continue past this instruction. 190583ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen for (MIOperands MO(Indexes->getInstructionFromIndex(Def)); 190683ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen MO.isValid(); ++MO) 1907d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (MO->isReg() && MO->isDef() && MO->getReg() == LI.reg) { 1908d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsUndef(EraseImpDef); 1909d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsDead(false); 1910d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen } 1911795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // This value will reach instructions below, but we need to make sure 1912795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // the live range also reaches the instruction at Def. 1913d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!EraseImpDef) 1914d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen EndPoints.push_back(Def); 191527cb347d0e765175efb2c4d388bcbba84cf1b95eJakob Stoklund Olesen } 19162df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned " << PrintReg(Other.LI.reg) << " at " << Def 19172df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << ": " << Other.LI << '\n'); 19182df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1919795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 19202df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Erase: 19212df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Merge: 19222df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (isPrunedValue(i, Other)) { 19232df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value is ultimately a copy of a pruned value in LI or Other.LI. 19242df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // We can no longer trust the value mapping computed by 19252df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // computeAssignment(), the value that was originally copied could have 19262df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // been replaced. 19272df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&LI, Def, &EndPoints); 19282df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned all of " << PrintReg(LI.reg) << " at " 19292df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << Def << ": " << LI << '\n'); 19302df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 19312df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 19322df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 19332df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Impossible: 19342df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen llvm_unreachable("Unresolved conflicts"); 19352df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 193687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen } 193787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen} 193887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1939c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1940c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs) { 1941c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1942795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Get the def location before markUnused() below invalidates it. 1943c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 1944795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen switch (Vals[i].Resolution) { 1945795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Keep: 1946795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // If an IMPLICIT_DEF value is pruned, it doesn't serve a purpose any 1947795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // longer. The IMPLICIT_DEF instructions are only inserted by 1948795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // PHIElimination to guarantee that all PHI predecessors have a value. 1949251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (!Vals[i].ErasableImplicitDef || !Vals[i].Pruned) 1950795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1951795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove value number i from LI. Note that this VNInfo is still present 1952795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // in NewVNInfo, so it will appear as an unused value number in the final 1953795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // joined interval. 1954795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.getValNumInfo(i)->markUnused(); 1955795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.removeValNo(LI.getValNumInfo(i)); 1956795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tremoved " << i << '@' << Def << ": " << LI << '\n'); 1957795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // FALL THROUGH. 1958795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 1959795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Erase: { 1960795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(Def); 1961795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen assert(MI && "No instruction to erase"); 1962795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (MI->isCopy()) { 1963795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1964795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg) && 1965795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Reg != CP.getSrcReg() && Reg != CP.getDstReg()) 1966795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ShrinkRegs.push_back(Reg); 1967795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1968795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ErasedInstrs.insert(MI); 1969795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\terased:\t" << Def << '\t' << *MI); 1970795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(MI); 1971795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MI->eraseFromParent(); 1972795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1973795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1974795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen default: 1975795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1976c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1977c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1978c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1979c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1980c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool RegisterCoalescer::joinVirtRegs(CoalescerPair &CP) { 1981c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<VNInfo*, 16> NewVNInfo; 1982c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 1983c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LHS = LIS->getInterval(CP.getDstReg()); 1984c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals RHSVals(RHS, CP.getSrcIdx(), NewVNInfo, CP, LIS, TRI); 1985c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals LHSVals(LHS, CP.getDstIdx(), NewVNInfo, CP, LIS, TRI); 1986c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 198703d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun DEBUG(dbgs() << "\t\tRHS = " << RHS 198803d9609c6154ed91daefb4e4f89b7298c11961f3Matthias Braun << "\n\t\tLHS = " << LHS 1989c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '\n'); 1990c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1991c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // First compute NewVNInfo and the simple value mappings. 1992c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Detect impossible conflicts early. 1993c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.mapValues(RHSVals) || !RHSVals.mapValues(LHSVals)) 1994c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1995c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1996c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some conflicts can only be resolved after all values have been mapped. 1997c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.resolveConflicts(RHSVals) || !RHSVals.resolveConflicts(LHSVals)) 1998c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1999c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 2000c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // All clear, the live ranges can be merged. 2001c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 200287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // The merging algorithm in LiveInterval::join() can't handle conflicting 200387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // value mappings, so we need to remove any live ranges that overlap a 200487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace resolution. Collect a set of end points that can be used to 200587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // restore the live range after joining. 200687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVector<SlotIndex, 8> EndPoints; 200787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen LHSVals.pruneValues(RHSVals, EndPoints); 200887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen RHSVals.pruneValues(LHSVals, EndPoints); 200987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 2010c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Erase COPY and IMPLICIT_DEF instructions. This may cause some external 2011c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // registers to require trimming. 2012c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<unsigned, 8> ShrinkRegs; 2013c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 2014c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen RHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 2015c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!ShrinkRegs.empty()) 2016c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LIS->shrinkToUses(&LIS->getInterval(ShrinkRegs.pop_back_val())); 2017c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 2018c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Join RHS into LHS. 20191920156982643a1c5c28af6f4684580b516eb597Matthias Braun LHS.join(RHS, LHSVals.getAssignments(), RHSVals.getAssignments(), NewVNInfo); 2020c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 2021c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Kill flags are going to be wrong if the live ranges were overlapping. 2022c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Eventually, we should simply clear all kill flags when computing live 2023c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // ranges. They are reinserted after register allocation. 2024c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(LHS.reg); 2025c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(RHS.reg); 202687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 202787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if (EndPoints.empty()) 202887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return true; 202987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 203087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Recompute the parts of the live range we had to remove because of 203187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace conflicts. 203287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen DEBUG(dbgs() << "\t\trestoring liveness to " << EndPoints.size() 203387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen << " points: " << LHS << '\n'); 2034e25dde550baec1f79caf2fc06edd74e7ae6ffa33Matthias Braun LIS->extendToIndices(LHS, EndPoints); 2035c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 2036c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 2037c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 20389790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinIntervals - Attempt to join these two intervals. On failure, this 2039655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// returns false. 20409790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinIntervals(CoalescerPair &CP) { 2041cdcdfd2cab67366b1debbe36bf46c29f7fecda67Jakob Stoklund Olesen return CP.isPhys() ? joinReservedPhysReg(CP) : joinVirtRegs(CP); 2042655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2043655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2044655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolanamespace { 2045cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// Information concerning MBB coalescing priority. 2046cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trickstruct MBBPriorityInfo { 2047cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MachineBasicBlock *MBB; 2048cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned Depth; 2049cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick bool IsSplit; 2050cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2051cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MBBPriorityInfo(MachineBasicBlock *mbb, unsigned depth, bool issplit) 2052cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick : MBB(mbb), Depth(depth), IsSplit(issplit) {} 2053cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick}; 2054cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick} 2055655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2056cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// C-style comparator that sorts first based on the loop depth of the basic 2057cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// block (the unsigned), and then on the MBB number. 2058cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// 2059cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// EnableGlobalCopies assumes that the primary sort key is loop depth. 20600d293e45b66c742fdbc3998209bb20ed6c5806bfBenjamin Kramerstatic int compareMBBPriority(const MBBPriorityInfo *LHS, 20610d293e45b66c742fdbc3998209bb20ed6c5806bfBenjamin Kramer const MBBPriorityInfo *RHS) { 2062cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Deeper loops first 2063cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->Depth != RHS->Depth) 2064cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->Depth > RHS->Depth ? -1 : 1; 2065cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2066cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Try to unsplit critical edges next. 2067cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->IsSplit != RHS->IsSplit) 2068cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->IsSplit ? -1 : 1; 2069cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2070cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Prefer blocks that are more connected in the CFG. This takes care of 2071cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // the most difficult copies first while intervals are short. 2072cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cl = LHS->MBB->pred_size() + LHS->MBB->succ_size(); 2073cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cr = RHS->MBB->pred_size() + RHS->MBB->succ_size(); 2074cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (cl != cr) 2075cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return cl > cr ? -1 : 1; 2076cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2077cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // As a last resort, sort by block number. 2078cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->MBB->getNumber() < RHS->MBB->getNumber() ? -1 : 1; 2079655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2080655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2081265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick/// \returns true if the given copy uses or defines a local live range. 2082265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickstatic bool isLocalCopy(MachineInstr *Copy, const LiveIntervals *LIS) { 2083265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!Copy->isCopy()) 2084265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2085265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2086ff197dfcf9ac50a62d21e0c30644e09ca3bb92f5Andrew Trick if (Copy->getOperand(1).isUndef()) 2087ff197dfcf9ac50a62d21e0c30644e09ca3bb92f5Andrew Trick return false; 2088ff197dfcf9ac50a62d21e0c30644e09ca3bb92f5Andrew Trick 2089265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned SrcReg = Copy->getOperand(1).getReg(); 2090265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned DstReg = Copy->getOperand(0).getReg(); 2091265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (TargetRegisterInfo::isPhysicalRegister(SrcReg) 2092265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || TargetRegisterInfo::isPhysicalRegister(DstReg)) 2093265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2094265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2095265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return LIS->intervalIsInOneMBB(LIS->getInterval(SrcReg)) 2096265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || LIS->intervalIsInOneMBB(LIS->getInterval(DstReg)); 2097265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2098265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2099b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Try joining WorkList copies starting from index From. 2100b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Null out any successful joins. 2101265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickbool RegisterCoalescer:: 2102265058d9239e6867d06dc8aa40db5f33390abd17Andrew TrickcopyCoalesceWorkList(MutableArrayRef<MachineInstr*> CurrList) { 2103b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Progress = false; 2104265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = CurrList.size(); i != e; ++i) { 2105265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!CurrList[i]) 2106b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen continue; 2107bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Skip instruction pointers that have already been erased, for example by 2108bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // dead code elimination. 2109265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (ErasedInstrs.erase(CurrList[i])) { 2110dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CurrList[i] = nullptr; 2111bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen continue; 2112bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 2113b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Again = false; 2114265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick bool Success = joinCopy(CurrList[i], Again); 2115b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen Progress |= Success; 2116b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen if (Success || !Again) 2117dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CurrList[i] = nullptr; 2118b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen } 2119b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen return Progress; 2120b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen} 2121b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 21229790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid 2123b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund OlesenRegisterCoalescer::copyCoalesceInMBB(MachineBasicBlock *MBB) { 2124655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << MBB->getName() << ":\n"); 2125655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2126846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // Collect all copy-like instructions in MBB. Don't start coalescing anything 2127846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // yet, it might invalidate the iterator. 2128b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen const unsigned PrevSize = WorkList.size(); 2129ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (JoinGlobalCopies) { 2130265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Coalesce copies bottom-up to coalesce local defs before local uses. They 2131265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // are not inherently easier to resolve, but slightly preferable until we 2132265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // have local live range splitting. In particular this is required by 2133265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // cmp+jmp macro fusion. 21340db6df0d963a8eee763fd878a72c3153501491c0Andrew Trick for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end(); 21350db6df0d963a8eee763fd878a72c3153501491c0Andrew Trick MII != E; ++MII) { 2136265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!MII->isCopyLike()) 2137265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick continue; 2138265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (isLocalCopy(&(*MII), LIS)) 2139265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.push_back(&(*MII)); 2140265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else 2141265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(&(*MII)); 2142265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2143265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2144265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else { 2145265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end(); 2146265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MII != E; ++MII) 2147265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (MII->isCopyLike()) 2148265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(MII); 2149265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2150b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // Try coalescing the collected copies immediately, and remove the nulls. 2151b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // This prevents the WorkList from getting too large since most copies are 2152b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // joinable on the first attempt. 2153265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MutableArrayRef<MachineInstr*> 2154265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList(WorkList.begin() + PrevSize, WorkList.end()); 2155265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (copyCoalesceWorkList(CurrList)) 2156b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.erase(std::remove(WorkList.begin() + PrevSize, WorkList.end(), 2157dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (MachineInstr*)nullptr), WorkList.end()); 2158655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2159655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2160265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickvoid RegisterCoalescer::coalesceLocals() { 2161265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick copyCoalesceWorkList(LocalWorkList); 2162265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned j = 0, je = LocalWorkList.size(); j != je; ++j) { 2163265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (LocalWorkList[j]) 2164265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(LocalWorkList[j]); 2165265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2166265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.clear(); 2167265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2168265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 21699790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid RegisterCoalescer::joinAllIntervals() { 2170655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** JOINING INTERVALS ***********\n"); 2171265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around."); 2172655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2173f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick std::vector<MBBPriorityInfo> MBBs; 21748762a6bc2b83dfc11e784772311ad0b8fa5211e2Jakub Staszak MBBs.reserve(MF->size()); 2175f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick for (MachineFunction::iterator I = MF->begin(), E = MF->end();I != E;++I){ 2176f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MachineBasicBlock *MBB = I; 2177f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MBBs.push_back(MBBPriorityInfo(MBB, Loops->getLoopDepth(MBB), 2178cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick JoinSplitEdges && isSplitEdge(MBB))); 2179655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 2180cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick array_pod_sort(MBBs.begin(), MBBs.end(), compareMBBPriority); 2181f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick 2182f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick // Coalesce intervals in MBB priority order. 2183265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned CurrDepth = UINT_MAX; 2184265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = MBBs.size(); i != e; ++i) { 2185265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Try coalescing the collected local copies for deeper loops. 2186c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick if (JoinGlobalCopies && MBBs[i].Depth < CurrDepth) { 2187265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2188c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick CurrDepth = MBBs[i].Depth; 2189c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick } 2190f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick copyCoalesceInMBB(MBBs[i].MBB); 2191265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2192265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2193655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2194655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Joining intervals can allow other intervals to be joined. Iteratively join 2195655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // until we make no progress. 2196265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick while (copyCoalesceWorkList(WorkList)) 2197b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /* empty */ ; 2198655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2199655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 22005b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::releaseMemory() { 2201bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.clear(); 2202b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.clear(); 2203bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.clear(); 220403c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.clear(); 2205655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2206655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 22075b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolabool RegisterCoalescer::runOnMachineFunction(MachineFunction &fn) { 2208c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF = &fn; 2209c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI = &fn.getRegInfo(); 2210c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TM = &fn.getTarget(); 2211c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 2212c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TII = TM->getInstrInfo(); 2213c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS = &getAnalysis<LiveIntervals>(); 2214655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AA = &getAnalysis<AliasAnalysis>(); 2215c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Loops = &getAnalysis<MachineLoopInfo>(); 2216655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2217ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick const TargetSubtargetInfo &ST = TM->getSubtarget<TargetSubtargetInfo>(); 2218ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (EnableGlobalCopies == cl::BOU_UNSET) 2219b6ac11cd03e9dd97b45dc97787171f942ef8e344Andrew Trick JoinGlobalCopies = ST.useMachineScheduler(); 2220ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick else 2221ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick JoinGlobalCopies = (EnableGlobalCopies == cl::BOU_TRUE); 2222ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 22233106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // The MachineScheduler does not currently require JoinSplitEdges. This will 22243106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // either be enabled unconditionally or replaced by a more general live range 22253106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // splitting optimization. 22263106aa125eb2756083e950362b6769b87cb3430aAndrew Trick JoinSplitEdges = EnableJoinSplits; 2227ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 2228655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** SIMPLE REGISTER COALESCING **********\n" 2229986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie << "********** Function: " << MF->getName() << '\n'); 2230655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2231655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2232c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "Before register coalescing"); 2233655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2234655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola RegClassInfo.runOnMachineFunction(fn); 2235655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2236655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Join (coalesce) intervals if requested. 2237b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen if (EnableJoining) 22389790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen joinAllIntervals(); 2239655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 22404a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // After deleting a lot of copies, register classes may be less constrained. 224103c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register operands may allow GR32_ABCD -> GR32 and DPR_VFP2 -> 22424a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // DPR inflation. 22434a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen array_pod_sort(InflateRegs.begin(), InflateRegs.end()); 22444a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.erase(std::unique(InflateRegs.begin(), InflateRegs.end()), 22454a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.end()); 22464a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << "Trying to inflate " << InflateRegs.size() << " regs.\n"); 22474a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen for (unsigned i = 0, e = InflateRegs.size(); i != e; ++i) { 22484a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen unsigned Reg = InflateRegs[i]; 22494a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(Reg)) 22504a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen continue; 22514a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->recomputeRegClass(Reg, *TM)) { 22524a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << PrintReg(Reg) << " inflated to " 22534a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen << MRI->getRegClass(Reg)->getName() << '\n'); 22544a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen ++NumInflated; 22554a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 22564a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 22574a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen 2258655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dump()); 2259655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2260c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "After register coalescing"); 2261655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 2262655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2263655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2264655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// print - Implement the dump method. 22655b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::print(raw_ostream &O, const Module* m) const { 2266c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->print(O, m); 2267655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2268