RegisterCoalescer.cpp revision 89dbe9744255864445b1c9f9a613ae333d3f79c8
12c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===- RegisterCoalescer.cpp - Generic Register Coalescing Interface -------==// 22c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 32c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// The LLVM Compiler Infrastructure 42c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 72c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 82c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===----------------------------------------------------------------------===// 92c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 102c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// This file implements the generic RegisterCoalescer interface which 112c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// is used as the common interface used by all clients and 122c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// implementations of register coalescing. 132c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene// 142c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene//===----------------------------------------------------------------------===// 152c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 164281e20aab7f1fe1b35b31c9237ad89c20937e02Jakob Stoklund Olesen#define DEBUG_TYPE "regalloc" 17fdf16ca44f130afe80c57481d0c08130aa08cc09Rafael Espindola#include "RegisterCoalescer.h" 18bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/OwningPtr.h" 19bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/STLExtras.h" 20bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/SmallSet.h" 21bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/ADT/Statistic.h" 22bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Analysis/AliasAnalysis.h" 232c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene#include "llvm/CodeGen/LiveIntervalAnalysis.h" 24bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/CodeGen/LiveRangeEdit.h" 25655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineFrameInfo.h" 26655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineInstr.h" 27655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineLoopInfo.h" 28655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/MachineRegisterInfo.h" 29655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/CodeGen/Passes.h" 301525260b3e50cc578939ef41b60609689eecfdd2Andrew Trick#include "llvm/CodeGen/RegisterClassInfo.h" 311ead68d769f27f6d68d4aaeffe4199fa2cacbc95Jakob Stoklund Olesen#include "llvm/CodeGen/VirtRegMap.h" 320b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Value.h" 33d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Pass.h" 34655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/CommandLine.h" 35655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/Debug.h" 36655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/ErrorHandling.h" 37655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include "llvm/Support/raw_ostream.h" 38bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetInstrInfo.h" 39bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetMachine.h" 40bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen#include "llvm/Target/TargetRegisterInfo.h" 41ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick#include "llvm/Target/TargetSubtargetInfo.h" 42655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <algorithm> 43655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola#include <cmath> 442c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greeneusing namespace llvm; 452c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 46655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numJoins , "Number of interval joins performed"); 47655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numCrossRCs , "Number of cross class joins performed"); 48655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numCommutes , "Number of instruction commuting performed"); 49655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(numExtends , "Number of copies extended"); 50655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaSTATISTIC(NumReMats , "Number of instructions re-materialized"); 514a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund OlesenSTATISTIC(NumInflated , "Number of register classes inflated"); 52d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesenSTATISTIC(NumLaneConflicts, "Number of dead lane conflicts tested"); 53d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesenSTATISTIC(NumLaneResolves, "Number of dead lane conflicts resolved"); 54655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 55655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolastatic cl::opt<bool> 56655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaEnableJoining("join-liveintervals", 57655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::desc("Coalesce copies (default=true)"), 58655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::init(true)); 59655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 603c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// Temporary flag to test critical edge unsplitting. 61a6aae0273af9963eaf58aa548f7a918f100e67c7Andrew Trickstatic cl::opt<bool> 623c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew TrickEnableJoinSplits("join-splitedges", 63a6aae0273af9963eaf58aa548f7a918f100e67c7Andrew Trick cl::desc("Coalesce copies on split edges (default=subtarget)"), cl::Hidden); 643c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 65265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick// Temporary flag to test global copy optimization. 66ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trickstatic cl::opt<cl::boolOrDefault> 67265058d9239e6867d06dc8aa40db5f33390abd17Andrew TrickEnableGlobalCopies("join-globalcopies", 68ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick cl::desc("Coalesce copies that span blocks (default=subtarget)"), 69ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick cl::init(cl::BOU_UNSET), cl::Hidden); 70265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 71655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolastatic cl::opt<bool> 72655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaVerifyCoalescing("verify-coalescing", 73655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::desc("Verify machine instrs before and after register coalescing"), 74655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola cl::Hidden); 75655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 768e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesennamespace { 77bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen class RegisterCoalescer : public MachineFunctionPass, 78bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen private LiveRangeEdit::Delegate { 79c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineFunction* MF; 80c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineRegisterInfo* MRI; 81c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetMachine* TM; 82c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetRegisterInfo* TRI; 83c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const TargetInstrInfo* TII; 84c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveIntervals *LIS; 85c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen const MachineLoopInfo* Loops; 868e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen AliasAnalysis *AA; 878e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen RegisterClassInfo RegClassInfo; 888e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 89ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// \brief True if the coalescer should aggressively coalesce global copies 90ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// in favor of keeping local copies. 91ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick bool JoinGlobalCopies; 92ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 93ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// \brief True if the coalescer should aggressively coalesce fall-thru 94ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick /// blocks exclusively containing copies. 95ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick bool JoinSplitEdges; 96ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 97b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /// WorkList - Copy instructions yet to be coalesced. 98b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen SmallVector<MachineInstr*, 8> WorkList; 99265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick SmallVector<MachineInstr*, 8> LocalWorkList; 100b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 101bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// ErasedInstrs - Set of instruction pointers that have been erased, and 102bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// that may be present in WorkList. 103bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallPtrSet<MachineInstr*, 8> ErasedInstrs; 104bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 105bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// Dead instructions that are about to be deleted. 106bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallVector<MachineInstr*, 8> DeadDefs; 107bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 10803c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen /// Virtual registers to be considered for register class inflation. 10903c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen SmallVector<unsigned, 8> InflateRegs; 11003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen 111bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// Recursively eliminate dead defs in DeadDefs. 112bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen void eliminateDeadDefs(); 113bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 114bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen /// LiveRangeEdit callback. 115bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen void LRE_WillEraseInstruction(MachineInstr *MI); 116bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 117265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// coalesceLocals - coalesce the LocalWorkList. 118265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick void coalesceLocals(); 119265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 1209790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinAllIntervals - join compatible live intervals 1219790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen void joinAllIntervals(); 1228e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1239790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// copyCoalesceInMBB - Coalesce copies in the specified MBB, putting 124b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /// copies that cannot yet be coalesced into WorkList. 125b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen void copyCoalesceInMBB(MachineBasicBlock *MBB); 126b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 127265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// copyCoalesceWorkList - Try to coalesce all copies in CurrList. Return 128265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick /// true if any progress was made. 129265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick bool copyCoalesceWorkList(MutableArrayRef<MachineInstr*> CurrList); 1308e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1319790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, 1328e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// which are the src/dst of the copy instruction CopyMI. This returns 1338e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// true if the copy was successfully coalesced away. If it is not 1348e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// currently possible to coalesce this interval, but it may be possible if 1358e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// other things get coalesced, then it returns true by reference in 1368e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// 'Again'. 1379790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool joinCopy(MachineInstr *TheCopy, bool &Again); 1388e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1399790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// joinIntervals - Attempt to join these two intervals. On failure, this 1408e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// returns false. The output "SrcInt" will not have been modified, so we 1418e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// can use this information below to update aliases. 1429790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool joinIntervals(CoalescerPair &CP); 1438e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 144c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Attempt joining two virtual registers. Return true on success. 145c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool joinVirtRegs(CoalescerPair &CP); 146c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 14792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen /// Attempt joining with a reserved physreg. 14892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen bool joinReservedPhysReg(CoalescerPair &CP); 14992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 1509790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// adjustCopiesBackFrom - We found a non-trivially-coalescable copy. If 1518e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// the source value number is defined by a copy from the destination reg 1528e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// see if we can merge these two destination reg valno# into a single 1538e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// value number, eliminating a copy. 1549790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool adjustCopiesBackFrom(const CoalescerPair &CP, MachineInstr *CopyMI); 1558e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1569790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// hasOtherReachingDefs - Return true if there are definitions of IntB 1578e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// other than BValNo val# that can reach uses of AValno val# of IntA. 1589790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool hasOtherReachingDefs(LiveInterval &IntA, LiveInterval &IntB, 1598e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen VNInfo *AValNo, VNInfo *BValNo); 1608e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1619790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// removeCopyByCommutingDef - We found a non-trivially-coalescable copy. 1628e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// If the source value number is defined by a commutable instruction and 1638e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// its other operand is coalesced to the copy dest register, see if we 1648e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// can transform the copy into a noop by commuting the definition. 1659790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen bool removeCopyByCommutingDef(const CoalescerPair &CP,MachineInstr *CopyMI); 1668e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1679790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// reMaterializeTrivialDef - If the source of a copy is defined by a 1688e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// trivial computation, replace the copy by rematerialize the definition. 1691d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich bool reMaterializeTrivialDef(CoalescerPair &CP, MachineInstr *CopyMI); 1708e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 17134a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen /// canJoinPhys - Return true if a physreg copy should be joined. 17239c71da6db9f52cf48430282a27384563a77793eJakub Staszak bool canJoinPhys(const CoalescerPair &CP); 1738e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1749790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen /// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 1758e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// update the subregister number if it is not zero. If DstReg is a 1768e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// physical register and the existing subregister number of the def / use 1778e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// being updated is not zero, make sure to set it to the correct physical 1788e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// subregister. 179ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen void updateRegDefsUses(unsigned SrcReg, unsigned DstReg, unsigned SubIdx); 1808e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1818e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// eliminateUndefCopy - Handle copies of undef values. 1828e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen bool eliminateUndefCopy(MachineInstr *CopyMI, const CoalescerPair &CP); 1838e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1848e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen public: 1858e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen static char ID; // Class identification, replacement for typeinfo 1868e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen RegisterCoalescer() : MachineFunctionPass(ID) { 1878e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen initializeRegisterCoalescerPass(*PassRegistry::getPassRegistry()); 1888e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen } 1898e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1908e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void getAnalysisUsage(AnalysisUsage &AU) const; 1918e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1928e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void releaseMemory(); 1938e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1948e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// runOnMachineFunction - pass entry point 1958e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual bool runOnMachineFunction(MachineFunction&); 1968e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 1978e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen /// print - Implement the dump method. 1988e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen virtual void print(raw_ostream &O, const Module* = 0) const; 1998e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen }; 2008e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen} /// end anonymous namespace 2018e0cca6945ec09bad0decf34ecd832f7e84dc7f1Jakob Stoklund Olesen 2028dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trickchar &llvm::RegisterCoalescerID = RegisterCoalescer::ID; 20327215676c7114132a0374f7b5c9ea73d9354d329Jakob Stoklund Olesen 2045b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_BEGIN(RegisterCoalescer, "simple-register-coalescing", 2055b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 206655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(LiveIntervals) 207655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(SlotIndexes) 208655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_PASS_DEPENDENCY(MachineLoopInfo) 209655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael EspindolaINITIALIZE_AG_DEPENDENCY(AliasAnalysis) 2105b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael EspindolaINITIALIZE_PASS_END(RegisterCoalescer, "simple-register-coalescing", 2115b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindola "Simple Register Coalescing", false, false) 212655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2132c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greenechar RegisterCoalescer::ID = 0; 2142c17c4d8d9f232f0329786ad9abee976bc0f3d27David Greene 21500258d17cd7152237141648d26e1b096cf0e882bRafael Espindolastatic bool isMoveInstr(const TargetRegisterInfo &tri, const MachineInstr *MI, 21600258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &Src, unsigned &Dst, 21700258d17cd7152237141648d26e1b096cf0e882bRafael Espindola unsigned &SrcSub, unsigned &DstSub) { 218273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen if (MI->isCopy()) { 219273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 220273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen DstSub = MI->getOperand(0).getSubReg(); 221273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen Src = MI->getOperand(1).getReg(); 222273f7e42994a5bce0614d04d96dbfdf05fd652e5Jakob Stoklund Olesen SrcSub = MI->getOperand(1).getSubReg(); 2235c00e077952d14899c3fc26709c7b2dfd36d0209Jakob Stoklund Olesen } else if (MI->isSubregToReg()) { 22440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Dst = MI->getOperand(0).getReg(); 22521caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen DstSub = tri.composeSubRegIndices(MI->getOperand(0).getSubReg(), 22621caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen MI->getOperand(3).getImm()); 22740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen Src = MI->getOperand(2).getReg(); 22840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen SrcSub = MI->getOperand(2).getSubReg(); 22904c528a0c86ddf3d6a70681f72e1b2ec07b0b53aJakob Stoklund Olesen } else 23040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 23140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 23240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 23340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2343c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// Return true if this block should be vacated by the coalescer to eliminate 2353c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// branches. The important cases to handle in the coalescer are critical edges 2363c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// split during phi elimination which contain only copies. Simple blocks that 2373c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// contain non-branches should also be vacated, but this can be handled by an 2383c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick// earlier pass similar to early if-conversion. 2393c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trickstatic bool isSplitEdge(const MachineBasicBlock *MBB) { 2403c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick if (MBB->pred_size() != 1 || MBB->succ_size() != 1) 2413c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick return false; 2423c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 2433c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick for (MachineBasicBlock::const_iterator MII = MBB->begin(), E = MBB->end(); 2443c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick MII != E; ++MII) { 2452344abc939b29ab80bbd247995a0ceb2efa5938bAndrew Trick if (!MII->isCopyLike() && !MII->isUnconditionalBranch()) 24643736c7cfaea3b0c3e2660b9cd5c01e306f7c0dfAndrew Trick return false; 2473c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick } 2483c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick return true; 2493c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick} 2503c9e55867e2c8ae7a9e528bce865ebfa963f30a9Andrew Trick 25140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::setRegisters(const MachineInstr *MI) { 25294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcReg = DstReg = 0; 25394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx = DstIdx = 0; 254c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen NewRC = 0; 255c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = CrossClass = false; 25640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 25740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen unsigned Src, Dst, SrcSub, DstSub; 258c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!isMoveInstr(TRI, MI, Src, Dst, SrcSub, DstSub)) 25940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 260c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Partial = SrcSub || DstSub; 26140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 26240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // If one register is a physreg, it must be Dst. 26340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Src)) { 26440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Dst)) 26540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 26640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 26740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(SrcSub, DstSub); 268c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = true; 26940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 27040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 27140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen const MachineRegisterInfo &MRI = MI->getParent()->getParent()->getRegInfo(); 27240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 27340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(Dst)) { 27440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Eliminate DstSub on a physreg. 27540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (DstSub) { 276c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getSubReg(Dst, DstSub); 27740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!Dst) return false; 27840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen DstSub = 0; 27940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 28040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 28140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Eliminate SrcSub by picking a corresponding Dst superregister. 28240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (SrcSub) { 283c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getMatchingSuperReg(Dst, SrcSub, MRI.getRegClass(Src)); 28440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!Dst) return false; 28540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen SrcSub = 0; 28640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else if (!MRI.getRegClass(Src)->contains(Dst)) { 28740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 28840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 28940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 29040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Both registers are virtual. 291defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *SrcRC = MRI.getRegClass(Src); 292defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen const TargetRegisterClass *DstRC = MRI.getRegClass(Dst); 29340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 2948df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen // Both registers have subreg indices. 2958df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen if (SrcSub && DstSub) { 296ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Copies between different sub-registers are never coalescable. 297ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (Src == Dst && SrcSub != DstSub) 298ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen return false; 299ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen 300defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen NewRC = TRI.getCommonSuperRegClass(SrcRC, SrcSub, DstRC, DstSub, 30194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx, DstIdx); 302defa0afa146f4c2370fe126b7860d6d57cf20909Jakob Stoklund Olesen if (!NewRC) 3038df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen return false; 30494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (DstSub) { 30594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // SrcReg will be merged with a sub-register of DstReg. 30694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen SrcIdx = DstSub; 30794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(DstRC, SrcRC, DstSub); 30894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else if (SrcSub) { 30994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // DstReg will be merged with a sub-register of SrcReg. 31094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen DstIdx = SrcSub; 31194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getMatchingSuperRegClass(SrcRC, DstRC, SrcSub); 31294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen } else { 31394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // This is a straight copy without sub-registers. 31494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen NewRC = TRI.getCommonSubClass(DstRC, SrcRC); 3158df08017d81ef3749acdc3234e3f33c15a6d0defJakob Stoklund Olesen } 31640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 31794b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // The combined constraint may be impossible to satisfy. 31894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (!NewRC) 31994b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen return false; 32094b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen 32194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // Prefer SrcReg to be a sub-register of DstReg. 32294b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen // FIXME: Coalescer should support subregs symmetrically. 32394b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (DstIdx && !SrcIdx) { 32440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 32594b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 32694b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen Flipped = !Flipped; 32740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 32840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 329c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen CrossClass = NewRC != DstRC || NewRC != SrcRC; 33040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 33140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Check our invariants 33240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Src) && "Src must be virtual"); 33340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen assert(!(TargetRegisterInfo::isPhysicalRegister(Dst) && DstSub) && 33440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen "Cannot have a physical SubIdx"); 335c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SrcReg = Src; 336c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DstReg = Dst; 33740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 33840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 33940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 34040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::flip() { 34194b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) 34240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 343c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen std::swap(SrcReg, DstReg); 34494b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen std::swap(SrcIdx, DstIdx); 345c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Flipped = !Flipped; 34640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return true; 34740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 34840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 34940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesenbool CoalescerPair::isCoalescable(const MachineInstr *MI) const { 35040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!MI) 35140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen unsigned Src, Dst, SrcSub, DstSub; 353c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!isMoveInstr(TRI, MI, Src, Dst, SrcSub, DstSub)) 35440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 35540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 356c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Find the virtual register that is SrcReg. 357c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (Dst == SrcReg) { 35840d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(Src, Dst); 35940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen std::swap(SrcSub, DstSub); 360c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen } else if (Src != SrcReg) { 36140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 36340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 364c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // Now check that Dst matches DstReg. 365c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { 36640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!TargetRegisterInfo::isPhysicalRegister(Dst)) 36740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 36894b62ac5f3b2732251f164ee6feab2dd1a4b967fJakob Stoklund Olesen assert(!DstIdx && !SrcIdx && "Inconsistent CoalescerPair state."); 36940d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // DstSub could be set for a physreg from INSERT_SUBREG. 37040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (DstSub) 371c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Dst = TRI.getSubReg(Dst, DstSub); 37240d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Full copy of Src. 37340d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen if (!SrcSub) 374c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return DstReg == Dst; 37540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // This is a partial register copy. Check that the parts match. 376c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen return TRI.getSubReg(DstReg, SrcSub) == Dst; 37740d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } else { 378c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen // DstReg is virtual. 379c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (DstReg != Dst) 38040d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen return false; 38140d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen // Registers match, do the subregisters line up? 38221caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen return TRI.composeSubRegIndices(SrcIdx, SrcSub) == 38321caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI.composeSubRegIndices(DstIdx, DstSub); 38440d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen } 38540d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen} 38640d07bbebbe73914af28be1bdab169ce8333adcaJakob Stoklund Olesen 3875b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::getAnalysisUsage(AnalysisUsage &AU) const { 388655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.setPreservesCFG(); 389655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<AliasAnalysis>(); 390655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<LiveIntervals>(); 391655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<LiveIntervals>(); 392655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<SlotIndexes>(); 393655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addRequired<MachineLoopInfo>(); 394655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreserved<MachineLoopInfo>(); 395655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AU.addPreservedID(MachineDominatorsID); 396655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineFunctionPass::getAnalysisUsage(AU); 397655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 398655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 399bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesenvoid RegisterCoalescer::eliminateDeadDefs() { 400bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen SmallVector<LiveInterval*, 8> NewRegs; 401bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen LiveRangeEdit(0, NewRegs, *MF, *LIS, 0, this).eliminateDeadDefs(DeadDefs); 402bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen} 403bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 404bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen// Callback from eliminateDeadDefs(). 405bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesenvoid RegisterCoalescer::LRE_WillEraseInstruction(MachineInstr *MI) { 406bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // MI may be in WorkList. Make sure we don't visit it. 407bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.insert(MI); 408bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen} 409bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 4109790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// adjustCopiesBackFrom - We found a non-trivially-coalescable copy with IntA 411655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// being the source and IntB being the dest, thus this defines a value number 412655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// in IntB. If the source value number (in IntA) is defined by a copy from B, 413655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// see if we can merge these two pieces of B into a single value number, 414655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// eliminating a copy. For example: 415655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 416655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// A3 = B0 417655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 418655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = A3 <- this copy 419655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 420655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// In this case, B0 can be extended to where the B1 copy lives, allowing the B1 421655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// value number to be replaced with B0 (which simplifies the B liveinterval). 422655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 423655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// This returns true if an interval was modified. 424655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 4259790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::adjustCopiesBackFrom(const CoalescerPair &CP, 4269790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 427141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen assert(!CP.isPartial() && "This doesn't work for partial copies."); 4280984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen assert(!CP.isPhys() && "This doesn't work for physreg copies."); 429141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen 430655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntA = 431c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg()); 432655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntB = 433c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg()); 4342debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(); 435655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 436655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo is a value number in B that is defined by a copy from A. 'B3' in 437655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // the example above. 438655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator BLR = IntB.FindLiveRangeContaining(CopyIdx); 439655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BLR == IntB.end()) return false; 440655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *BValNo = BLR->valno; 441655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 442655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the location that B is defined at. Two options: either this value has 443655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // an unknown definition point or it is defined at CopyIdx. If unknown, we 444655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // can't process it. 4453b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen if (BValNo->def != CopyIdx) return false; 446655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 447655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // AValNo is the value number in A that defines the copy, A3 in the example. 4482debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyUseIdx = CopyIdx.getRegSlot(true); 449655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ALR = IntA.FindLiveRangeContaining(CopyUseIdx); 450655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // The live range might not exist after fun with physreg coalescing. 451655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ALR == IntA.end()) return false; 452655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *AValNo = ALR->valno; 453655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 454655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If AValNo is defined as a copy from IntB, we can potentially process this. 455655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the instruction that defines this value number. 4563b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen MachineInstr *ACopyMI = LIS->getInstructionFromIndex(AValNo->def); 457573303e62a913ec881fde3434d7babed0bd4da33Jakob Stoklund Olesen // Don't allow any partial copies, even if isCoalescable() allows them. 458573303e62a913ec881fde3434d7babed0bd4da33Jakob Stoklund Olesen if (!CP.isCoalescable(ACopyMI) || !ACopyMI->isFullCopy()) 459655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 460655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 461655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Get the LiveRange in IntB that this value number starts with. 462655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ValLR = 463655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.FindLiveRangeContaining(AValNo->def.getPrevSlot()); 464655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ValLR == IntB.end()) 465655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 466655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 467655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure that the end of the live range is inside the same block as 468655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI. 469655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *ValLREndInst = 470c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInstructionFromIndex(ValLR->end.getPrevSlot()); 471655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!ValLREndInst || ValLREndInst->getParent() != CopyMI->getParent()) 472655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 473655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 474655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, we now know that ValLR ends in the same block that the CopyMI 475655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // live-range starts. If there are no intervening live ranges between them in 476655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // IntB, we can merge them. 477655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ValLR+1 != BLR) return false; 478655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 479b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << "Extending: " << PrintReg(IntB.reg, TRI)); 480655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 481655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola SlotIndex FillerStart = ValLR->end, FillerEnd = BLR->start; 482655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // We are about to delete CopyMI, so need to remove it as the 'instruction 483655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // that defines this value #'. Update the valnum with the new defining 484655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // instruction #. 4853b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen BValNo->def = FillerStart; 486655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 487655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, we can merge them. We need to insert a new liverange: 488655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // [ValLR.end, BLR.begin) of either value number, then we merge the 489655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // two value numbers. 490655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.addRange(LiveRange(FillerStart, FillerEnd, BValNo)); 491655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 492655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, merge "B1" into the same value number as "B0". 493bf60aa9db5953dd99c561dfa9323b1e3293a5a85Jakob Stoklund Olesen if (BValNo != ValLR->valno) 494655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.MergeValueNumberInto(BValNo, ValLR->valno); 495b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << " result = " << IntB << '\n'); 496655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 497655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If the source instruction was killing the source register before the 498655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // merge, unset the isKill marker given the live range has been extended. 499655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola int UIdx = ValLREndInst->findRegisterUseOperandIdx(IntB.reg, true); 500655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UIdx != -1) { 501655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ValLREndInst->getOperand(UIdx).setIsKill(false); 502655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 5038dd26253f54247e77e5accfdd70e7b4bf27b39c2Andrew Trick 5043b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // Rewrite the copy. If the copy instruction was killing the destination 5053b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // register before the merge, find the last use and trim the live range. That 5063b0714d993a37c722603f7cbfab71848a99e91cdLang Hames // will also add the isKill marker. 507141aea9cff95b8df8ca89fb757dc44ee37a3d8dfJakob Stoklund Olesen CopyMI->substituteRegister(IntA.reg, IntB.reg, 0, *TRI); 508655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ALR->end == CopyIdx) 509c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->shrinkToUses(&IntA); 510655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 511655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numExtends; 512655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 513655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 514655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5159790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// hasOtherReachingDefs - Return true if there are definitions of IntB 5169b82d50d209adf915d3c7f871dc82cb73349db80Jakob Stoklund Olesen/// other than BValNo val# that can reach uses of AValno val# of IntA. 5179790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::hasOtherReachingDefs(LiveInterval &IntA, 5189790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen LiveInterval &IntB, 5199790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen VNInfo *AValNo, 5209790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen VNInfo *BValNo) { 5210ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen // If AValNo has PHI kills, conservatively assume that IntB defs can reach 5220ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen // the PHI values. 5230ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen if (LIS->hasPHIKill(IntA, AValNo)) 5240ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen return true; 5250ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen 526655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (LiveInterval::iterator AI = IntA.begin(), AE = IntA.end(); 527655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AI != AE; ++AI) { 5289b82d50d209adf915d3c7f871dc82cb73349db80Jakob Stoklund Olesen if (AI->valno != AValNo) continue; 529655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::Ranges::iterator BI = 530655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola std::upper_bound(IntB.ranges.begin(), IntB.ranges.end(), AI->start); 531655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI != IntB.ranges.begin()) 532655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola --BI; 533655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (; BI != IntB.ranges.end() && AI->end >= BI->start; ++BI) { 534655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->valno == BValNo) 535655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 536655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->start <= AI->start && BI->end > AI->start) 537655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 538655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (BI->start > AI->start && BI->start < AI->end) 539655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 540655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 541655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 542655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 543655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 544655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5459790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// removeCopyByCommutingDef - We found a non-trivially-coalescable copy with 546655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// IntA being the source and IntB being the dest, thus this defines a value 547655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// number in IntB. If the source value number (in IntA) is defined by a 548655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// commutable instruction and its other operand is coalesced to the copy dest 549655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// register, see if we can transform the copy into a noop by commuting the 550655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// definition. For example, 551655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 552655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// A3 = op A2 B0<kill> 553655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 554655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = A3 <- this copy 555655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 556655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// = op A3 <- more uses 557655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 558655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ==> 559655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 560655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B2 = op B0 A2<kill> 561655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 562655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// B1 = B2 <- now an identify copy 563655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// ... 564655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// = op B2 <- more uses 565655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 566655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// This returns true if an interval was modified. 567655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// 5689790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::removeCopyByCommutingDef(const CoalescerPair &CP, 5699790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 5700984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen assert (!CP.isPhys()); 571655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 5722debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(); 573655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 574655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntA = 575c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg()); 576655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval &IntB = 577c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg()); 578655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 579655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo is a value number in B that is defined by a copy from A. 'B3' in 580655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // the example above. 581655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *BValNo = IntB.getVNInfoAt(CopyIdx); 5823b1088a2cc15a39c7a7b8dd95a56143f1dda6863Jakob Stoklund Olesen if (!BValNo || BValNo->def != CopyIdx) 583655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 584655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 585655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(BValNo->def == CopyIdx && "Copy doesn't define the value?"); 586655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 587655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // AValNo is the value number in A that defines the copy, A3 in the example. 5882debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *AValNo = IntA.getVNInfoAt(CopyIdx.getRegSlot(true)); 589655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(AValNo && "COPY source not live"); 5900ab7103e06ee1da7bde5b196a68be77ab49a005dJakob Stoklund Olesen if (AValNo->isPHIDef() || AValNo->isUnused()) 591655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 592c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *DefMI = LIS->getInstructionFromIndex(AValNo->def); 593655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI) 594655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 5955a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!DefMI->isCommutable()) 596655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 597655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If DefMI is a two-address instruction then commuting it will change the 598655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // destination register. 599655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola int DefIdx = DefMI->findRegisterDefOperandIdx(IntA.reg); 600655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DefIdx != -1); 601655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned UseOpIdx; 602655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isRegTiedToUseOperand(DefIdx, &UseOpIdx)) 603655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 604655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned Op1, Op2, NewDstIdx; 605c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->findCommutedOpIndices(DefMI, Op1, Op2)) 606655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 607655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (Op1 == UseOpIdx) 608655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op2; 609655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else if (Op2 == UseOpIdx) 610655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewDstIdx = Op1; 611655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 612655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 613655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 614655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &NewDstMO = DefMI->getOperand(NewDstIdx); 615655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned NewReg = NewDstMO.getReg(); 616ab9baf7ff4b58b3905bccad68c8d2ab59ea4202bJakob Stoklund Olesen if (NewReg != IntB.reg || !LiveRangeQuery(IntB, AValNo->def).isKill()) 617655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 618655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 619655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Make sure there are no other definitions of IntB that would reach the 620655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // uses which the new definition can reach. 6219790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (hasOtherReachingDefs(IntA, IntB, AValNo, BValNo)) 622655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 623655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 624655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If some of the uses of IntA.reg is already coalesced away, return false. 625655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // It's not possible to determine whether it's safe to perform the coalescing. 626b1afbac64b7c4c06959350acc175fb3552012f57Andrew Trick for (MachineRegisterInfo::use_nodbg_iterator UI = 627c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI->use_nodbg_begin(IntA.reg), 628c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UE = MRI->use_nodbg_end(); UI != UE; ++UI) { 629655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = &*UI; 630c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI); 631655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ULR = IntA.FindLiveRangeContaining(UseIdx); 63256366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen if (ULR == IntA.end() || ULR->valno != AValNo) 633655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 63456366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen // If this use is tied to a def, we can't rewrite the register. 63556366601765c1ff43f8796c271a818f8c272af27Jakob Stoklund Olesen if (UseMI->isRegTiedToDefOperand(UI.getOperandNo())) 636655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 637655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 638655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 6399790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen DEBUG(dbgs() << "\tremoveCopyByCommutingDef: " << AValNo->def << '\t' 640655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola << *DefMI); 641655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 642655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // At this point we have decided that it is legal to do this 643655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // transformation. Start by commuting the instruction. 644655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = DefMI->getParent(); 645c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *NewMI = TII->commuteInstruction(DefMI); 646655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!NewMI) 647655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 648655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isVirtualRegister(IntA.reg) && 649655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola TargetRegisterInfo::isVirtualRegister(IntB.reg) && 650c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen !MRI->constrainRegClass(IntB.reg, MRI->getRegClass(IntA.reg))) 651655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 652655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (NewMI != DefMI) { 653c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->ReplaceMachineInstrInMaps(DefMI, NewMI); 6547c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MachineBasicBlock::iterator Pos = DefMI; 6557c2a4a30e0e16762c75adacebd05ec9fcbccf16bEvan Cheng MBB->insert(Pos, NewMI); 656655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MBB->erase(DefMI); 657655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 658655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola unsigned OpIdx = NewMI->findRegisterUseOperandIdx(IntA.reg, false); 659655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola NewMI->getOperand(OpIdx).setIsKill(); 660655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 661655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If ALR and BLR overlaps and end of BLR extends beyond end of ALR, e.g. 662655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // A = or A, B 663655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 664655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // B = A 665655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 666655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // C = A<kill> 667655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // ... 668655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // = B 669655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 670655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update uses of IntA of the specific Val# with IntB. 671c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(IntA.reg), 672c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UE = MRI->use_end(); UI != UE;) { 673655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &UseMO = UI.getOperand(); 674655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = &*UI; 675655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++UI; 676655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->isDebugValue()) { 677655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // FIXME These don't have an instruction index. Not clear we have enough 678655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // info to decide whether to do this replacement or not. For now do it. 679655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 680655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 681655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 6822debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex UseIdx = LIS->getInstructionIndex(UseMI).getRegSlot(true); 683655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator ULR = IntA.FindLiveRangeContaining(UseIdx); 684655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (ULR == IntA.end() || ULR->valno != AValNo) 685655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 68634af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen // Kill flags are no longer accurate. They are recomputed after RA. 68734af6f597b09c13fba7d3a1960c0810cfc30beffJakob Stoklund Olesen UseMO.setIsKill(false); 688655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (TargetRegisterInfo::isPhysicalRegister(NewReg)) 689c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen UseMO.substPhysReg(NewReg, *TRI); 690655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 691655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMO.setReg(NewReg); 692655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI == CopyMI) 693655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 694655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isCopy()) 695655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 696655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (UseMI->getOperand(0).getReg() != IntB.reg || 697655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola UseMI->getOperand(0).getSubReg()) 698655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 699655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 700655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // This copy will become a noop. If it's defining a new val#, merge it into 701655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // BValNo. 7022debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex DefIdx = UseIdx.getRegSlot(); 703655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *DVNI = IntB.getVNInfoAt(DefIdx); 704655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DVNI) 705655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola continue; 706655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\tnoop: " << DefIdx << '\t' << *UseMI); 707655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DVNI->def == DefIdx); 708655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola BValNo = IntB.MergeValueNumberInto(BValNo, DVNI); 709ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen ErasedInstrs.insert(UseMI); 710ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(UseMI); 711ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen UseMI->eraseFromParent(); 712655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 713655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 714655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Extend BValNo by merging in IntA live ranges of AValNo. Val# definition 715655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // is updated. 716655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *ValNo = BValNo; 717655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ValNo->def = AValNo->def; 718655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (LiveInterval::iterator AI = IntA.begin(), AE = IntA.end(); 719655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AI != AE; ++AI) { 720655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (AI->valno != AValNo) continue; 721655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntB.addRange(LiveRange(AI->start, AI->end, ValNo)); 722655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 723655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\textended: " << IntB << '\n'); 724655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 725655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola IntA.removeValNo(AValNo); 726655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\t\ttrimmed: " << IntA << '\n'); 727655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCommutes; 728655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 729655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 730655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 7319790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// reMaterializeTrivialDef - If the source of a copy is defined by a trivial 732655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// computation, replace the copy by rematerialize the definition. 7331d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarichbool RegisterCoalescer::reMaterializeTrivialDef(CoalescerPair &CP, 7349790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen MachineInstr *CopyMI) { 7351d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned SrcReg = CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg(); 736aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned SrcIdx = CP.isFlipped() ? CP.getDstIdx() : CP.getSrcIdx(); 7371d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich unsigned DstReg = CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg(); 738aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned DstIdx = CP.isFlipped() ? CP.getSrcIdx() : CP.getDstIdx(); 7391d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (TargetRegisterInfo::isPhysicalRegister(SrcReg)) 7401d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich return false; 7411d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich 7421d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich LiveInterval &SrcInt = LIS->getInterval(SrcReg); 7432debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(true); 744655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola LiveInterval::iterator SrcLR = SrcInt.FindLiveRangeContaining(CopyIdx); 745655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(SrcLR != SrcInt.end() && "Live range not found!"); 746655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola VNInfo *ValNo = SrcLR->valno; 7474ea24e993f179113a9bb76ee152cc490e738c936Jakob Stoklund Olesen if (ValNo->isPHIDef() || ValNo->isUnused()) 748655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 749c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MachineInstr *DefMI = LIS->getInstructionFromIndex(ValNo->def); 750655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI) 751655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 752655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola assert(DefMI && "Defining instruction disappeared"); 7535a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!DefMI->isAsCheapAsAMove()) 754655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 755c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!TII->isTriviallyReMaterializable(DefMI, AA)) 756655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 757655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool SawStore = false; 758c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen if (!DefMI->isSafeToMove(TII, AA, SawStore)) 759655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 7605a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng const MCInstrDesc &MCID = DefMI->getDesc(); 761e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng if (MCID.getNumDefs() != 1) 762655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 763c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich // Only support subregister destinations when the def is read-undef. 764c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich MachineOperand &DstOperand = CopyMI->getOperand(0); 765d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover unsigned CopyDstReg = DstOperand.getReg(); 766c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich if (DstOperand.getSubReg() && !DstOperand.isUndef()) 767c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich return false; 768aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 769aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover const TargetRegisterClass *DefRC = TII->getRegClass(MCID, 0, TRI, *MF); 770655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!DefMI->isImplicitDef()) { 771aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { 772aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewDstReg = DstReg; 773aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 774aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewDstIdx = TRI->composeSubRegIndices(CP.getSrcIdx(), 775aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover DefMI->getOperand(0).getSubReg()); 776aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewDstIdx) 777aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewDstReg = TRI->getSubReg(DstReg, NewDstIdx); 778aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 779aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // Finally, make sure that the physical subregister that will be 780aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // constructed later is permitted for the instruction. 781aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (!DefRC->contains(NewDstReg)) 782655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 783aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } else { 784aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // Theoretically, some stack frame reference could exist. Just make sure 785aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // it hasn't actually happened. 786aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover assert(TargetRegisterInfo::isVirtualRegister(DstReg) && 787aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover "Only expect to deal with virtual or physical registers"); 788aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } 789655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 790655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 791655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock *MBB = CopyMI->getParent(); 792655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineBasicBlock::iterator MII = 793655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola llvm::next(MachineBasicBlock::iterator(CopyMI)); 794aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover TII->reMaterialize(*MBB, MII, DstReg, SrcIdx, DefMI, *TRI); 795655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *NewMI = prior(MII); 796655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 797aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover LIS->ReplaceMachineInstrInMaps(CopyMI, NewMI); 798aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover CopyMI->eraseFromParent(); 799aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover ErasedInstrs.insert(CopyMI); 800c5f147459b1704e25df4ff888729dd5d22d73381Cameron Zwarich 801eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI may have dead implicit defs (E.g. EFLAGS for MOV<bits>r0 on X86). 802eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // We need to remember these so we can add intervals once we insert 803eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames // NewMI into SlotIndexes. 804eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SmallVector<unsigned, 4> NewMIImplDefs; 805eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = NewMI->getDesc().getNumOperands(), 806eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames e = NewMI->getNumOperands(); i != e; ++i) { 807eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames MachineOperand &MO = NewMI->getOperand(i); 808eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames if (MO.isReg()) { 809275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isDef() && MO.isImplicit() && MO.isDead() && 810275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames TargetRegisterInfo::isPhysicalRegister(MO.getReg())); 811eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames NewMIImplDefs.push_back(MO.getReg()); 812eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 813eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 814eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 815aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (TargetRegisterInfo::isVirtualRegister(DstReg)) { 816aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover unsigned NewIdx = NewMI->getOperand(0).getSubReg(); 817aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover const TargetRegisterClass *RCForInst; 818aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewIdx) 819aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover RCForInst = TRI->getMatchingSuperRegClass(MRI->getRegClass(DstReg), DefRC, 820aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewIdx); 821aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 822aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (MRI->constrainRegClass(DstReg, DefRC)) { 823aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // The materialized instruction is quite capable of setting DstReg 824aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // directly, but it may still have a now-trivial subregister index which 825aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // we should clear. 826aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewMI->getOperand(0).setSubReg(0); 827aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } else if (NewIdx && RCForInst) { 828aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // The subreg index on NewMI is essential; we still have to make sure 829aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // DstReg:idx is in a class that NewMI can use. 830aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover MRI->constrainRegClass(DstReg, RCForInst); 831aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } else { 832aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // DstReg is actually incompatible with NewMI, we have to move to a 833aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // super-reg's class. This could come from a sequence like: 834aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // GR32 = MOV32r0 835aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // GR8 = COPY GR32:sub_8 836aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover MRI->setRegClass(DstReg, CP.getNewRC()); 837aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover updateRegDefsUses(DstReg, DstReg, DstIdx); 838aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewMI->getOperand(0).setSubReg( 839aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover TRI->composeSubRegIndices(SrcIdx, DefMI->getOperand(0).getSubReg())); 840aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } 841d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover } else if (NewMI->getOperand(0).getReg() != CopyDstReg) { 842aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // The New instruction may be defining a sub-register of what's actually 843aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover // been asked for. If so it must implicitly define the whole thing. 844aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover assert(TargetRegisterInfo::isPhysicalRegister(DstReg) && 845aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover "Only expect virtual or physical registers in remat"); 84689dbe9744255864445b1c9f9a613ae333d3f79c8Tim Northover NewMI->getOperand(0).setIsDead(true); 847d01fb9e212d989ff14e84a332c5b18f8a23d4b35Tim Northover NewMI->addOperand(MachineOperand::CreateReg(CopyDstReg, 848aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover true /*IsDef*/, 849aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover true /*IsImp*/, 850aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover false /*IsKill*/)); 851aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover } 852aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 853aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover if (NewMI->getOperand(0).getSubReg()) 854aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover NewMI->getOperand(0).setIsUndef(); 855aae0fa998af0f65221d7b98630162be6d88f05dcTim Northover 856655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // CopyMI may have implicit operands, transfer them over to the newly 857655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerialized instruction. And update implicit def interval valnos. 858655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = CopyMI->getDesc().getNumOperands(), 859655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola e = CopyMI->getNumOperands(); i != e; ++i) { 860655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = CopyMI->getOperand(i); 861275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (MO.isReg()) { 862275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames assert(MO.isImplicit() && "No explicit operands after implict operands."); 863275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames // Discard VReg implicit defs. 864275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) { 865275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames NewMI->addOperand(MO); 866275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 867275ff9bb17698a5eee613c20eca31b4835ae60dbLang Hames } 868655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 869655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 870eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI); 871eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames for (unsigned i = 0, e = NewMIImplDefs.size(); i != e; ++i) { 87271b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen unsigned Reg = NewMIImplDefs[i]; 87371b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen for (MCRegUnitIterator Units(Reg, TRI); Units.isValid(); ++Units) 87471b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen if (LiveInterval *LI = LIS->getCachedRegUnit(*Units)) 87571b49cb5c73ba912f2fab30f35ed1e43c35a2139Jakob Stoklund Olesen LI->createDeadDef(NewMIIdx.getRegSlot(), LIS->getVNInfoAllocator()); 876eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames } 877eec68e7ffa22d489562a58299cd2fc6f089b893bLang Hames 878655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "Remat: " << *NewMI); 879655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++NumReMats; 880655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 881655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // The source interval can become smaller because we removed a use. 8821dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen LIS->shrinkToUses(&SrcInt, &DeadDefs); 8831dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen if (!DeadDefs.empty()) 8841dc6d7cbb5affee14a2fc5e7269616f3b7b4b6faJakob Stoklund Olesen eliminateDeadDefs(); 885655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 886655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 887655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 888655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 889e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// eliminateUndefCopy - ProcessImpicitDefs may leave some copies of <undef> 890e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// values, it only removes local variables. When we have a copy like: 891e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 892e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// %vreg1 = COPY %vreg2<undef> 893e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// 894e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// We delete the copy and remove the corresponding value number from %vreg1. 895e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen/// Any uses of that value number are marked as <undef>. 896e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesenbool RegisterCoalescer::eliminateUndefCopy(MachineInstr *CopyMI, 897e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen const CoalescerPair &CP) { 898c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(CopyMI); 899c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *SrcInt = &LIS->getInterval(CP.getSrcReg()); 900e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (SrcInt->liveAt(Idx)) 901e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 902c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LiveInterval *DstInt = &LIS->getInterval(CP.getDstReg()); 903e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 904e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return false; 905e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 906e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // No intervals are live-in to CopyMI - it is undef. 907e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (CP.isFlipped()) 908e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt = SrcInt; 909e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen SrcInt = 0; 910e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 9112debd48ca790ac01be6e12e094fdf4fdcadc8364Jakob Stoklund Olesen VNInfo *DeadVNI = DstInt->getVNInfoAt(Idx.getRegSlot()); 912e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen assert(DeadVNI && "No value defined in DstInt"); 913e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DstInt->removeValNo(DeadVNI); 914e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 915e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen // Find new undef uses. 916e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen for (MachineRegisterInfo::reg_nodbg_iterator 917c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen I = MRI->reg_nodbg_begin(DstInt->reg), E = MRI->reg_nodbg_end(); 918e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen I != E; ++I) { 919e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MachineOperand &MO = I.getOperand(); 920e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (MO.isDef() || MO.isUndef()) 921e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 922e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MachineInstr *MI = MO.getParent(); 923c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen SlotIndex Idx = LIS->getInstructionIndex(MI); 924e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen if (DstInt->liveAt(Idx)) 925e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen continue; 926e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen MO.setIsUndef(true); 927e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen DEBUG(dbgs() << "\tnew undef: " << Idx << '\t' << *MI); 928e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 929e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen return true; 930e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen} 931e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 9329790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// updateRegDefsUses - Replace all defs and uses of SrcReg to DstReg and 933655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// update the subregister number if it is not zero. If DstReg is a 934655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// physical register and the existing subregister number of the def / use 935655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// being updated is not zero, make sure to set it to the correct physical 936655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// subregister. 937ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesenvoid RegisterCoalescer::updateRegDefsUses(unsigned SrcReg, 938ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned DstReg, 939ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen unsigned SubIdx) { 940ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen bool DstIsPhys = TargetRegisterInfo::isPhysicalRegister(DstReg); 941324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen LiveInterval *DstInt = DstIsPhys ? 0 : &LIS->getInterval(DstReg); 942655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 94389bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen SmallPtrSet<MachineInstr*, 8> Visited; 944c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen for (MachineRegisterInfo::reg_iterator I = MRI->reg_begin(SrcReg); 945655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineInstr *UseMI = I.skipInstruction();) { 94689bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // Each instruction can only be rewritten once because sub-register 94789bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // composition is not always idempotent. When SrcReg != DstReg, rewriting 94889bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // the UseMI operands removes them from the SrcReg use-def chain, but when 94989bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // SrcReg is DstReg we could encounter UseMI twice if it has multiple 95089bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen // operands mentioning the virtual register. 95189bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen if (SrcReg == DstReg && !Visited.insert(UseMI)) 95289bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen continue; 95389bea17af235ea3a69485e73e54e71053c1bd936Jakob Stoklund Olesen 954655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola SmallVector<unsigned,8> Ops; 955655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola bool Reads, Writes; 956655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola tie(Reads, Writes) = UseMI->readsWritesVirtualRegister(SrcReg, &Ops); 957655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 95807a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // If SrcReg wasn't read, it may still be the case that DstReg is live-in 95907a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // because SrcReg is a sub-register. 960324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen if (DstInt && !Reads && SubIdx) 961324143d888a83511b6e022b4c541b18cc7773886Jakob Stoklund Olesen Reads = DstInt->liveAt(LIS->getInstructionIndex(UseMI)); 96207a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen 963655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Replace SrcReg with DstReg in all UseMI operands. 964655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola for (unsigned i = 0, e = Ops.size(); i != e; ++i) { 965655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola MachineOperand &MO = UseMI->getOperand(Ops[i]); 966655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 96707a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // Adjust <undef> flags in case of sub-register joins. We don't want to 96807a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // turn a full def into a read-modify-write sub-register def and vice 96907a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen // versa. 970ec096b492549d625e4be608fcaea265b96dabc03Jakob Stoklund Olesen if (SubIdx && MO.isDef()) 97107a267faec7bd77fdece44f242cb4270120e0ef2Jakob Stoklund Olesen MO.setIsUndef(!Reads); 972b077cf338bd85a6a7397ec88d65278f02f0ed06fJakob Stoklund Olesen 973655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (DstIsPhys) 974c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substPhysReg(DstReg, *TRI); 975655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola else 976c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MO.substVirtReg(DstReg, SubIdx, *TRI); 977655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 978655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 979655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG({ 980655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << "\t\tupdated: "; 981655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!UseMI->isDebugValue()) 982c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen dbgs() << LIS->getInstructionIndex(UseMI) << "\t"; 983655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola dbgs() << *UseMI; 984655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola }); 985655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 986655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 987655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 98834a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen/// canJoinPhys - Return true if a copy involving a physreg should be joined. 98939c71da6db9f52cf48430282a27384563a77793eJakub Staszakbool RegisterCoalescer::canJoinPhys(const CoalescerPair &CP) { 990655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// Always join simple intervals that are defined by a single copy from a 991655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// reserved register. This doesn't increase register pressure, so it is 992655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola /// always beneficial. 99314d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen if (!MRI->isReserved(CP.getDstReg())) { 99434a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCan only merge into reserved registers.\n"); 995655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 996655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 997655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 99834a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen LiveInterval &JoinVInt = LIS->getInterval(CP.getSrcReg()); 99934a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (CP.isFlipped() && JoinVInt.containsOneValue()) 100034a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return true; 1001655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 100234a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen DEBUG(dbgs() << "\tCannot join defs into reserved register.\n"); 100334a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen return false; 1004655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1005655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 10069790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, 1007655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// which are the src/dst of the copy instruction CopyMI. This returns true 1008655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// if the copy was successfully coalesced away. If it is not currently 1009655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// possible to coalesce this interval, but it may be possible if other 1010655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// things get coalesced, then it returns true by reference in 'Again'. 10119790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinCopy(MachineInstr *CopyMI, bool &Again) { 1012655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1013655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = false; 1014c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen DEBUG(dbgs() << LIS->getInstructionIndex(CopyMI) << '\t' << *CopyMI); 1015655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1016a7542d5f870c5d98960d1676e23ac1d1d975d7e5Benjamin Kramer CoalescerPair CP(*TRI); 1017655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (!CP.setRegisters(CopyMI)) { 1018655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tNot coalescable.\n"); 1019655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1020655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1021655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1022bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Dead code elimination. This really should be handled by MachineDCE, but 1023bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // sometimes dead copies slip through, and we can't generate invalid live 1024bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // ranges. 1025bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen if (!CP.isPhys() && CopyMI->allDefsAreDead()) { 1026bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy is dead.\n"); 1027bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.push_back(CopyMI); 1028bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen eliminateDeadDefs(); 1029bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen return true; 1030bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 1031bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen 1032e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Eliminate undefs. 1033e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (!CP.isPhys() && eliminateUndefCopy(CopyMI, CP)) { 1034e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tEliminated copy of <undef> value.\n"); 10353662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 10363662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1037655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; // Not coalescable. 1038655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1039655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1040e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // Coalesced copies are normally removed immediately, but transformations 1041e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // like removeCopyByCommutingDef() can inadvertently create identity copies. 1042e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen // When that happens, just join the values and remove the copy. 1043e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (CP.getSrcReg() == CP.getDstReg()) { 1044e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LiveInterval &LI = LIS->getInterval(CP.getSrcReg()); 1045e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tCopy already coalesced: " << LI << '\n'); 1046e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LiveRangeQuery LRQ(LI, LIS->getInstructionIndex(CopyMI)); 1047e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen if (VNInfo *DefVNI = LRQ.valueDefined()) { 1048e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen VNInfo *ReadVNI = LRQ.valueIn(); 1049e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI && "No value before copy and no <undef> flag."); 1050e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen assert(ReadVNI != DefVNI && "Cannot read and define the same value."); 1051e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen LI.MergeValueNumberInto(DefVNI, ReadVNI); 1052e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen DEBUG(dbgs() << "\tMerged values: " << LI << '\n'); 1053e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen } 10543662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 10553662f0d492533435c30969118fd025f6bed46654Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1056e3b548219ff47b1384aa7325ebbe21c795c19974Jakob Stoklund Olesen return true; 1057e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen } 1058e4709777e38b58b856cf8395e071a3326d50a402Jakob Stoklund Olesen 1059655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Enforce policies. 1060655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isPhys()) { 1061ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen DEBUG(dbgs() << "\tConsidering merging " << PrintReg(CP.getSrcReg(), TRI) 1062ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with " << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) 1063ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << '\n'); 106434a18775a402f269425b5d79efe385fe122cc64dJakob Stoklund Olesen if (!canJoinPhys(CP)) { 1065655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Before giving up coalescing, if definition of source is defined by 1066655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // trivial computation, try rematerializing it. 10671d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (reMaterializeTrivialDef(CP, CopyMI)) 1068655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1069655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1070655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1071655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } else { 107240a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen DEBUG({ 1073ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << "\tConsidering merging to " << CP.getNewRC()->getName() 1074ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << " with "; 1075ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx() && CP.getSrcIdx()) 1076ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getDstReg()) << " in " 1077ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getDstIdx()) << " and " 1078ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getSrcReg()) << " in " 1079ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << TRI->getSubRegIndexName(CP.getSrcIdx()) << '\n'; 1080ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen else 1081ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen dbgs() << PrintReg(CP.getSrcReg(), TRI) << " in " 1082ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen << PrintReg(CP.getDstReg(), TRI, CP.getSrcIdx()) << '\n'; 108340a2b653e165b5afc2f612b4b3edbb54a7b5eb59Jakob Stoklund Olesen }); 1084655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1085655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // When possible, let DstReg be the larger interval. 1086ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (!CP.isPartial() && LIS->getInterval(CP.getSrcReg()).ranges.size() > 1087c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->getInterval(CP.getDstReg()).ranges.size()) 1088655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola CP.flip(); 1089655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1090655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1091655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Okay, attempt to join these two intervals. On failure, this returns false. 1092655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, if one of the intervals being joined is a physreg, this method 1093655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // always canonicalizes DstInt to be it. The output "SrcInt" will not have 1094655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // been modified, so we can use this information below to update aliases. 10959790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (!joinIntervals(CP)) { 1096655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing failed. 1097655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1098655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If definition of source is defined by trivial computation, try 1099655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // rematerializing it. 11001d4673228143965fafbcb679417f5a9be53d0a2aCameron Zwarich if (reMaterializeTrivialDef(CP, CopyMI)) 1101655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1102655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1103655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // If we can eliminate the copy without merging the live ranges, do so now. 11040984461dfb329c8e43ca70e264f56cd39bbae573Jakob Stoklund Olesen if (!CP.isPartial() && !CP.isPhys()) { 11059790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen if (adjustCopiesBackFrom(CP, CopyMI) || 11069790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen removeCopyByCommutingDef(CP, CopyMI)) { 1107ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1108ccce1233a27e9527cfb68cbced311351332a3a4eJakob Stoklund Olesen CopyMI->eraseFromParent(); 1109655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tTrivial!\n"); 1110655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1111655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1112655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1113655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1114655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Otherwise, we are unable to join the intervals. 1115655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "\tInterference!\n"); 1116655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola Again = true; // May be possible to coalesce later. 1117655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return false; 1118655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1119655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1120655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Coalescing to a virtual register that is of a sub-register class of the 1121655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // other. Make sure the resulting register is set to the right register class. 1122655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (CP.isCrossClass()) { 1123655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numCrossRCs; 1124c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI->setRegClass(CP.getDstReg(), CP.getNewRC()); 1125655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 1126655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 112703c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register copies can ease the register class constraints. 112803c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Make sure we attempt to inflate the register class of DstReg. 112903c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen if (!CP.isPhys() && RegClassInfo.isProperSubClass(CP.getNewRC())) 113003c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.push_back(CP.getDstReg()); 113103c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen 11327ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // CopyMI has been erased by joinIntervals at this point. Remove it from 11337ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // ErasedInstrs since copyCoalesceWorkList() won't add a successful join back 11347ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen // to the work list. This keeps ErasedInstrs from growing needlessly. 11357ebed91fddbcd259d03c4b438719ac1ce2a4fc87Jakob Stoklund Olesen ErasedInstrs.erase(CopyMI); 1136655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1137ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Rewrite all SrcReg operands to DstReg. 1138ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen // Also update DstReg operands to include DstIdx if it is set. 1139ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen if (CP.getDstIdx()) 1140ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getDstReg(), CP.getDstReg(), CP.getDstIdx()); 1141ceacd6da8c31106333952f6dc4fd6e6aa98312f1Jakob Stoklund Olesen updateRegDefsUses(CP.getSrcReg(), CP.getDstReg(), CP.getSrcIdx()); 1142655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1143e02a17c4efb843b8627f3d819c62f88a7f2fb457Lang Hames // SrcReg is guaranteed to be the register whose live interval that is 1144655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // being merged. 1145c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->removeInterval(CP.getSrcReg()); 1146655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1147655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Update regalloc hint. 1148c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI->UpdateRegAllocHint(CP.getSrcReg(), CP.getDstReg(), *MF); 1149655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 115004ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen DEBUG({ 115104ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << "\tJoined. Result = " << PrintReg(CP.getDstReg(), TRI); 115204ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen if (!CP.isPhys()) 115304ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << LIS->getInterval(CP.getDstReg()); 115404ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen dbgs() << '\n'; 115504ce06dc4c9dff4ff7a8b97079e3cbb7b60da3abJakob Stoklund Olesen }); 1156655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 1157655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola ++numJoins; 1158655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 1159655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 1160655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 116192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen/// Attempt joining with a reserved physreg. 116292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesenbool RegisterCoalescer::joinReservedPhysReg(CoalescerPair &CP) { 116392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isPhys() && "Must be a physreg copy"); 116414d1dd95c7c969e07defebb6fe65df2fae1b30cfJakob Stoklund Olesen assert(MRI->isReserved(CP.getDstReg()) && "Not a reserved register"); 116592ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 1166b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen DEBUG(dbgs() << "\t\tRHS = " << PrintReg(CP.getSrcReg()) << ' ' << RHS 1167b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen << '\n'); 116892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 116992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen assert(CP.isFlipped() && RHS.containsOneValue() && 117092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen "Invalid join with reserved register"); 117192ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 117292ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Optimization for reserved registers like ESP. We can only merge with a 117392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved physreg if RHS has a single value that is a copy of CP.DstReg(). 117492ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // The live range of the reserved register will look like a set of dead defs 117592ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // - we don't properly track the live range of reserved registers. 117692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 117792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Deny any overlapping intervals. This depends on all the reserved 117892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live ranges to look like dead defs. 1179241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen for (MCRegUnitIterator UI(CP.getDstReg(), TRI); UI.isValid(); ++UI) 1180241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen if (RHS.overlaps(LIS->getRegUnit(*UI))) { 1181241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tInterference: " << PrintRegUnit(*UI, TRI) << '\n'); 1182241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen return false; 118392ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen } 1184241d0209a765c97c684b120527e185f17723f650Jakob Stoklund Olesen 118592ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // Skip any value computations, we are not adding new values to the 118692ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // reserved register. Also skip merging the live ranges, the reserved 118792ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // register live range doesn't need to be accurate as long as all the 118892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen // defs are there. 1189857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 1190e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen // Delete the identity copy. 1191e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen MachineInstr *CopyMI = MRI->getVRegDef(RHS.reg); 1192e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(CopyMI); 1193e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen CopyMI->eraseFromParent(); 1194e744ac49f4cf878e2b34dba26964f04fb0415fa3Jakob Stoklund Olesen 1195857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen // We don't track kills for reserved registers. 1196857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen MRI->clearKillFlags(CP.getSrcReg()); 1197857ed2260403f2cbfe702e83da283b78e341707eJakob Stoklund Olesen 119892ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen return true; 119992ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen} 120092ff7cae7c5a6ce236549516119a9e0b2e71fda0Jakob Stoklund Olesen 1201c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1202c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// Interference checking and interval joining 1203c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen//===----------------------------------------------------------------------===// 1204c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1205c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// In the easiest case, the two live ranges being joined are disjoint, and 1206c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// there is no interference to consider. It is quite common, though, to have 1207c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping live ranges, and we need to check if the interference can be 1208c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// resolved. 1209c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1210c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of a single SSA value forms a sub-tree of the dominator tree. 1211c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This means that two SSA values overlap if and only if the def of one value 1212c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is contained in the live range of the other value. As a special case, the 1213c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// overlapping values can be defined at the same index. 1214c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1215c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The interference from an overlapping def can be resolved in these cases: 1216c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1217c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1. Coalescable copies. The value is defined by a copy that would become an 1218c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// identity copy after joining SrcReg and DstReg. The copy instruction will 1219c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// be removed, and the value will be merged with the source value. 1220c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1221c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// There can be several copies back and forth, causing many values to be 1222c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merged into one. We compute a list of ultimate values in the joined live 1223c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// range as well as a mappings from the old value numbers. 1224c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1225c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 2. IMPLICIT_DEF. This instruction is only inserted to ensure all PHI 1226c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// predecessors have a live out value. It doesn't cause real interference, 1227c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// and can be merged into the value it overlaps. Like a coalescable copy, it 1228c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// can be erased after joining. 1229c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1230c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 3. Copy of external value. The overlapping def may be a copy of a value that 1231c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is already in the other register. This is like a coalescable copy, but 1232c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// the live range of the source register must be trimmed after erasing the 1233c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// copy instruction: 1234c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1235c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = COPY %ext 1236c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst = COPY %ext <-- Remove this COPY, trim the live range of %ext. 1237c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1238c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 4. Clobbering undefined lanes. Vector registers are sometimes built by 1239c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// defining one lane at a time: 1240c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1241c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub0<def,read-undef> = FOO 1242c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1243c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1244c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1245c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The live range of %src overlaps the %dst value defined by FOO, but 1246c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// merging %src into %dst:ssub1 is only going to clobber the ssub1 lane 1247c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// which was undef anyway. 1248c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1249c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// The value mapping is more complicated in this case. The final live range 1250c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// will have different value numbers for both FOO and BAR, but there is no 1251c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// simple mapping from old to new values. It may even be necessary to add 1252c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// new PHI values. 1253c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1254c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 5. Clobbering dead lanes. A def may clobber a lane of a vector register that 1255c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// is live, but never read. This can happen because we don't compute 1256c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// individual live ranges per lane. 1257c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1258c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst<def> = FOO 1259c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %src = BAR 1260c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// %dst:ssub1<def> = COPY %src 1261c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// 1262c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// This kind of interference is only resolved locally. If the clobbered 1263c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen// lane value escapes the block, the join is aborted. 1264c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1265c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesennamespace { 1266c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Track information about values in a single virtual register about to be 1267c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// joined. Objects of this class are always created in pairs - one for each 1268c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// side of the CoalescerPair. 1269c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenclass JoinVals { 1270c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LI; 1271c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1272c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Location of this register in the final joined register. 1273c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Either CP.DstIdx or CP.SrcIdx. 1274c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned SubIdx; 1275c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1276c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Values that will be present in the final live range. 1277c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &NewVNInfo; 1278c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1279c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &CP; 1280c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *LIS; 1281c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndexes *Indexes; 1282c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *TRI; 1283c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1284c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value number assignments. Maps value numbers in LI to entries in NewVNInfo. 1285c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is suitable for passing to LiveInterval::join(). 1286c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<int, 8> Assignments; 1287c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1288c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conflict resolution for overlapping values. 1289c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen enum ConflictResolution { 1290c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, simply keep this value. 1291c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Keep, 1292c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1293c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI and erase the defining instruction. 1294c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used for IMPLICIT_DEF, coalescable copies, and copies from external 1295c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values. 1296c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Erase, 1297c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1298c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this value into OtherVNI but keep the defining instruction. 1299c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is for the special case where OtherVNI is defined by the same 1300c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // instruction. 1301c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Merge, 1302c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1303c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, and have it replace OtherVNI where possible. This 1304c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // complicates value mapping since OtherVNI maps to two different values 1305c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // before and after this def. 1306c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Used when clobbering undefined or dead lanes. 1307c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Replace, 1308c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1309c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolved conflict. Visit later when all values have been mapped. 1310c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Unresolved, 1311c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1312c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Unresolvable conflict. Abort the join. 1313c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen CR_Impossible 1314c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1315c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1316c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Per-value info for LI. The lane bit masks are all relative to the final 1317c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // joined register, so they can be compared directly between SrcReg and 1318c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // DstReg. 1319c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen struct Val { 1320c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution Resolution; 1321c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1322c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes written by this def, 0 for unanalyzed values. 1323c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned WriteLanes; 1324c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1325c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Lanes with defined values in this register. Other lanes are undef and 1326c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // safe to clobber. 1327c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned ValidLanes; 1328c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1329c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in LI being redefined by this def. 1330c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *RedefVNI; 1331c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1332c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Value in the other live range that overlaps this def, if any. 1333c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *OtherVNI; 1334c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1335251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Is this value an IMPLICIT_DEF that can be erased? 1336251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1337251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF values should only exist at the end of a basic block that 1338251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // is a predecessor to a phi-value. These IMPLICIT_DEF instructions can be 1339251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // safely erased if they are overlapping a live value in the other live 1340251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // interval. 1341251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1342251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Weird control flow graphs and incomplete PHI handling in 1343251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // ProcessImplicitDefs can very rarely create IMPLICIT_DEF values with 1344251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // longer live ranges. Such IMPLICIT_DEF values should be treated like 1345251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // normal values. 1346251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool ErasableImplicitDef; 1347795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 13482df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True when the live range of this value will be pruned because of an 13492df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // overlapping CR_Replace value in the other live range. 13502df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool Pruned; 13512df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 13522df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // True once Pruned above has been computed. 13532df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool PrunedComputed; 13542df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 1355c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val() : Resolution(CR_Keep), WriteLanes(0), ValidLanes(0), 1356251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen RedefVNI(0), OtherVNI(0), ErasableImplicitDef(false), 1357251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Pruned(false), PrunedComputed(false) {} 1358c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1359c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool isAnalyzed() const { return WriteLanes != 0; } 1360c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen }; 1361c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1362c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One entry per value number in LI. 1363c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<Val, 8> Vals; 1364c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1365c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned computeWriteLanes(const MachineInstr *DefMI, bool &Redef); 1366c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *stripCopies(VNInfo *VNI); 1367c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen ConflictResolution analyzeValue(unsigned ValNo, JoinVals &Other); 1368c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void computeAssignment(unsigned ValNo, JoinVals &Other); 1369d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool taintExtent(unsigned, unsigned, JoinVals&, 1370d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> >&); 1371d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen bool usesLanes(MachineInstr *MI, unsigned, unsigned, unsigned); 13722df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen bool isPrunedValue(unsigned ValNo, JoinVals &Other); 1373c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1374c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenpublic: 1375c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals(LiveInterval &li, unsigned subIdx, 1376c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<VNInfo*> &newVNInfo, 1377c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const CoalescerPair &cp, 1378c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveIntervals *lis, 1379c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const TargetRegisterInfo *tri) 1380c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen : LI(li), SubIdx(subIdx), NewVNInfo(newVNInfo), CP(cp), LIS(lis), 1381c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Indexes(LIS->getSlotIndexes()), TRI(tri), 1382c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments(LI.getNumValNums(), -1), Vals(LI.getNumValNums()) 1383c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen {} 1384c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1385c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Analyze defs in LI and compute a value mapping in NewVNInfo. 1386c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1387c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool mapValues(JoinVals &Other); 1388c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1389c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Try to resolve conflicts that require all values to be mapped. 1390c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Returns false if any conflicts were impossible to resolve. 1391c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool resolveConflicts(JoinVals &Other); 1392c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 139387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// Prune the live range of values in Other.LI where they would conflict with 139487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// CR_Replace values in LI. Collect end points for restoring the live range 139587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen /// after joining. 139687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen void pruneValues(JoinVals &Other, SmallVectorImpl<SlotIndex> &EndPoints); 139787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1398c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Erase any machine instructions that have been coalesced away. 1399c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add erased instructions to ErasedInstrs. 1400c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Add foreign virtual registers to ShrinkRegs if their live range ended at 1401c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// the erased instrs. 1402c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen void eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1403c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs); 1404c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1405c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen /// Get the value assignments suitable for passing to LiveInterval::join. 140656acf63e35440068935bca999d19a81f76e876d6Jakob Stoklund Olesen const int *getAssignments() const { return Assignments.data(); } 1407c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen}; 1408c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} // end anonymous namespace 1409c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1410c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the bitmask of lanes actually written by DefMI. 1411c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Set Redef if there are any partial register definitions that depend on the 1412c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// previous value of the register. 1413c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenunsigned JoinVals::computeWriteLanes(const MachineInstr *DefMI, bool &Redef) { 1414c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned L = 0; 1415c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (ConstMIOperands MO(DefMI); MO.isValid(); ++MO) { 1416c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MO->isReg() || MO->getReg() != LI.reg || !MO->isDef()) 1417c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 141821caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen L |= TRI->getSubRegIndexLaneMask( 141921caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg())); 1420c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (MO->readsReg()) 1421c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Redef = true; 1422c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1423c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return L; 1424c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1425c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1426c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Find the ultimate value that VNI was copied from. 1427c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenVNInfo *JoinVals::stripCopies(VNInfo *VNI) { 1428c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!VNI->isPHIDef()) { 1429c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(VNI->def); 1430c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(MI && "No defining instruction"); 1431c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!MI->isFullCopy()) 1432c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1433c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1434c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!TargetRegisterInfo::isVirtualRegister(Reg)) 1435c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1436c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveRangeQuery LRQ(LIS->getInterval(Reg), VNI->def); 1437c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LRQ.valueIn()) 1438c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1439c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNI = LRQ.valueIn(); 1440c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1441c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return VNI; 1442c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1443c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1444c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Analyze ValNo in this live range, and set all fields of Vals[ValNo]. 1445c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Return a conflict resolution when possible, but leave the hard cases as 1446c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// CR_Unresolved. 1447c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Recursively calls computeAssignment() on this and Other, guaranteeing that 1448c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// both OtherVNI and RedefVNI have been analyzed and mapped before returning. 1449c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// The recursion always goes upwards in the dominator tree, making loops 1450c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// impossible. 1451c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::ConflictResolution 1452c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund OlesenJoinVals::analyzeValue(unsigned ValNo, JoinVals &Other) { 1453c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1454c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!V.isAnalyzed() && "Value has already been analyzed!"); 1455c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1456c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isUnused()) { 1457c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.WriteLanes = ~0u; 1458c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1459c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1460c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1461c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Get the instruction defining this value, compute the lanes written. 1462c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen const MachineInstr *DefMI = 0; 1463c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) { 1464c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Conservatively assume that all lanes in a PHI are valid. 1465c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = TRI->getSubRegIndexLaneMask(SubIdx); 1466c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } else { 1467c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DefMI = Indexes->getInstructionFromIndex(VNI->def); 1468c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen bool Redef = false; 1469c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes = V.WriteLanes = computeWriteLanes(DefMI, Redef); 1470c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1471c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // If this is a read-modify-write instruction, there may be more valid 1472c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // lanes than the ones written by this instruction. 1473c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This only covers partial redef operands. DefMI may have normal use 1474c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // operands reading the register. They don't contribute valid lanes. 1475c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1476c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This adds ssub1 to the set of valid lanes in %src: 1477c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1478c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def> = FOO 1479c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1480c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This leaves only ssub1 valid, making any other lanes undef: 1481c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1482c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %src:ssub1<def,read-undef> = FOO %src:ssub2 1483c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1484c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The <read-undef> flag on the def operand means that old lane values are 1485c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // not important. 1486c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Redef) { 1487c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.RedefVNI = LiveRangeQuery(LI, VNI->def).valueIn(); 1488c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.RedefVNI && "Instruction is reading nonexistent value"); 1489c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(V.RedefVNI->id, Other); 1490c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes |= Vals[V.RedefVNI->id].ValidLanes; 1491c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1492c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1493c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // An IMPLICIT_DEF writes undef values. 1494795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (DefMI->isImplicitDef()) { 1495251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // We normally expect IMPLICIT_DEF values to be live only until the end 1496251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // of their block. If the value is really live longer and gets pruned in 1497251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // another block, this flag is cleared again. 1498251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen V.ErasableImplicitDef = true; 1499c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes; 1500795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1501c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1502c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1503c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Find the value in Other that overlaps VNI->def, if any. 1504c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveRangeQuery OtherLRQ(Other.LI, VNI->def); 1505c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1506c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // It is possible that both values are defined by the same instruction, or 1507c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // the values are PHIs defined in the same block. When that happens, the two 1508c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // values should be merged into one, but not into any preceding value. 1509c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // The first value defined or visited gets CR_Keep, the other gets CR_Merge. 1510c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNInfo *OtherVNI = OtherLRQ.valueDefined()) { 1511c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ"); 1512c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1513c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // One value stays, the other is merged. Keep the earlier one, or the first 1514c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // one we see. 1515c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherVNI->def < VNI->def) 1516c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(OtherVNI->id, *this); 1517c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else if (VNI->def < OtherVNI->def && OtherLRQ.valueIn()) { 1518c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This is an early-clobber def overlapping a live-in value in the other 1519c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // register. Not mergeable. 1520c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1521c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Impossible; 1522c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1523c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherVNI; 1524c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &OtherV = Other.Vals[OtherVNI->id]; 1525c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Keep this value, check for conflicts when analyzing OtherVNI. 1526c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!OtherV.isAnalyzed()) 1527c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1528e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Both sides have been analyzed now. 1529e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1530e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1531e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen if (VNI->isPHIDef()) 1532e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Merge; 1533c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.ValidLanes & OtherV.ValidLanes) 1534d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Overlapping lanes can't be resolved. 1535d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1536c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen else 1537c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Merge; 1538c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1539c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1540c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No simultaneous def. Is Other live at the def? 1541c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen V.OtherVNI = OtherLRQ.valueIn(); 1542c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!V.OtherVNI) 1543c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // No overlap, no conflict. 1544c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1545c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1546c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ"); 1547c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1548c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // We have overlapping values, or possibly a kill of Other. 1549c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursively compute assignments up the dominator tree. 1550c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Other.computeAssignment(V.OtherVNI->id, *this); 1551251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen Val &OtherV = Other.Vals[V.OtherVNI->id]; 1552251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen 1553251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // Check if OtherV is an IMPLICIT_DEF that extends beyond its basic block. 1554251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // This shouldn't normally happen, but ProcessImplicitDefs can leave such 1555251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // IMPLICIT_DEF instructions behind, and there is nothing wrong with it 1556251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // technically. 1557251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // 1558251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // WHen it happens, treat that IMPLICIT_DEF as a normal value, and don't try 1559251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen // to erase the IMPLICIT_DEF instruction. 1560251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (OtherV.ErasableImplicitDef && DefMI && 1561251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DefMI->getParent() != Indexes->getMBBFromIndex(V.OtherVNI->def)) { 1562251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen DEBUG(dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def 1563251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << " extends into BB#" << DefMI->getParent()->getNumber() 1564251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen << ", keeping it.\n"); 1565251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.ErasableImplicitDef = false; 1566251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen } 1567c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1568e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // Allow overlapping PHI values. Any real interference would show up in a 1569e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen // predecessor, the PHI itself can't introduce any conflicts. 1570c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (VNI->isPHIDef()) 1571e6e2d8cd90ceb5190aa646dc06584027f7d492d0Jakob Stoklund Olesen return CR_Replace; 1572c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1573c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Check for simple erasable conflicts. 1574c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isImplicitDef()) 1575c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1576c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1577c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Include the non-conflict where DefMI is a coalescable copy that kills 1578c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // OtherVNI. We still want the copy erased and value numbers merged. 1579c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (CP.isCoalescable(DefMI)) { 1580c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some of the lanes copied from OtherVNI may be undef, making them undef 1581c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // here too. 158287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen V.ValidLanes &= ~V.WriteLanes | OtherV.ValidLanes; 1583c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1584c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1585c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1586c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This may not be a real conflict if DefMI simply kills Other and defines 1587c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // VNI. 1588c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (OtherLRQ.isKill() && OtherLRQ.endPoint() <= VNI->def) 1589c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Keep; 1590c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1591c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Handle the case where VNI and OtherVNI can be proven to be identical: 1592c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1593c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %other = COPY %ext 1594c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // %this = COPY %ext <-- Erase this copy 1595c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // 1596c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (DefMI->isFullCopy() && !CP.isPartial() && 1597c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen stripCopies(VNI) == stripCopies(V.OtherVNI)) 1598c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return CR_Erase; 1599c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 160087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // If the lanes written by this instruction were all undef in OtherVNI, it is 160187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // still safe to join the live ranges. This can't be done with a simple value 160287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // mapping, though - OtherVNI will map to multiple values: 160387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 160487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 1 %dst:ssub0 = FOO <-- OtherVNI 160587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 2 %src = BAR <-- VNI 160687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 3 %dst:ssub1 = COPY %src<kill> <-- Eliminate this copy. 160787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 4 BAZ %dst<kill> 160887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 5 QUUX %src<kill> 160987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // 161087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Here OtherVNI will map to itself in [1;2), but to VNI in [2;5). CR_Replace 161187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // handles this complex value mapping. 161287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if ((V.WriteLanes & OtherV.ValidLanes) == 0) 161387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return CR_Replace; 161487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1615163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // If the other live range is killed by DefMI and the live ranges are still 1616163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // overlapping, it must be because we're looking at an early clobber def: 1617163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1618163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // %dst<def,early-clobber> = ASM %src<kill> 1619163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // 1620163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // In this case, it is illegal to merge the two live ranges since the early 1621163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // clobber def would clobber %src before it was read. 1622163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen if (OtherLRQ.isKill()) { 1623163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen // This case where the def doesn't overlap the kill is handled above. 1624163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen assert(VNI->def.isEarlyClobber() && 1625163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen "Only early clobber defs can overlap a kill"); 1626163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen return CR_Impossible; 1627163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen } 1628163f67f4d98aab114cb9b04efd086f54f7688d0cJakob Stoklund Olesen 1629d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is clobbering live lanes in OtherVNI, but there is still the 1630d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // possibility that no instructions actually read the clobbered lanes. 1631d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // If we're clobbering all the lanes in OtherVNI, at least one must be read. 1632d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Otherwise Other.LI wouldn't be live here. 1633d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if ((TRI->getSubRegIndexLaneMask(Other.SubIdx) & ~V.WriteLanes) == 0) 1634d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1635d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1636d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // We need to verify that no instructions are reading the clobbered lanes. To 1637d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // save compile time, we'll only check that locally. Don't allow the tainted 1638d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // value to escape the basic block. 1639d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1640d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (OtherLRQ.endPoint() >= Indexes->getMBBEndIdx(MBB)) 1641d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Impossible; 1642d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1643d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // There are still some things that could go wrong besides clobbered lanes 1644d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // being read, for example OtherVNI may be only partially redefined in MBB, 1645d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // and some clobbered lanes could escape the block. Save this analysis for 1646d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // resolveConflicts() when all values have been mapped. We need to know 1647d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // RedefVNI and WriteLanes for any later defs in MBB, and we can't compute 1648d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // that now - the recursive analyzeValue() calls must go upwards in the 1649d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // dominator tree. 1650d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return CR_Unresolved; 1651c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1652c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1653c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// Compute the value assignment for ValNo in LI. 1654c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// This may be called recursively by analyzeValue(), but never for a ValNo on 1655c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen/// the stack. 1656c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::computeAssignment(unsigned ValNo, JoinVals &Other) { 1657c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Val &V = Vals[ValNo]; 1658c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (V.isAnalyzed()) { 1659c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Recursion should always move up the dominator tree, so ValNo is not 1660c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // supposed to reappear before it has been assigned. 1661c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Assignments[ValNo] != -1 && "Bad recursion?"); 1662c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return; 1663c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1664c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen switch ((V.Resolution = analyzeValue(ValNo, Other))) { 1665c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Erase: 1666c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen case CR_Merge: 1667c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Merge this ValNo into OtherVNI. 1668c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't merge."); 1669c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen assert(Other.Vals[V.OtherVNI->id].isAnalyzed() && "Missing recursion"); 1670c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = Other.Assignments[V.OtherVNI->id]; 1671c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tmerge " << PrintReg(LI.reg) << ':' << ValNo << '@' 1672c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << LI.getValNumInfo(ValNo)->def << " into " 1673c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << PrintReg(Other.LI.reg) << ':' << V.OtherVNI->id << '@' 1674c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << V.OtherVNI->def << " --> @" 1675c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << NewVNInfo[Assignments[ValNo]]->def << '\n'); 1676c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 16772df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Replace: 16782df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 16792df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // The other value is going to be pruned if this join is successful. 16802df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen assert(V.OtherVNI && "OtherVNI not assigned, can't prune"); 16812df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Other.Vals[V.OtherVNI->id].Pruned = true; 16822df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Fall through. 1683c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen default: 1684c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // This value number needs to go in the final joined live range. 1685c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen Assignments[ValNo] = NewVNInfo.size(); 1686c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen NewVNInfo.push_back(LI.getValNumInfo(ValNo)); 1687c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen break; 1688c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1689c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1690c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1691c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::mapValues(JoinVals &Other) { 1692c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1693c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen computeAssignment(i, Other); 1694c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (Vals[i].Resolution == CR_Impossible) { 1695c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tinterference at " << PrintReg(LI.reg) << ':' << i 1696c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1697c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1698c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1699c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1700c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1701c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1702c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1703d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Assuming ValNo is going to clobber some valid lanes in Other.LI, compute 1704d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// the extent of the tainted lanes in the block. 1705d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1706d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Multiple values in Other.LI can be affected since partial redefinitions can 1707d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// preserve previously tainted lanes. 1708d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1709d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1 %dst = VLOAD <-- Define all lanes in %dst 1710d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 2 %src = FOO <-- ValNo to be joined with %dst:ssub0 1711d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 3 %dst:ssub1 = BAR <-- Partial redef doesn't clear taint in ssub0 1712d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 4 %dst:ssub0 = COPY %src <-- Conflict resolved, ssub0 wasn't read 1713d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1714d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// For each ValNo in Other that is affected, add an (EndIndex, TaintedLanes) 1715d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// entry to TaintedVals. 1716d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// 1717d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Returns false if the tainted lanes extend beyond the basic block. 1718d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals:: 1719d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund OlesentaintExtent(unsigned ValNo, unsigned TaintedLanes, JoinVals &Other, 1720d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVectorImpl<std::pair<SlotIndex, unsigned> > &TaintExtent) { 1721d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(ValNo); 1722d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1723d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex MBBEnd = Indexes->getMBBEndIdx(MBB); 1724d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1725d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Scan Other.LI from VNI.def to MBBEnd. 1726d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LiveInterval::iterator OtherI = Other.LI.find(VNI->def); 1727d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(OtherI != Other.LI.end() && "No conflict?"); 1728d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen do { 1729d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // OtherI is pointing to a tainted value. Abort the join if the tainted 1730d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // lanes escape the block. 1731d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SlotIndex End = OtherI->end; 1732d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End >= MBBEnd) { 1733d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints global " << PrintReg(Other.LI.reg) << ':' 1734d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start << '\n'); 1735d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1736d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1737d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttaints local " << PrintReg(Other.LI.reg) << ':' 1738d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << OtherI->valno->id << '@' << OtherI->start 1739d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen << " to " << End << '\n'); 1740d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // A dead def is not a problem. 1741d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (End.isDead()) 1742d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1743d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintExtent.push_back(std::make_pair(End, TaintedLanes)); 1744d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1745d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Check for another def in the MBB. 1746d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++OtherI == Other.LI.end() || OtherI->start >= MBBEnd) 1747d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1748d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1749d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Lanes written by the new def are no longer tainted. 1750d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OV = Other.Vals[OtherI->valno->id]; 1751d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes &= ~OV.WriteLanes; 1752d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!OV.RedefVNI) 1753d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1754d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } while (TaintedLanes); 1755d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1756d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1757d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1758d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// Return true if MI uses any of the given Lanes from Reg. 1759d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen/// This does not include partial redefinitions of Reg. 1760d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesenbool JoinVals::usesLanes(MachineInstr *MI, unsigned Reg, unsigned SubIdx, 1761d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned Lanes) { 1762d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (MI->isDebugValue()) 1763d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1764d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for (ConstMIOperands MO(MI); MO.isValid(); ++MO) { 1765d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->isReg() || MO->isDef() || MO->getReg() != Reg) 1766d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 1767d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!MO->readsReg()) 1768d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen continue; 176921caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen if (Lanes & TRI->getSubRegIndexLaneMask( 177021caa9ef03e3f2d4e860c8fc3cd53015c42934bfJakob Stoklund Olesen TRI->composeSubRegIndices(SubIdx, MO->getSubReg()))) 1771d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return true; 1772d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1773d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1774d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen} 1775d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1776c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool JoinVals::resolveConflicts(JoinVals &Other) { 1777c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1778d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Val &V = Vals[i]; 1779d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert (V.Resolution != CR_Impossible && "Unresolvable conflict"); 1780d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (V.Resolution != CR_Unresolved) 1781c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen continue; 1782c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tconflict at " << PrintReg(LI.reg) << ':' << i 1783c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '@' << LI.getValNumInfo(i)->def << '\n'); 1784d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneConflicts; 1785d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(V.OtherVNI && "Inconsistent conflict resolution."); 1786d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen VNInfo *VNI = LI.getValNumInfo(i); 1787d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen const Val &OtherV = Other.Vals[V.OtherVNI->id]; 1788d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1789d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // VNI is known to clobber some lanes in OtherVNI. If we go ahead with the 1790d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // join, those lanes will be tainted with a wrong value. Get the extent of 1791d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // the tainted lanes. 1792d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintedLanes = V.WriteLanes & OtherV.ValidLanes; 1793d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen SmallVector<std::pair<SlotIndex, unsigned>, 8> TaintExtent; 1794d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!taintExtent(i, TaintedLanes, Other, TaintExtent)) 1795d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Tainted lanes would extend beyond the basic block. 1796d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1797d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1798d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!TaintExtent.empty() && "There should be at least one conflict."); 1799d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1800d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // Now look at the instructions from VNI->def to TaintExtent (inclusive). 1801d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def); 1802d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineBasicBlock::iterator MI = MBB->begin(); 1803d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (!VNI->isPHIDef()) { 1804d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MI = Indexes->getInstructionFromIndex(VNI->def); 1805d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // No need to check the instruction defining VNI for reads. 1806d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1807d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1808d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(!SlotIndex::isSameInstr(VNI->def, TaintExtent.front().first) && 1809d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen "Interference ends on VNI->def. Should have been handled earlier"); 1810d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen MachineInstr *LastMI = 1811d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen Indexes->getInstructionFromIndex(TaintExtent.front().first); 1812d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1813d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen unsigned TaintNum = 0; 1814d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen for(;;) { 1815d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(MI != MBB->end() && "Bad LastMI"); 1816d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (usesLanes(MI, Other.LI.reg, Other.SubIdx, TaintedLanes)) { 1817d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen DEBUG(dbgs() << "\t\ttainted lanes used by: " << *MI); 1818d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen return false; 1819d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1820d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // LastMI is the last instruction to use the current value. 1821d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (&*MI == LastMI) { 1822d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen if (++TaintNum == TaintExtent.size()) 1823d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen break; 1824d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen LastMI = Indexes->getInstructionFromIndex(TaintExtent[TaintNum].first); 1825d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen assert(LastMI && "Range must end at a proper instruction"); 1826d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen TaintedLanes = TaintExtent[TaintNum].second; 1827d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1828d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++MI; 1829d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen } 1830d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen 1831d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen // The tainted lanes are unused. 1832d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen V.Resolution = CR_Replace; 1833d40d4c34f72d1eda3cd9ba0f3dbf2d43b726f06cJakob Stoklund Olesen ++NumLaneResolves; 1834c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1835c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 1836c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1837c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 18382df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// Determine if ValNo is a copy of a value number in LI or Other.LI that will 18392df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// be pruned: 18402df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 18412df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src 18422df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %src = COPY %dst <-- This value to be pruned. 18432df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// %dst = COPY %src <-- This value is a copy of a pruned value. 18442df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen// 18452df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesenbool JoinVals::isPrunedValue(unsigned ValNo, JoinVals &Other) { 18462df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen Val &V = Vals[ValNo]; 18472df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Pruned || V.PrunedComputed) 18482df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18492df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18502df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (V.Resolution != CR_Erase && V.Resolution != CR_Merge) 18512df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18522df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 18532df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // Follow copies up the dominator tree and check if any intermediate value 18542df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // has been pruned. 18552df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.PrunedComputed = true; 18562df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen V.Pruned = Other.isPrunedValue(V.OtherVNI->id, *this); 18572df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen return V.Pruned; 18582df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen} 18592df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen 186087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesenvoid JoinVals::pruneValues(JoinVals &Other, 186187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVectorImpl<SlotIndex> &EndPoints) { 186287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 186387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 18642df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen switch (Vals[i].Resolution) { 18652df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Keep: 18662df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1867795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Replace: { 18682df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value takes precedence over the value in Other.LI. 18692df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&Other.LI, Def, &EndPoints); 1870795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Check if we're replacing an IMPLICIT_DEF value. The IMPLICIT_DEF 1871795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // instructions are only inserted to provide a live-out value for PHI 1872795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // predecessors, so the instruction should simply go away once its value 1873795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // has been replaced. 1874795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Val &OtherV = Other.Vals[Vals[i].OtherVNI->id]; 1875251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen bool EraseImpDef = OtherV.ErasableImplicitDef && 1876251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen OtherV.Resolution == CR_Keep; 1877d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!Def.isBlock()) { 1878795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove <def,read-undef> flags. This def is now a partial redef. 1879d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // Also remove <def,dead> flags since the joined live range will 1880d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen // continue past this instruction. 188183ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen for (MIOperands MO(Indexes->getInstructionFromIndex(Def)); 188283ef63efced9a957fe370134314645d2188c7203Jakob Stoklund Olesen MO.isValid(); ++MO) 1883d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (MO->isReg() && MO->isDef() && MO->getReg() == LI.reg) { 1884d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsUndef(EraseImpDef); 1885d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen MO->setIsDead(false); 1886d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen } 1887795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // This value will reach instructions below, but we need to make sure 1888795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // the live range also reaches the instruction at Def. 1889d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen if (!EraseImpDef) 1890d86296a4aea7ebac9c8ef8ba92642b64545dec95Jakob Stoklund Olesen EndPoints.push_back(Def); 189127cb347d0e765175efb2c4d388bcbba84cf1b95eJakob Stoklund Olesen } 18922df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned " << PrintReg(Other.LI.reg) << " at " << Def 18932df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << ": " << Other.LI << '\n'); 18942df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 1895795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 18962df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Erase: 18972df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Merge: 18982df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen if (isPrunedValue(i, Other)) { 18992df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // This value is ultimately a copy of a pruned value in LI or Other.LI. 19002df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // We can no longer trust the value mapping computed by 19012df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // computeAssignment(), the value that was originally copied could have 19022df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen // been replaced. 19032df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen LIS->pruneValue(&LI, Def, &EndPoints); 19042df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tpruned all of " << PrintReg(LI.reg) << " at " 19052df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen << Def << ": " << LI << '\n'); 19062df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 19072df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen break; 19082df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Unresolved: 19092df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen case CR_Impossible: 19102df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen llvm_unreachable("Unresolved conflicts"); 19112df8ac84ae8317b6a96f19bbc984d2bd02cff087Jakob Stoklund Olesen } 191287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen } 191387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen} 191487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1915c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenvoid JoinVals::eraseInstrs(SmallPtrSet<MachineInstr*, 8> &ErasedInstrs, 1916c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVectorImpl<unsigned> &ShrinkRegs) { 1917c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen for (unsigned i = 0, e = LI.getNumValNums(); i != e; ++i) { 1918795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Get the def location before markUnused() below invalidates it. 1919c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SlotIndex Def = LI.getValNumInfo(i)->def; 1920795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen switch (Vals[i].Resolution) { 1921795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Keep: 1922795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // If an IMPLICIT_DEF value is pruned, it doesn't serve a purpose any 1923795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // longer. The IMPLICIT_DEF instructions are only inserted by 1924795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // PHIElimination to guarantee that all PHI predecessors have a value. 1925251ed7f3e59a857dd92bda1ba4f9305f33deb67bJakob Stoklund Olesen if (!Vals[i].ErasableImplicitDef || !Vals[i].Pruned) 1926795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1927795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // Remove value number i from LI. Note that this VNInfo is still present 1928795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // in NewVNInfo, so it will appear as an unused value number in the final 1929795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // joined interval. 1930795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.getValNumInfo(i)->markUnused(); 1931795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LI.removeValNo(LI.getValNumInfo(i)); 1932795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\tremoved " << i << '@' << Def << ": " << LI << '\n'); 1933795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen // FALL THROUGH. 1934795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen 1935795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen case CR_Erase: { 1936795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MachineInstr *MI = Indexes->getInstructionFromIndex(Def); 1937795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen assert(MI && "No instruction to erase"); 1938795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (MI->isCopy()) { 1939795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen unsigned Reg = MI->getOperand(1).getReg(); 1940795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen if (TargetRegisterInfo::isVirtualRegister(Reg) && 1941795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen Reg != CP.getSrcReg() && Reg != CP.getDstReg()) 1942795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ShrinkRegs.push_back(Reg); 1943795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1944795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen ErasedInstrs.insert(MI); 1945795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen DEBUG(dbgs() << "\t\terased:\t" << Def << '\t' << *MI); 1946795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen LIS->RemoveMachineInstrFromMaps(MI); 1947795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen MI->eraseFromParent(); 1948795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1949795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen } 1950795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen default: 1951795f951c6d5c60a10ffc8e0fdfa22b7c3b499f35Jakob Stoklund Olesen break; 1952c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1953c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen } 1954c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 1955c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1956c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesenbool RegisterCoalescer::joinVirtRegs(CoalescerPair &CP) { 1957c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<VNInfo*, 16> NewVNInfo; 1958c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &RHS = LIS->getInterval(CP.getSrcReg()); 1959c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LiveInterval &LHS = LIS->getInterval(CP.getDstReg()); 1960c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals RHSVals(RHS, CP.getSrcIdx(), NewVNInfo, CP, LIS, TRI); 1961c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen JoinVals LHSVals(LHS, CP.getDstIdx(), NewVNInfo, CP, LIS, TRI); 1962c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1963c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen DEBUG(dbgs() << "\t\tRHS = " << PrintReg(CP.getSrcReg()) << ' ' << RHS 1964c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << "\n\t\tLHS = " << PrintReg(CP.getDstReg()) << ' ' << LHS 1965c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen << '\n'); 1966c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1967c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // First compute NewVNInfo and the simple value mappings. 1968c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Detect impossible conflicts early. 1969c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.mapValues(RHSVals) || !RHSVals.mapValues(LHSVals)) 1970c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1971c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1972c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Some conflicts can only be resolved after all values have been mapped. 1973c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen if (!LHSVals.resolveConflicts(RHSVals) || !RHSVals.resolveConflicts(LHSVals)) 1974c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return false; 1975c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1976c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // All clear, the live ranges can be merged. 1977c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 197887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // The merging algorithm in LiveInterval::join() can't handle conflicting 197987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // value mappings, so we need to remove any live ranges that overlap a 198087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace resolution. Collect a set of end points that can be used to 198187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // restore the live range after joining. 198287f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen SmallVector<SlotIndex, 8> EndPoints; 198387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen LHSVals.pruneValues(RHSVals, EndPoints); 198487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen RHSVals.pruneValues(LHSVals, EndPoints); 198587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 1986c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Erase COPY and IMPLICIT_DEF instructions. This may cause some external 1987c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // registers to require trimming. 1988c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen SmallVector<unsigned, 8> ShrinkRegs; 1989c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 1990c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen RHSVals.eraseInstrs(ErasedInstrs, ShrinkRegs); 1991c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen while (!ShrinkRegs.empty()) 1992c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LIS->shrinkToUses(&LIS->getInterval(ShrinkRegs.pop_back_val())); 1993c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1994c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Join RHS into LHS. 1995c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen LHS.join(RHS, LHSVals.getAssignments(), RHSVals.getAssignments(), NewVNInfo, 1996c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI); 1997c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 1998c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Kill flags are going to be wrong if the live ranges were overlapping. 1999c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // Eventually, we should simply clear all kill flags when computing live 2000c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen // ranges. They are reinserted after register allocation. 2001c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(LHS.reg); 2002c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen MRI->clearKillFlags(RHS.reg); 200387f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 200487f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen if (EndPoints.empty()) 200587f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen return true; 200687f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen 200787f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // Recompute the parts of the live range we had to remove because of 200887f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen // CR_Replace conflicts. 200987f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen DEBUG(dbgs() << "\t\trestoring liveness to " << EndPoints.size() 201087f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen << " points: " << LHS << '\n'); 201187f7864c6d81ae134335b8271ac12c937c81dffcJakob Stoklund Olesen LIS->extendToIndices(&LHS, EndPoints); 2012c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen return true; 2013c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen} 2014c722ae7a2b470e544ce570692ef3b109449d69ecJakob Stoklund Olesen 20159790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen/// joinIntervals - Attempt to join these two intervals. On failure, this 2016655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// returns false. 20179790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenbool RegisterCoalescer::joinIntervals(CoalescerPair &CP) { 2018cdcdfd2cab67366b1debbe36bf46c29f7fecda67Jakob Stoklund Olesen return CP.isPhys() ? joinReservedPhysReg(CP) : joinVirtRegs(CP); 2019655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2020655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2021655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindolanamespace { 2022cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// Information concerning MBB coalescing priority. 2023cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trickstruct MBBPriorityInfo { 2024cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MachineBasicBlock *MBB; 2025cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned Depth; 2026cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick bool IsSplit; 2027cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2028cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick MBBPriorityInfo(MachineBasicBlock *mbb, unsigned depth, bool issplit) 2029cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick : MBB(mbb), Depth(depth), IsSplit(issplit) {} 2030cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick}; 2031cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick} 2032655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2033cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// C-style comparator that sorts first based on the loop depth of the basic 2034cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// block (the unsigned), and then on the MBB number. 2035cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// 2036cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick// EnableGlobalCopies assumes that the primary sort key is loop depth. 2037cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trickstatic int compareMBBPriority(const void *L, const void *R) { 2038cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick const MBBPriorityInfo *LHS = static_cast<const MBBPriorityInfo*>(L); 2039cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick const MBBPriorityInfo *RHS = static_cast<const MBBPriorityInfo*>(R); 2040cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Deeper loops first 2041cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->Depth != RHS->Depth) 2042cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->Depth > RHS->Depth ? -1 : 1; 2043cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2044cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Try to unsplit critical edges next. 2045cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (LHS->IsSplit != RHS->IsSplit) 2046cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->IsSplit ? -1 : 1; 2047cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2048cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // Prefer blocks that are more connected in the CFG. This takes care of 2049cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // the most difficult copies first while intervals are short. 2050cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cl = LHS->MBB->pred_size() + LHS->MBB->succ_size(); 2051cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick unsigned cr = RHS->MBB->pred_size() + RHS->MBB->succ_size(); 2052cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick if (cl != cr) 2053cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return cl > cr ? -1 : 1; 2054cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick 2055cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick // As a last resort, sort by block number. 2056cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick return LHS->MBB->getNumber() < RHS->MBB->getNumber() ? -1 : 1; 2057655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2058655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2059265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick/// \returns true if the given copy uses or defines a local live range. 2060265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickstatic bool isLocalCopy(MachineInstr *Copy, const LiveIntervals *LIS) { 2061265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!Copy->isCopy()) 2062265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2063265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2064265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned SrcReg = Copy->getOperand(1).getReg(); 2065265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned DstReg = Copy->getOperand(0).getReg(); 2066265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (TargetRegisterInfo::isPhysicalRegister(SrcReg) 2067265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || TargetRegisterInfo::isPhysicalRegister(DstReg)) 2068265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return false; 2069265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2070265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick return LIS->intervalIsInOneMBB(LIS->getInterval(SrcReg)) 2071265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick || LIS->intervalIsInOneMBB(LIS->getInterval(DstReg)); 2072265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2073265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 2074b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Try joining WorkList copies starting from index From. 2075b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen// Null out any successful joins. 2076265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickbool RegisterCoalescer:: 2077265058d9239e6867d06dc8aa40db5f33390abd17Andrew TrickcopyCoalesceWorkList(MutableArrayRef<MachineInstr*> CurrList) { 2078b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Progress = false; 2079265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = CurrList.size(); i != e; ++i) { 2080265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!CurrList[i]) 2081b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen continue; 2082bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // Skip instruction pointers that have already been erased, for example by 2083bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen // dead code elimination. 2084265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (ErasedInstrs.erase(CurrList[i])) { 2085265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList[i] = 0; 2086bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen continue; 2087bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen } 2088b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen bool Again = false; 2089265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick bool Success = joinCopy(CurrList[i], Again); 2090b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen Progress |= Success; 2091b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen if (Success || !Again) 2092265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList[i] = 0; 2093b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen } 2094b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen return Progress; 2095b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen} 2096b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen 20979790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid 2098b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund OlesenRegisterCoalescer::copyCoalesceInMBB(MachineBasicBlock *MBB) { 2099655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << MBB->getName() << ":\n"); 2100655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2101846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // Collect all copy-like instructions in MBB. Don't start coalescing anything 2102846b183a9ed2999d3f35c7c6b54a5796c0660b9eJakob Stoklund Olesen // yet, it might invalidate the iterator. 2103b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen const unsigned PrevSize = WorkList.size(); 2104ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (JoinGlobalCopies) { 2105265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Coalesce copies bottom-up to coalesce local defs before local uses. They 2106265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // are not inherently easier to resolve, but slightly preferable until we 2107265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // have local live range splitting. In particular this is required by 2108265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // cmp+jmp macro fusion. 2109265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (MachineBasicBlock::reverse_iterator 2110265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MII = MBB->rbegin(), E = MBB->rend(); MII != E; ++MII) { 2111265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (!MII->isCopyLike()) 2112265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick continue; 2113265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (isLocalCopy(&(*MII), LIS)) 2114265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.push_back(&(*MII)); 2115265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else 2116265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(&(*MII)); 2117265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2118265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2119265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick else { 2120265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end(); 2121265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MII != E; ++MII) 2122265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (MII->isCopyLike()) 2123265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(MII); 2124265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2125b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // Try coalescing the collected copies immediately, and remove the nulls. 2126b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // This prevents the WorkList from getting too large since most copies are 2127b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen // joinable on the first attempt. 2128265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick MutableArrayRef<MachineInstr*> 2129265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick CurrList(WorkList.begin() + PrevSize, WorkList.end()); 2130265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (copyCoalesceWorkList(CurrList)) 2131b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.erase(std::remove(WorkList.begin() + PrevSize, WorkList.end(), 2132b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen (MachineInstr*)0), WorkList.end()); 2133655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2134655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2135265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trickvoid RegisterCoalescer::coalesceLocals() { 2136265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick copyCoalesceWorkList(LocalWorkList); 2137265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned j = 0, je = LocalWorkList.size(); j != je; ++j) { 2138265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick if (LocalWorkList[j]) 2139265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick WorkList.push_back(LocalWorkList[j]); 2140265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2141265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick LocalWorkList.clear(); 2142265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick} 2143265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick 21449790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesenvoid RegisterCoalescer::joinAllIntervals() { 2145655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** JOINING INTERVALS ***********\n"); 2146265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick assert(WorkList.empty() && LocalWorkList.empty() && "Old data still around."); 2147655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2148f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick std::vector<MBBPriorityInfo> MBBs; 21498762a6bc2b83dfc11e784772311ad0b8fa5211e2Jakub Staszak MBBs.reserve(MF->size()); 2150f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick for (MachineFunction::iterator I = MF->begin(), E = MF->end();I != E;++I){ 2151f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MachineBasicBlock *MBB = I; 2152f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick MBBs.push_back(MBBPriorityInfo(MBB, Loops->getLoopDepth(MBB), 2153cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick JoinSplitEdges && isSplitEdge(MBB))); 2154655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola } 2155cdf493dd0b74fa8a784bd1ea690351e0f4b608adAndrew Trick array_pod_sort(MBBs.begin(), MBBs.end(), compareMBBPriority); 2156f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick 2157f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick // Coalesce intervals in MBB priority order. 2158265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick unsigned CurrDepth = UINT_MAX; 2159265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick for (unsigned i = 0, e = MBBs.size(); i != e; ++i) { 2160265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick // Try coalescing the collected local copies for deeper loops. 2161c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick if (JoinGlobalCopies && MBBs[i].Depth < CurrDepth) { 2162265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2163c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick CurrDepth = MBBs[i].Depth; 2164c6d6aeb95feca2efc6ee652555dbb29f0a3d41c8Andrew Trick } 2165f546ac5f9bdedc7d1ae49238c65a93201d0e4f05Andrew Trick copyCoalesceInMBB(MBBs[i].MBB); 2166265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick } 2167265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick coalesceLocals(); 2168655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2169655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Joining intervals can allow other intervals to be joined. Iteratively join 2170655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // until we make no progress. 2171265058d9239e6867d06dc8aa40db5f33390abd17Andrew Trick while (copyCoalesceWorkList(WorkList)) 2172b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen /* empty */ ; 2173655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2174655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 21755b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::releaseMemory() { 2176bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen ErasedInstrs.clear(); 2177b3776d33cfaba3fc48acccf166d2bd4871ee51c7Jakob Stoklund Olesen WorkList.clear(); 2178bd6f44a3a2a1404721bcbb67edf92b8480a3e655Jakob Stoklund Olesen DeadDefs.clear(); 217903c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen InflateRegs.clear(); 2180655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2181655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 21825b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolabool RegisterCoalescer::runOnMachineFunction(MachineFunction &fn) { 2183c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF = &fn; 2184c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MRI = &fn.getRegInfo(); 2185c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TM = &fn.getTarget(); 2186c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TRI = TM->getRegisterInfo(); 2187c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen TII = TM->getInstrInfo(); 2188c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS = &getAnalysis<LiveIntervals>(); 2189655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola AA = &getAnalysis<AliasAnalysis>(); 2190c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen Loops = &getAnalysis<MachineLoopInfo>(); 2191655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2192ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick const TargetSubtargetInfo &ST = TM->getSubtarget<TargetSubtargetInfo>(); 2193ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick if (EnableGlobalCopies == cl::BOU_UNSET) 2194ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick JoinGlobalCopies = ST.enableMachineScheduler(); 2195ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick else 2196ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick JoinGlobalCopies = (EnableGlobalCopies == cl::BOU_TRUE); 2197ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 21983106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // The MachineScheduler does not currently require JoinSplitEdges. This will 21993106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // either be enabled unconditionally or replaced by a more general live range 22003106aa125eb2756083e950362b6769b87cb3430aAndrew Trick // splitting optimization. 22013106aa125eb2756083e950362b6769b87cb3430aAndrew Trick JoinSplitEdges = EnableJoinSplits; 2202ad1cc1d1bfc0accd3f1af5c02ac367ff46a4bfdfAndrew Trick 2203655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dbgs() << "********** SIMPLE REGISTER COALESCING **********\n" 2204986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie << "********** Function: " << MF->getName() << '\n'); 2205655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2206655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2207c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "Before register coalescing"); 2208655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2209655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola RegClassInfo.runOnMachineFunction(fn); 2210655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2211655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola // Join (coalesce) intervals if requested. 2212b77ec7d26405125fa5685370af5f17fcc9edbecdJakob Stoklund Olesen if (EnableJoining) 22139790266eeae86b2d763d0760f239ab90bc1de84aJakob Stoklund Olesen joinAllIntervals(); 2214655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 22154a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // After deleting a lot of copies, register classes may be less constrained. 221603c8383324da4fe42fae4e5685072a782935644dJakob Stoklund Olesen // Removing sub-register operands may allow GR32_ABCD -> GR32 and DPR_VFP2 -> 22174a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen // DPR inflation. 22184a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen array_pod_sort(InflateRegs.begin(), InflateRegs.end()); 22194a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.erase(std::unique(InflateRegs.begin(), InflateRegs.end()), 22204a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen InflateRegs.end()); 22214a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << "Trying to inflate " << InflateRegs.size() << " regs.\n"); 22224a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen for (unsigned i = 0, e = InflateRegs.size(); i != e; ++i) { 22234a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen unsigned Reg = InflateRegs[i]; 22244a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->reg_nodbg_empty(Reg)) 22254a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen continue; 22264a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen if (MRI->recomputeRegClass(Reg, *TM)) { 22274a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen DEBUG(dbgs() << PrintReg(Reg) << " inflated to " 22284a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen << MRI->getRegClass(Reg)->getName() << '\n'); 22294a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen ++NumInflated; 22304a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 22314a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen } 22324a74b3b933e2944ff313dc5d24da6f9e8ec4c1c4Jakob Stoklund Olesen 2233655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola DEBUG(dump()); 2234655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola if (VerifyCoalescing) 2235c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen MF->verify(this, "After register coalescing"); 2236655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola return true; 2237655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2238655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola 2239655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola/// print - Implement the dump method. 22405b220213bfe9c37c2bb41a7ae0804e06a14f1007Rafael Espindolavoid RegisterCoalescer::print(raw_ostream &O, const Module* m) const { 2241c19e6dd64fe4fa825c8d79e1d097e301c66eaf72Jakob Stoklund Olesen LIS->print(O, m); 2242655739de7b09dcfecd9f3e5f1734e53ec90a19f3Rafael Espindola} 2243