Lines Matching defs:?I
188 BlockInfo BI;
189 BI.MBB = MFI;
191 tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
198 ThroughBlocks.set(BI.MBB->getNumber());
205 BI.FirstInstr = *UseI;
206 assert(BI.FirstInstr >= Start);
209 BI.LastInstr = UseI[-1];
210 assert(BI.LastInstr < Stop);
213 BI.LiveIn = LVI->start <= Start;
216 if (!BI.LiveIn) {
218 assert(LVI->start == BI.FirstInstr && "First instr should be a def");
219 BI.FirstDef = BI.FirstInstr;
223 BI.LiveOut = true;
227 BI.LiveOut = false;
228 BI.LastInstr = LastStop;
238 BI.LiveOut = false;
239 UseBlocks.push_back(BI);
242 // Set up BI for the live-out part.
243 BI.LiveIn = false;
244 BI.LiveOut = true;
245 BI.FirstInstr = BI.FirstDef = LVI->start;
250 if (!BI.FirstDef)
251 BI.FirstDef = LVI->start;
254 UseBlocks.push_back(BI);
378 LiveInterval *LI = Edit->get(RegIdx);
381 VNInfo *VNI = LI->getNextValue(Idx, LIS.getVNInfoAllocator());
396 LI->addRange(LiveRange(Def, Def.getDeadSlot(), OldVNI));
403 LI->addRange(LiveRange(Def, Def.getDeadSlot(), VNI));
435 LiveInterval *LI = Edit->get(RegIdx);
444 Def = Edit->rematerializeAt(MBB, I, LI->reg, RM, TRI, Late);
448 CopyMI = BuildMI(MBB, I, DebugLoc(), TII.get(TargetOpcode::COPY), LI->reg)
488 MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
489 assert(MI && "enterIntvBefore called with invalid index");
491 VNInfo *VNI = defFromParent(OpenIdx, ParentVNI, Idx, *MI->getParent(), MI);
505 MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
506 assert(MI && "enterIntvAfter called with invalid index");
508 VNInfo *VNI = defFromParent(OpenIdx, ParentVNI, Idx, *MI->getParent(),
509 llvm::next(MachineBasicBlock::iterator(MI)));
555 MachineInstr *MI = LIS.getInstructionFromIndex(Boundary);
556 assert(MI && "No instruction at index");
559 // before MI. This is only possible if that instruction doesn't redefine the
563 MI->readsVirtualRegister(Edit->getReg())) {
565 defFromParent(0, ParentVNI, Idx, *MI->getParent(), MI);
569 VNInfo *VNI = defFromParent(0, ParentVNI, Boundary, *MI->getParent(),
570 llvm::next(MachineBasicBlock::iterator(MI)));
587 MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
588 assert(MI && "No instruction at index");
589 VNInfo *VNI = defFromParent(0, ParentVNI, Idx, *MI->getParent(), MI);
632 LiveInterval *LI = Edit->get(0);
640 MachineInstr *MI = LIS.getInstructionFromIndex(Def);
641 assert(MI && "No instruction for back-copy");
643 MachineBasicBlock *MBB = MI->getParent();
644 MachineBasicBlock::iterator MBBI(MI);
649 DEBUG(dbgs() << "Removing " << Def << '\t' << *MI);
650 LI->removeValNo(VNI);
651 LIS.RemoveMachineInstrFromMaps(MI);
652 MI->eraseFromParent();
660 // If MI doesn't kill the assigned register, just leave it.
731 LiveInterval *LI = Edit->get(0);
741 for (LiveInterval::vni_iterator VI = LI->vni_begin(), VE = LI->vni_end();
742 VI != VE; ++VI) {
743 VNInfo *VNI = *VI;
816 for (LiveInterval::vni_iterator VI = LI->vni_begin(), VE = LI->vni_end();
817 VI != VE; ++VI) {
818 VNInfo *VNI = *VI;
862 LiveInterval *LI = Edit->get(RegIdx);
868 LI->addRange(LiveRange(Start, End, VNI));
892 VNInfo *VNI = LI->extendInBlock(BlockStart, std::min(BlockEnd, End));
912 VNInfo *VNI = LI->extendInBlock(BlockStart, std::min(BlockEnd, End));
920 LRC.addLiveInBlock(LI, MDT[MBB], End);
923 LRC.addLiveInBlock(LI, MDT[MBB]);
950 LiveInterval *LI = Edit->get(RegIdx);
953 for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
954 PE = MBB->pred_end(); PI != PE; ++PI) {
955 SlotIndex End = LIS.getMBBEndIdx(*PI);
962 LRC.extend(LI, End);
970 for (MachineRegisterInfo::reg_iterator RI = MRI.reg_begin(Edit->getReg()),
971 RE = MRI.reg_end(); RI != RE;) {
972 MachineOperand &MO = RI.getOperand();
973 MachineInstr *MI = MO.getParent();
974 ++RI;
976 if (MI->isDebugValue()) {
977 DEBUG(dbgs() << "Zapping " << *MI);
985 SlotIndex Idx = LIS.getInstructionIndex(MI);
991 LiveInterval *LI = Edit->get(RegIdx);
992 MO.setReg(LI->reg);
993 DEBUG(dbgs() << " rewr BB#" << MI->getParent()->getNumber() << '\t'
994 << Idx << ':' << RegIdx << '\t' << *MI);
1012 getLRCalc(RegIdx).extend(LI, Idx.getNextSlot());
1019 LiveInterval *LI = *I;
1020 for (LiveInterval::const_iterator LII = LI->begin(), LIE = LI->end();
1025 MachineInstr *MI = LIS.getInstructionFromIndex(LII->valno->def);
1026 assert(MI && "Missing instruction for dead def");
1027 MI->addRegisterDead(LI->reg, &TRI);
1029 if (!MI->allDefsAreDead())
1032 DEBUG(dbgs() << "All defs dead: " << *MI);
1033 Dead.push_back(MI);
1132 bool SplitAnalysis::shouldSplitSingleBlock(const BlockInfo &BI,
1135 if (!BI.isOneInstr())
1141 if (BI.LiveIn && BI.LiveOut)
1144 if (LIS.getInstructionFromIndex(BI.FirstInstr)->isCopyLike())
1147 return isOriginalEndpoint(BI.FirstInstr);
1150 void SplitEditor::splitSingleBlock(const SplitAnalysis::BlockInfo &BI) {
1152 SlotIndex LastSplitPoint = SA.getLastSplitPoint(BI.MBB->getNumber());
1153 SlotIndex SegStart = enterIntvBefore(std::min(BI.FirstInstr,
1155 if (!BI.LiveOut || BI.LastInstr < LastSplitPoint) {
1156 useIntv(SegStart, leaveIntvAfter(BI.LastInstr));
1161 overlapIntv(SegStop, BI.LastInstr);
1281 void SplitEditor::splitRegInBlock(const SplitAnalysis::BlockInfo &BI,
1284 tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
1286 DEBUG(dbgs() << "BB#" << BI.MBB->getNumber() << " [" << Start << ';' << Stop
1287 << "), uses " << BI.FirstInstr << '-' << BI.LastInstr
1289 << (BI.LiveOut ? ", stack-out" : ", killed in block"));
1292 assert(BI.LiveIn && "Must be live-in");
1295 if (!BI.LiveOut && (!LeaveBefore || LeaveBefore >= BI.LastInstr)) {
1303 useIntv(Start, BI.LastInstr);
1307 SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
1309 if (!LeaveBefore || LeaveBefore > BI.LastInstr.getBoundaryIndex()) {
1320 if (BI.LastInstr < LSP) {
1323 SlotIndex Idx = leaveIntvAfter(BI.LastInstr);
1330 overlapIntv(Idx, BI.LastInstr);
1344 if (!BI.LiveOut || BI.LastInstr < LSP) {
1350 SlotIndex To = leaveIntvAfter(BI.LastInstr);
1365 overlapIntv(To, BI.LastInstr);
1373 void SplitEditor::splitRegOutBlock(const SplitAnalysis::BlockInfo &BI,
1376 tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
1378 DEBUG(dbgs() << "BB#" << BI.MBB->getNumber() << " [" << Start << ';' << Stop
1379 << "), uses " << BI.FirstInstr << '-' << BI.LastInstr
1381 << (BI.LiveIn ? ", stack-in" : ", defined in block"));
1383 SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
1386 assert(BI.LiveOut && "Must be live-out");
1389 if (!BI.LiveIn && (!EnterAfter || EnterAfter <= BI.FirstInstr)) {
1397 useIntv(BI.FirstInstr, Stop);
1401 if (!EnterAfter || EnterAfter < BI.FirstInstr.getBaseIndex()) {
1409 SlotIndex Idx = enterIntvBefore(std::min(LSP, BI.FirstInstr));
1430 SlotIndex From = enterIntvBefore(std::min(Idx, BI.FirstInstr));