lib/CodeGen/TwoAddressInstructionPass.cpp

83   // DistanceMap - Keep track the distance of a MI from the start of the
100   bool sink3AddrInstruction(MachineInstr *MI, unsigned Reg,
106                              MachineInstr *MI, unsigned Dist);
117   bool isDefTooClose(unsigned Reg, unsigned Dist, MachineInstr *MI);
133   void processCopy(MachineInstr *MI);
137   bool collectTiedOperands(MachineInstr *MI, TiedOperandMap&);
138   void processTiedPairs(MachineInstr *MI, TiedPairList&, unsigned &Dist);
172 static bool isPlainlyKilled(MachineInstr *MI, unsigned Reg, LiveIntervals *LIS);
179 sink3AddrInstruction(MachineInstr *MI, unsigned SavedReg,
187   if (!MI->isSafeToMove(TII, AA, SeenStore))
193   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
194     const MachineOperand &MO = MI->getOperand(i);
243   if (!KillMI || KillMI->getParent() != MBB || KillMI == MI ||
279           // marker if we can sink MI past it.
292     KillMO = MI->findRegisterUseOperand(SavedReg, false, TRI);
296       LV->replaceKillInstruction(SavedReg, KillMI, MI);
300   MBB->remove(MI);
301   MBB->insert(KillPos, MI);
304     LIS->handleMove(MI);
321     MachineInstr *MI = MO.getParent();
322     if (MI->getParent() != MBB || MI->isDebugValue())
324     DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
336 /// isCopyToReg - Return true if the specified MI is a copy instruction or
339 static bool isCopyToReg(MachineInstr &MI, const TargetInstrInfo *TII,
344   if (MI.isCopy()) {
345     DstReg = MI.getOperand(0).getReg();
346     SrcReg = MI.getOperand(1).getReg();
347   } else if (MI.isInsertSubreg() || MI.isSubregToReg()) {
348     DstReg = MI.getOperand(0).getReg();
349     SrcReg = MI.getOperand(2).getReg();
360 static bool isPlainlyKilled(MachineInstr *MI, unsigned Reg,
363       !LIS->isNotInMIMap(MI)) {
376     SlotIndex useIdx = LIS->getInstructionIndex(MI);
382   return MI->killsRegister(Reg);
402 static bool isKilled(MachineInstr &MI, unsigned Reg,
407   MachineInstr *DefMI = &MI;
433 /// isTwoAddrUse - Return true if the specified MI uses the specified register
435 static bool isTwoAddrUse(MachineInstr &MI, unsigned Reg, unsigned &DstReg) {
436   for (unsigned i = 0, NumOps = MI.getNumOperands(); i != NumOps; ++i) {
437     const MachineOperand &MO = MI.getOperand(i);
441     if (MI.isRegTiedToDefOperand(i, &ti)) {
442       DstReg = MI.getOperand(ti).getReg();
509                       MachineInstr *MI, unsigned Dist) {
531   if (!isPlainlyKilled(MI, regC, LIS))
577   MachineInstr *MI = mi;
578   DEBUG(dbgs() << "2addr: COMMUTING  : " << *MI);
579   MachineInstr *NewMI = TII->commuteInstruction(MI);
587   assert(NewMI == MI &&
594     unsigned RegA = MI->getOperand(0).getReg();
718 void TwoAddressInstructionPass::processCopy(MachineInstr *MI) {
719   if (Processed.count(MI))
724   if (!isCopyToReg(*MI, TII, SrcReg, DstReg, IsSrcPhys, IsDstPhys))
738   Processed.insert(MI);
754   MachineInstr *MI = &*mi;
755   DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
776   if (!KillMI || MI == KillMI || KillMI->isCopy() || KillMI->isCopyLike())
790   if (!MI->isSafeToMove(TII, AA, SeenStore))
793   if (TII->getInstrLatency(InstrItins, MI) > 1)
800   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
801     const MachineOperand &MO = MI->getOperand(i);
812                            (LIS && isPlainlyKilled(MI, MOReg, LIS))))
817   // Move the copies connected to MI down as well.
818   MachineBasicBlock::iterator Begin = MI;
894     End = llvm::next(MachineBasicBlock::iterator(MI));
897   // Copies following MI may have been moved as well.
903     LIS->handleMove(MI);
906     LV->addVirtualRegisterKilled(Reg, MI);
916                                               MachineInstr *MI) {
922     if (DefMI == MI)
923       return true; // MI is defining something KillMI uses
926       return true;  // Below MI
948   MachineInstr *MI = &*mi;
949   DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
970   if (!KillMI || MI == KillMI || KillMI->isCopy() || KillMI->isCopyLike())
994       if (isDefTooClose(MOReg, DI->second, MI))
1040         if (OtherMI != MI && MOReg == Reg &&
1061   // Move the old kill above MI, don't forget to move debug info as well.
1079     LV->addVirtualRegisterKilled(Reg, MI);
1101   MachineInstr &MI = *mi;
1102   unsigned regA = MI.getOperand(DstIdx).getReg();
1103   unsigned regB = MI.getOperand(SrcIdx).getReg();
1107   bool regBKilled = isKilled(MI, regB, MRI, TII, LIS, true);
1118   if (MI.isCommutable() && MI.getNumOperands() >= 3 &&
1119       TII->findCommutedOpIndices(&MI, SrcOp1, SrcOp2)) {
1126       regC = MI.getOperand(regCIdx).getReg();
1127       if (!regBKilled && isKilled(MI, regC, MRI, TII, LIS, false))
1131       else if (isProfitableToCommute(regA, regB, regC, &MI, Dist)) {
1150   // re-schedule this MI below it.
1156   if (MI.isConvertibleTo3Addr()) {
1169   // re-schedule it before this MI if it's legal.
1183   if (MI.mayLoad() && !regBKilled) {
1187       TII->getOpcodeAfterMemoryUnfold(MI.getOpcode(),
1195         DEBUG(dbgs() << "2addr:   UNFOLDING: " << MI);
1201         if (!TII->unfoldMemoryOperand(*MF, &MI, Reg,
1233             for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1234               MachineOperand &MO = MI.getOperand(i);
1240                       LV->replaceKillInstruction(MO.getReg(), &MI, NewMIs[0]);
1244                       LV->replaceKillInstruction(MO.getReg(), &MI, NewMIs[1]);
1247                 } else if (LV->removeVirtualRegisterDead(MO.getReg(), &MI)) {
1263             for (MachineInstr::const_mop_iterator MOI = MI.operands_begin(),
1264                  MOE = MI.operands_end(); MOI != MOE; ++MOI) {
1270           MI.eraseFromParent();
1295 // Collect tied operands of MI that need to be handled.
1299 collectTiedOperands(MachineInstr *MI, TiedOperandMap &TiedOperands) {
1300   const MCInstrDesc &MCID = MI->getDesc();
1302   unsigned NumOps = MI->getNumOperands();
1306     if (!MI->isRegTiedToDefOperand(SrcIdx, &DstIdx))
1309     MachineOperand &SrcMO = MI->getOperand(SrcIdx);
1310     MachineOperand &DstMO = MI->getOperand(DstIdx);
1327       DEBUG(dbgs() << "\t\trewrite undef:\t" << *MI);
1335 // Process a list of tied MI operands that all use the same source register.
1338 TwoAddressInstructionPass::processTiedPairs(MachineInstr *MI,
1343     const MachineOperand &DstMO = MI->getOperand(TiedPairs[tpi].second);
1356     const MachineOperand &DstMO = MI->getOperand(DstIdx);
1361     RegB = MI->getOperand(SrcIdx).getReg();
1379     for (unsigned i = 0; i != MI->getNumOperands(); ++i)
1381              !MI->getOperand(i).isReg() ||
1382              MI->getOperand(i).getReg() != RegA);
1386     BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
1390     MachineBasicBlock::iterator PrevMI = MI;
1393     DistanceMap[MI] = ++Dist;
1402           LIS->getInstructionIndex(MI).getRegSlot(IsEarlyClobber);
1409     MachineOperand &MO = MI->getOperand(SrcIdx);
1432       for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
1433         MachineOperand &MO = MI->getOperand(i);
1445     if (RemovedKillFlag && LV && LV->getVarInfo(RegB).removeKill(MI)) {
1446       MachineBasicBlock::iterator PrevMI = MI;
1454       SlotIndex MIIdx = LIS->getInstructionIndex(MI);
1468     for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
1469       MachineOperand &MO = MI->getOperand(i);
1607   MachineInstr *MI = MBBI;
1608   unsigned DstReg = MI->getOperand(0).getReg();
1609   if (MI->getOperand(0).getSubReg() ||
1611       !(MI->getNumOperands() & 1)) {
1612     DEBUG(dbgs() << "Illegal REG_SEQUENCE instruction:" << *MI);
1618     OrigRegs.push_back(MI->getOperand(0).getReg());
1619     for (unsigned i = 1, e = MI->getNumOperands(); i < e; i += 2)
1620       OrigRegs.push_back(MI->getOperand(i).getReg());
1624   for (unsigned i = 1, e = MI->getNumOperands(); i < e; i += 2) {
1625     MachineOperand &UseMO = MI->getOperand(i);
1627     unsigned SubIdx = MI->getOperand(i+1).getImm();
1637         if (MI->getOperand(j).getReg() == SrcReg) {
1638           MI->getOperand(j).setIsKill();
1645     MachineInstr *CopyMI = BuildMI(*MI->getParent(), MI, MI->getDebugLoc(),
1661       LV->replaceKillInstruction(SrcReg, MI, CopyMI);
1667       llvm::next(MachineBasicBlock::iterator(MI));
1670     DEBUG(dbgs() << "Turned: " << *MI << " into an IMPLICIT_DEF");
1671     MI->setDesc(TII->get(TargetOpcode::IMPLICIT_DEF));
1672     for (int j = MI->getNumOperands() - 1, ee = 0; j > ee; --j)
1673       MI->RemoveOperand(j);
1675     DEBUG(dbgs() << "Eliminated: " << *MI);
1676     MI->eraseFromParent();