1 //===--- RDFCopy.cpp ------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // RDF-based copy propagation. 11 12 #include "RDFCopy.h" 13 #include "RDFGraph.h" 14 #include "llvm/CodeGen/MachineBasicBlock.h" 15 #include "llvm/CodeGen/MachineDominators.h" 16 #include "llvm/CodeGen/MachineInstr.h" 17 #include "llvm/CodeGen/MachineRegisterInfo.h" 18 #include "llvm/Support/CommandLine.h" 19 #include "llvm/Target/TargetInstrInfo.h" 20 #include "llvm/Target/TargetRegisterInfo.h" 21 using namespace llvm; 22 using namespace rdf; 23 24 #ifndef NDEBUG 25 static cl::opt<unsigned> CpLimit("rdf-cp-limit", cl::init(0), cl::Hidden); 26 static unsigned CpCount = 0; 27 #endif 28 29 bool CopyPropagation::interpretAsCopy(const MachineInstr *MI, EqualityMap &EM) { 30 unsigned Opc = MI->getOpcode(); 31 switch (Opc) { 32 case TargetOpcode::COPY: { 33 const MachineOperand &Dst = MI->getOperand(0); 34 const MachineOperand &Src = MI->getOperand(1); 35 RegisterRef DstR = { Dst.getReg(), Dst.getSubReg() }; 36 RegisterRef SrcR = { Src.getReg(), Src.getSubReg() }; 37 if (TargetRegisterInfo::isVirtualRegister(DstR.Reg)) { 38 if (!TargetRegisterInfo::isVirtualRegister(SrcR.Reg)) 39 return false; 40 MachineRegisterInfo &MRI = DFG.getMF().getRegInfo(); 41 if (MRI.getRegClass(DstR.Reg) != MRI.getRegClass(SrcR.Reg)) 42 return false; 43 } else if (TargetRegisterInfo::isPhysicalRegister(DstR.Reg)) { 44 if (!TargetRegisterInfo::isPhysicalRegister(SrcR.Reg)) 45 return false; 46 const TargetRegisterInfo &TRI = DFG.getTRI(); 47 if (TRI.getMinimalPhysRegClass(DstR.Reg) != 48 TRI.getMinimalPhysRegClass(SrcR.Reg)) 49 return false; 50 } else { 51 // Copy between some unknown objects. 52 return false; 53 } 54 EM.insert(std::make_pair(DstR, SrcR)); 55 return true; 56 } 57 case TargetOpcode::REG_SEQUENCE: { 58 const MachineOperand &Dst = MI->getOperand(0); 59 RegisterRef DefR = { Dst.getReg(), Dst.getSubReg() }; 60 SmallVector<TargetInstrInfo::RegSubRegPairAndIdx,2> Inputs; 61 const TargetInstrInfo &TII = DFG.getTII(); 62 if (!TII.getRegSequenceInputs(*MI, 0, Inputs)) 63 return false; 64 for (auto I : Inputs) { 65 unsigned S = DFG.getTRI().composeSubRegIndices(DefR.Sub, I.SubIdx); 66 RegisterRef DR = { DefR.Reg, S }; 67 RegisterRef SR = { I.Reg, I.SubReg }; 68 EM.insert(std::make_pair(DR, SR)); 69 } 70 return true; 71 } 72 } 73 return false; 74 } 75 76 77 void CopyPropagation::recordCopy(NodeAddr<StmtNode*> SA, EqualityMap &EM) { 78 CopyMap.insert(std::make_pair(SA.Id, EM)); 79 Copies.push_back(SA.Id); 80 81 for (auto I : EM) { 82 auto FS = DefM.find(I.second); 83 if (FS == DefM.end() || FS->second.empty()) 84 continue; // Undefined source 85 RDefMap[I.second][SA.Id] = FS->second.top()->Id; 86 // Insert DstR into the map. 87 RDefMap[I.first]; 88 } 89 } 90 91 92 void CopyPropagation::updateMap(NodeAddr<InstrNode*> IA) { 93 RegisterSet RRs; 94 for (NodeAddr<RefNode*> RA : IA.Addr->members(DFG)) 95 RRs.insert(RA.Addr->getRegRef()); 96 bool Common = false; 97 for (auto &R : RDefMap) { 98 if (!RRs.count(R.first)) 99 continue; 100 Common = true; 101 break; 102 } 103 if (!Common) 104 return; 105 106 for (auto &R : RDefMap) { 107 if (!RRs.count(R.first)) 108 continue; 109 auto F = DefM.find(R.first); 110 if (F == DefM.end() || F->second.empty()) 111 continue; 112 R.second[IA.Id] = F->second.top()->Id; 113 } 114 } 115 116 117 bool CopyPropagation::scanBlock(MachineBasicBlock *B) { 118 bool Changed = false; 119 auto BA = DFG.getFunc().Addr->findBlock(B, DFG); 120 DFG.markBlock(BA.Id, DefM); 121 122 for (NodeAddr<InstrNode*> IA : BA.Addr->members(DFG)) { 123 if (DFG.IsCode<NodeAttrs::Stmt>(IA)) { 124 NodeAddr<StmtNode*> SA = IA; 125 EqualityMap EM; 126 if (interpretAsCopy(SA.Addr->getCode(), EM)) 127 recordCopy(SA, EM); 128 } 129 130 updateMap(IA); 131 DFG.pushDefs(IA, DefM); 132 } 133 134 MachineDomTreeNode *N = MDT.getNode(B); 135 for (auto I : *N) 136 Changed |= scanBlock(I->getBlock()); 137 138 DFG.releaseBlock(BA.Id, DefM); 139 return Changed; 140 } 141 142 143 bool CopyPropagation::run() { 144 scanBlock(&DFG.getMF().front()); 145 146 if (trace()) { 147 dbgs() << "Copies:\n"; 148 for (auto I : Copies) { 149 dbgs() << "Instr: " << *DFG.addr<StmtNode*>(I).Addr->getCode(); 150 dbgs() << " eq: {"; 151 for (auto J : CopyMap[I]) 152 dbgs() << ' ' << Print<RegisterRef>(J.first, DFG) << '=' 153 << Print<RegisterRef>(J.second, DFG); 154 dbgs() << " }\n"; 155 } 156 dbgs() << "\nRDef map:\n"; 157 for (auto R : RDefMap) { 158 dbgs() << Print<RegisterRef>(R.first, DFG) << " -> {"; 159 for (auto &M : R.second) 160 dbgs() << ' ' << Print<NodeId>(M.first, DFG) << ':' 161 << Print<NodeId>(M.second, DFG); 162 dbgs() << " }\n"; 163 } 164 } 165 166 bool Changed = false; 167 #ifndef NDEBUG 168 bool HasLimit = CpLimit.getNumOccurrences() > 0; 169 #endif 170 171 for (auto C : Copies) { 172 #ifndef NDEBUG 173 if (HasLimit && CpCount >= CpLimit) 174 break; 175 #endif 176 auto SA = DFG.addr<InstrNode*>(C); 177 auto FS = CopyMap.find(SA.Id); 178 if (FS == CopyMap.end()) 179 continue; 180 181 EqualityMap &EM = FS->second; 182 for (NodeAddr<DefNode*> DA : SA.Addr->members_if(DFG.IsDef, DFG)) { 183 RegisterRef DR = DA.Addr->getRegRef(); 184 auto FR = EM.find(DR); 185 if (FR == EM.end()) 186 continue; 187 RegisterRef SR = FR->second; 188 if (DR == SR) 189 continue; 190 191 auto &RDefSR = RDefMap[SR]; 192 NodeId RDefSR_SA = RDefSR[SA.Id]; 193 194 for (NodeId N = DA.Addr->getReachedUse(), NextN; N; N = NextN) { 195 auto UA = DFG.addr<UseNode*>(N); 196 NextN = UA.Addr->getSibling(); 197 uint16_t F = UA.Addr->getFlags(); 198 if ((F & NodeAttrs::PhiRef) || (F & NodeAttrs::Fixed)) 199 continue; 200 if (UA.Addr->getRegRef() != DR) 201 continue; 202 203 NodeAddr<InstrNode*> IA = UA.Addr->getOwner(DFG); 204 assert(DFG.IsCode<NodeAttrs::Stmt>(IA)); 205 if (RDefSR[IA.Id] != RDefSR_SA) 206 continue; 207 208 MachineOperand &Op = UA.Addr->getOp(); 209 if (Op.isTied()) 210 continue; 211 if (trace()) { 212 dbgs() << "Can replace " << Print<RegisterRef>(DR, DFG) 213 << " with " << Print<RegisterRef>(SR, DFG) << " in " 214 << *NodeAddr<StmtNode*>(IA).Addr->getCode(); 215 } 216 217 Op.setReg(SR.Reg); 218 Op.setSubReg(SR.Sub); 219 DFG.unlinkUse(UA, false); 220 if (RDefSR_SA != 0) { 221 UA.Addr->linkToDef(UA.Id, DFG.addr<DefNode*>(RDefSR_SA)); 222 } else { 223 UA.Addr->setReachingDef(0); 224 UA.Addr->setSibling(0); 225 } 226 227 Changed = true; 228 #ifndef NDEBUG 229 if (HasLimit && CpCount >= CpLimit) 230 break; 231 CpCount++; 232 #endif 233 234 auto FC = CopyMap.find(IA.Id); 235 if (FC != CopyMap.end()) { 236 // Update the EM map in the copy's entry. 237 auto &M = FC->second; 238 for (auto &J : M) { 239 if (J.second != DR) 240 continue; 241 J.second = SR; 242 break; 243 } 244 } 245 } // for (N in reached-uses) 246 } // for (DA in defs) 247 } // for (C in Copies) 248 249 return Changed; 250 } 251 252