Fix regalloc-verifier error for r265547

[wmi]

Summary

This is to fix the problem here:
http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20160404/345537.html

The error is caused by that I didn't create live interval for the dummy register used in rematerialization. regalloc-verifier requires any vreg has a live interval, and because it is a dummy register without live range segment, verifier requires it to be marked as Dead.

However, rematerialization may copy the dead flag to the instruction cloned, which is incorrect. So I need to set the Dead flag to false before doing rematerialization and reset it to true after that.

[qcolombet]

lib/CodeGen/LiveRangeEdit.cpp

166

This code feels so wrong.
I am okay if we would have to reset isDead to false for DestReg, since the remat may just clone the input, but we shouldn’t have to do a gymnastic with OrigMI.

[wmi]

lib/CodeGen/LiveRangeEdit.cpp

166

Yes, you are right. It is better to just reset isDead to false for DestReg of the instruction cloned by remat.

[wmi]

Address Quentins' comment.

[wmi]

Hi Quentin,

Do you think the change looks ok now? I did another round of testing for the original patch plus all the updated bug fixing patches and saw no failure. If it is ok, I will recommit all these changes again.

Thanks,
Wei.

[qcolombet]

LGTM.

[Eugene.Zelenko]

Settled in r266162.

include/llvm/CodeGen/LiveRangeEdit.h

public:
   }
 
   void markDeadRemat(MachineInstr *inst) {
     // DeadRemats is an optional field.
     if (DeadRemats)
       DeadRemats->insert(inst);
   }
 
+  bool isDeadRematInstr(MachineInstr *inst) { return DeadRemats->count(inst); }
+
   /// eraseVirtReg - Notify the delegate that Reg is no longer in use, and try
   /// to erase it from LIS.
   void eraseVirtReg(unsigned Reg);
 
   /// eliminateDeadDefs - Try to delete machine instructions that are now dead
   /// (allDefsAreDead returns true). This may cause live intervals to be trimmed
   /// and further dead efs to be eliminated.
   /// RegsBeingSpilled lists registers currently being spilled by the register

lib/CodeGen/LiveRangeEdit.cpp

 
 SlotIndex LiveRangeEdit::rematerializeAt(MachineBasicBlock &MBB,
                                          MachineBasicBlock::iterator MI,
                                          unsigned DestReg,
                                          const Remat &RM,
                                          const TargetRegisterInfo &tri,
                                          bool Late) {
   assert(RM.OrigMI && "Invalid remat");
+  // The dest operand of Inst in DeadRemats is set to Dead because it
+  // uses dummy register and MachineVerifier will check it.
+  // When inst in DeadRemats is used for remat, need to set the dest
+  // operand of the inst not to be Dead before reMaterialize and reset
+  // it to be Dead after. That is because otherwise the flag will be
+  // copied to the remat instruction newly created in reMaterialize
+  // whose dest operand we know is not Dead.
+  bool isDeadRemat = isDeadRematInstr(RM.OrigMI);
+  if (isDeadRemat)
+    RM.OrigMI->getOperand(0).setIsDead(false);
+
+  assert(!RM.OrigMI->getOperand(0).isDead() &&
+         "dest register of OrigMI cannot be Dead before remat");
   TII.reMaterialize(MBB, MI, DestReg, 0, RM.OrigMI, tri);
+
+  if (isDeadRemat)
+    RM.OrigMI->getOperand(0).setIsDead(true);
   Rematted.insert(RM.ParentVNI);
   return LIS.getSlotIndexes()
       ->insertMachineInstrInMaps(*--MI, Late)
       .getRegSlot();
 }
 
 void LiveRangeEdit::eraseVirtReg(unsigned Reg) {
   if (TheDelegate && TheDelegate->LRE_CanEraseVirtReg(Reg))
if (ReadsPhysRegs) {
     }
     DEBUG(dbgs() << "Converted physregs to:\t" << *MI);
   } else {
     // If the dest of MI is an original reg, don't delete the inst. Replace
     // the dest with a new reg, keep the inst for remat of other siblings.
     // The inst is saved in LiveRangeEdit::DeadRemats and will be deleted
     // after all the allocations of the func are done.
     if (isOrigDef) {
-      unsigned NewDest = createFrom(Dest);
+      LiveInterval &NewLI = createEmptyIntervalFrom(Dest);
+      VNInfo *VNI = NewLI.getNextValue(Idx, LIS.getVNInfoAllocator());
+      NewLI.addSegment(LiveInterval::Segment(Idx, Idx.getDeadSlot(), VNI));
       pop_back();
       markDeadRemat(MI);
       const TargetRegisterInfo &TRI = *MRI.getTargetRegisterInfo();
-      MI->substituteRegister(Dest, NewDest, 0, TRI);
-      MI->getOperand(0).setIsDead(false);
+      MI->substituteRegister(Dest, NewLI.reg, 0, TRI);
+      MI->getOperand(0).setIsDead(true);
     } else {
       if (TheDelegate)
         TheDelegate->LRE_WillEraseInstruction(MI);
       LIS.RemoveMachineInstrFromMaps(*MI);
       MI->eraseFromParent();
       ++NumDCEDeleted;
     }
   }

test/CodeGen/X86/new-remat.ll

-; RUN: llc < %s | FileCheck %s
+; RUN: llc -verify-regalloc < %s | FileCheck %s
 ; Check all spills are rematerialized.
 ; CHECK-NOT: Spill
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @b = common global double 0.000000e+00, align 8
 @a = common global i32 0, align 4