[WIP][DebugInfo] When sinking DBG_VALUEs, only insert undef DBG_VALUEs if sinking would re-order assignments

[jmorse]

Summary

This patch is a follow-up to D58238, where the discussion asked in what circumstances we needed to insert undef DBG_VALUEs into a block when sinking instructions. The answer was (to my mind) "only when it would re-order the appearance of variable assignments". This patch attempts to implement that.

I then realised that I'd misread some of Bjorns question there, so leaving this as a WIP with no reviewers until I'm certain this is a good idea.

The overall idea here is to keep a MachineBasicBlock::iterator that points at (or after) the last DBG_VALUE in a block. We can then identify whether DBG_VALUEs that are to be sunk, sink past the last one, which would mean assignments were re-ordered. In the worst case scenario we'll end up iterating over each basic block twice instead of once, which IMO is a better trade-off than anything that allocates memory.

If a set of DBG_VALUEs sink without any other DBG_VALUE being between them and the end of the block, for example:

blah:
    %0 = tosink...
    DBG_VALUE %0, "var1"
    %1 = inst1...
    DBG_VALUE %0, "var2"
    %2 = inst2...
    DBG_VALUE %0, "var3"
    br i1 %cond, label %dest, label %nope

and if "tosink" were sunk to another block, we would sink all those DBG_VALUEs into the destination block like this:

blah:
    %1 = inst1...
    %2 = inst2...
    br i1 %cond, ...
dest:
    %0 = tosink...
    DBG_VALUE %0, "var1"
    DBG_VALUE %0, "var2"
    DBG_VALUE %0, "var3"
    [...]
nope:
    DBG_VALUE undef, "var1"
    DBG_VALUE undef, "var2"
    DBG_VALUE undef, "var3"
    [...]

This reduces the number of sets of of different variable values you can see, because var1/var2/var3 all transition at the same time. This it the correct behaviour IMO because:

• We can't cover the 'blah' block with %0 regardless
• We're keeping var1/var2/var3 alive as long as possible in the 'blah' block

Wheras if there were a DBG_VALUE %2, "var4" after 'inst2', we would get:

blah:
    %1 = inst1...
    %2 = inst2...
    DBG_VALUE undef, "var1"
    DBG_VALUE undef, "var2"
    DBG_VALUE %2, "var4"
    br i1 %cond, ...
dest:
    %0 = tosink...
    DBG_VALUE %0, "var1"
    DBG_VALUE %0, "var2"
    DBG_VALUE %0, "var3"
    [...]
nope:
    DBG_VALUE undef, "var3"
    [...]

With var1/var2 leaving undef DBG_VALUEs in place in 'blah', to avoid earlier assignments to var1/var2 reordering with the assignment to var4.

I've split copy-propagation into its own function and applied it before sinking, to avoid awkward interactions with the "last DBG_VALUE in block" iterator. Any DBG_VALUE that can be copy-propagated doesn't need to be sunk anyway, and livedebugvalues should observe the sunk copy and keep the variable alive there.

Test changes:

• postra-ignore-dbg-instrs.mir: the DBG_VALUE gets copy-prop'd now, and the test is only checking that the debug instruction doesn't affect codegen, so I've deleted the debug check line.
• pr38952.mir: this is checking that non-immediately-following DBG_VALUEs get sunk. With this patch, the example gets copy-prop'd. I've changed the DBG_VALUE to refer to a subregister instead (which gets sunk), and test that not-immediately-following DBG_VALUEs get found.
• machinesink.mir: as we're no longer re-ordering assignments, a sunk DBG_VALUE no longer leaves an undef DBG_VALUE behind.
• postra-subreg-sink.mir: Two DBG_VALUEs no longer leave undef's behind, one only gets copy-prop'd, not sunk and copy-prop'd.
• sink-leaves-undef.mir: insert a DBG_VALUE that would lead to ordering reassignment, to test that an undef DBG_VALUE is generated

[jmorse]

(This is now reborn as D70672)

lib/CodeGen/MachineSink.cpp

 //
 // This pass is not intended to be a replacement or a complete alternative
 // for an LLVM-IR-level sinking pass. It is only designed to sink simple
 // constructs that are not exposed before lowering and instruction selection.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SparseBitVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
class MachineSinking : public MachineFunctionPass {
     SparseBitVector<> RegsToClearKillFlags;
 
     using AllSuccsCache =
         std::map<MachineBasicBlock *, SmallVector<MachineBasicBlock *, 4>>;
 
     // Remember debug uses of vregs seen, so we know what to sink out of blocks.
     DenseMap<unsigned, TinyPtrVector<MachineInstr *>> SeenDbgUsers;
 
+    // Iterator identifying the last "significant" DBG_VALUE in the block (i.e.
+    // non-undef DBG_VALUE). Used to determine whether sinking DBG_VALUEs will
+    // change the order that assignments appear.
+    MachineBasicBlock::iterator LastDbgInst;
+
   public:
     static char ID; // Pass identification
 
     MachineSinking() : MachineFunctionPass(ID) {
       initializeMachineSinkingPass(*PassRegistry::getPassRegistry());
     }
 
     bool runOnMachineFunction(MachineFunction &MF) override;
bool MachineSinking::ProcessBlock(MachineBasicBlock &MBB) {
   if (MBB.succ_size() <= 1 || MBB.empty()) return false;
 
   // Don't bother sinking code out of unreachable blocks. In addition to being
   // unprofitable, it can also lead to infinite looping, because in an
   // unreachable loop there may be nowhere to stop.
   if (!DT->isReachableFromEntry(&MBB)) return false;
 
   bool MadeChange = false;
+  LastDbgInst = MBB.end();
 
   // Cache all successors, sorted by frequency info and loop depth.
   AllSuccsCache AllSuccessors;
 
   // Walk the basic block bottom-up.  Remember if we saw a store.
   MachineBasicBlock::iterator I = MBB.end();
   --I;
   bool ProcessedBegin, SawStore = false;
if (TII->analyzeBranchPredicate(*PredMBB, MBP, false))
     return false;
 
   return MBP.LHS.isReg() && MBP.RHS.isImm() && MBP.RHS.getImm() == 0 &&
          (MBP.Predicate == MachineBranchPredicate::PRED_NE ||
           MBP.Predicate == MachineBranchPredicate::PRED_EQ) &&
          MBP.LHS.getReg() == BaseOp->getReg();
 }
 
-/// Sink an instruction and its associated debug instructions.
-static void performSink(MachineInstr &MI, MachineBasicBlock &SuccToSinkTo,
-                        MachineBasicBlock::iterator InsertPos,
-                        SmallVectorImpl<MachineInstr *> &DbgValuesToSink) {
-  const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo();
-  const TargetInstrInfo &TII = *MI.getMF()->getSubtarget().getInstrInfo();
+/// Separate DBG_VALUE instructions into those that would cause reordering of
+/// assignments when sunk, and those that would not. Uses (and updates) the last
+/// non-undef DBG_VALUE in the block to determine whether sinking DBG_VALUEs
+/// sink past it (thus reordering).
+static void
+filterReorderingDbgValues(MachineBasicBlock::iterator &LastDbgInst,
+                          MachineBasicBlock &MBB,
+                          SmallVectorImpl<MachineInstr *> &ToSink,
+                          SmallVectorImpl<MachineInstr *> &ReorderingDbgVals) {
+  SmallPtrSet<MachineInstr *, 8> SinkingSet(ToSink.begin(), ToSink.end());
+  SmallVector<MachineInstr *, 8> NoReordering;
+
+  // Walk the LastDbgInst iterator backwards: members of SinkingSet can be
+  // ignored, but if any another DBG_VALUE is seen then the members of
+  // SinkingSet will re-order when sunk past it.
+  // Keep track of which DBG_VALUEs are definitely safe-to-sink in NoReordering
+  // so that we can cope with partial cases where some DBG_VALUEs are safe to
+  // sink, and some are not.
+  for (; LastDbgInst != MBB.begin() && NoReordering.size() != ToSink.size();
+       --LastDbgInst) {
+    if (LastDbgInst == MBB.end() || !LastDbgInst->isDebugValue())
+      continue;
+
+    // Ignore undef DBG_VALUEs. They do not present program state, and so can't
+    // mislead the developer.
+    const MachineOperand &LastOp = LastDbgInst->getOperand(0);
+    if (LastOp.isReg() && LastOp.getReg() == 0)
+      continue;
+
+    if (SinkingSet.count(&*LastDbgInst)) {
+      // The last DBG_VALUE in the block is to be sunk: there are no others
+      // that it can sink past. Mark it as safe.
+      NoReordering.push_back(&*LastDbgInst);
+      SinkingSet.erase(&*LastDbgInst);
+      continue;
+    } else {
+      // We've found a meaningful DBG_VALUE that the contents of SinkingSet will
+      // be sunk past, causing assignment reordering. Report those as DBG_VALUEs
+      // that will re-order assignments.
+      for (auto *DbgVal : SinkingSet)
+        ReorderingDbgVals.push_back(DbgVal);
+
+      // Sinking DBG_VALUEs that we've previously determined to not re-order can
+      // safely be sunk with no further consideration.
+      ToSink = NoReordering;
+      return;
+    }
+  }
 
-  // If we cannot find a location to use (merge with), then we erase the debug
-  // location to prevent debug-info driven tools from potentially reporting
-  // wrong location information.
-  if (!SuccToSinkTo.empty() && InsertPos != SuccToSinkTo.end())
-    MI.setDebugLoc(DILocation::getMergedLocation(MI.getDebugLoc(),
-                                                 InsertPos->getDebugLoc()));
-  else
-    MI.setDebugLoc(DebugLoc());
+  // The loop terminates when we hit the start of the block (no re-ordering)
+  // or all the DBG_VALUEs were determined to be safe for re-ordering. No need
+  // to separate which DBG_VALUEs to sink.
+
+  // If we determined that no re-ordering occurs, step past the last seen
+  // DBG_VALUE.
+  if (NoReordering.size() == ToSink.size() && LastDbgInst != MBB.begin())
+    --LastDbgInst;
 
-  // Move the instruction.
-  MachineBasicBlock *ParentBlock = MI.getParent();
-  SuccToSinkTo.splice(InsertPos, ParentBlock, MI,
-                      ++MachineBasicBlock::iterator(MI));
-
-  // Sink a copy of debug users to the insert position. Mark the original
-  // DBG_VALUE location as 'undef', indicating that any earlier variable
-  // location should be terminated as we've optimised away the value at this
-  // point.
-  // If the sunk instruction is a copy, try to forward the copy instead of
-  // leaving an 'undef' DBG_VALUE in the original location. Don't do this if
-  // there's any subregister weirdness involved.
-  for (SmallVectorImpl<MachineInstr *>::iterator DBI = DbgValuesToSink.begin(),
-                                                 DBE = DbgValuesToSink.end();
-       DBI != DBE; ++DBI) {
-    MachineInstr *DbgMI = *DBI;
-    MachineInstr *NewDbgMI = DbgMI->getMF()->CloneMachineInstr(*DBI);
-    SuccToSinkTo.insert(InsertPos, NewDbgMI);
+  return;
+}
 
-    // Copy DBG_VALUE operand and set the original to undef. We then check to
-    // see whether this is something that can be const-propagated.
-    MachineOperand DbgMO = DbgMI->getOperand(0);
-    DbgMI->getOperand(0).setReg(0);
+static void copyPropDbgValues(MachineInstr &MI,
+                              SmallVectorImpl<MachineInstr *> &DbgVals)
+{
+  SmallVector<MachineInstr *, 8> NoCopyProp;
+  const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo();
+  const TargetInstrInfo &TII = *MI.getMF()->getSubtarget().getInstrInfo();
 
-    const MachineOperand *SrcMO = nullptr, *DstMO = nullptr;
-    if (TII.isCopyInstr(MI, SrcMO, DstMO)) {
-      bool DoCopy = false;
+  if (!TII.isCopyInstr(MI, SrcMO, DstMO))
+    return;
 
-      // Check validity of forwarding this copy.
-      bool PostRA = MRI.getNumVirtRegs() == 0;
 
-      // Pre-regalloc, only forward if all operands are virtual and their
-      // subregisters agree (or there are no subregs at all). More analysis
-      // might recover some forwardable copies.
-      if (TargetRegisterInfo::isVirtualRegister(DbgMO.getReg()) &&
-          TargetRegisterInfo::isVirtualRegister(SrcMO->getReg()) &&
-          DbgMO.getSubReg() == SrcMO->getSubReg() == DstMO->getSubReg() &&
-          !PostRA)
-        DoCopy = true;
-      // Post-regalloc, we may be sinking a DBG_VALUE of a sub or super-register
-      // of this copy. Only forward the copy if the DBG_VALUE operand exactly
-      // matches the copy destination.
-      else if (!TargetRegisterInfo::isVirtualRegister(DbgMO.getReg()) &&
-               !TargetRegisterInfo::isVirtualRegister(SrcMO->getReg()) &&
-               DbgMO.getReg() == DstMO->getReg() && PostRA)
-        DoCopy = true;
+  for (auto *DbgMI : DbgVals) {
+    MachineOperand DbgMO = DbgMI->getOperand(0);
+
+    bool DoCopy = false;
+
 
-      if (DoCopy) {
-        DbgMI->getOperand(0).setReg(SrcMO->getReg());
-        DbgMI->getOperand(0).setSubReg(SrcMO->getSubReg());
-      }
-    }
+    } else {
+      NoCopyProp.push_back(DbgMI);
+
+  // We might have successfully copy-prop'd several DBG_VALUEs, if there are
+  // any remaining then leave them to the caller to sink.
+  DbgVals.clear();
+  DbgVals = NoCopyProp;
+  return;
+}
+
+/// Sink an instruction and its associated debug instructions.
+static void performSink(MachineInstr &MI, MachineBasicBlock &SuccToSinkTo,
+                        MachineBasicBlock::iterator InsertPos,
+                        SmallVectorImpl<MachineInstr *> &DbgValuesToSink,
+                        MachineBasicBlock::iterator &LastDbgInst) {
+  // If we cannot find a location to use (merge with), then we erase the debug
+  // location to prevent debug-info driven tools from potentially reporting
+  // wrong location information.
+  if (!SuccToSinkTo.empty() && InsertPos != SuccToSinkTo.end())
+    MI.setDebugLoc(DILocation::getMergedLocation(MI.getDebugLoc(),
+                                                 InsertPos->getDebugLoc()));
+  else
+    MI.setDebugLoc(DebugLoc());
+
+  // Separate DBG_VALUEs that can sink without re-ordering variable values
+  // from those that cannot.
+  SmallVector<MachineInstr *, 8> ReorderingDbgVals;
+  filterReorderingDbgValues(LastDbgInst, *MI.getParent(), DbgValuesToSink,
+                            ReorderingDbgVals);
+
+  // Move the instruction.
+  MachineBasicBlock *ParentBlock = MI.getParent();
+  SuccToSinkTo.splice(InsertPos, ParentBlock, MI,
+                      ++MachineBasicBlock::iterator(MI));
+
+  SmallPtrSet<MachineBasicBlock *, 4>
+     OtherSuccs(ParentBlock->succ_begin(), ParentBlock->succ_end());
+  OtherSuccs.erase(&SuccToSinkTo);
+
+  // Sink DBG_VALUEs that won't re-order assignments. Enter undef DBG_VALUEs in
+  // all other successor blocks: we can't know the variables location in other
+  // successors unless a new DBG_VALUE specifies it.
+  for (auto DBI = DbgValuesToSink.begin(), DBE = DbgValuesToSink.end();
+       DBI != DBE;) {
+    for (auto *MBB : OtherSuccs) {
+      auto MIt = MBB->getFirstNonPHI();
+      MachineInstr *NewDbgMI = (*DBI)->getMF()->CloneMachineInstr(*DBI);
+      MBB->insert(MIt, NewDbgMI);
+      NewDbgMI->getOperand(0).setReg(0);
+    }
+
+    SmallVectorImpl<MachineInstr *>::iterator ToSink = DBI++;
+    SuccToSinkTo.insert(InsertPos, (*ToSink)->removeFromParent());
+  }
+
+  // Sink a copy of debug users to the insert position. Mark the original
+  // DBG_VALUE location as 'undef', indicating that any earlier variable
+  // location should be terminated as we've optimised away the value at this
+  // point.
+  for (SmallVectorImpl<MachineInstr *>::iterator
+           DBI = ReorderingDbgVals.begin(),
+           DBE = ReorderingDbgVals.end();
+       DBI != DBE; ++DBI) {
+    MachineInstr *DbgMI = *DBI;
+    MachineInstr *NewDbgMI = DbgMI->getMF()->CloneMachineInstr(*DBI);
+    SuccToSinkTo.insert(InsertPos, NewDbgMI);
+    DbgMI->getOperand(0).setReg(0);
   }
 }
 
 /// SinkInstruction - Determine whether it is safe to sink the specified machine
 /// instruction out of its current block into a successor.
 bool MachineSinking::SinkInstruction(MachineInstr &MI, bool &SawStore,
                                      AllSuccsCache &AllSuccessors) {
   // Don't sink instructions that the target prefers not to sink.
for (auto &MO : MI.operands()) {
 
     auto &Users = SeenDbgUsers[MO.getReg()];
     DbgUsersToSink.insert(DbgUsersToSink.end(), Users.begin(), Users.end());
   }
 
   // After sinking, some debug users may not be dominated any more. If possible,
   // copy-propagate their operands. As it's expensive, don't do this if there's
   // no debuginfo in the program.
-  if (MI.getMF()->getFunction().getSubprogram() && MI.isCopy())
+  if (MI.getMF()->getFunction().getSubprogram() && MI.isCopy()) {
+    copyPropDbgValues(MI, DbgUsersToSink);
     SalvageUnsunkDebugUsersOfCopy(MI, SuccToSinkTo);
+  }
 
-  performSink(MI, *SuccToSinkTo, InsertPos, DbgUsersToSink);
+  performSink(MI, *SuccToSinkTo, InsertPos, DbgUsersToSink, LastDbgInst);
 
   // Conservatively, clear any kill flags, since it's possible that they are no
   // longer correct.
   // Note that we have to clear the kill flags for any register this instruction
   // uses as we may sink over another instruction which currently kills the
   // used registers.
   for (MachineOperand &MO : MI.operands()) {
     if (MO.isReg() && MO.isUse())
bool PostRAMachineSinking::tryToSinkCopy(MachineBasicBlock &CurBB,
 
   bool Changed = false;
 
   // Track which registers have been modified and used between the end of the
   // block and the current instruction.
   ModifiedRegUnits.clear();
   UsedRegUnits.clear();
   SeenDbgInstrs.clear();
+  MachineBasicBlock::iterator LastDbgInst = CurBB.end();
 
   for (auto I = CurBB.rbegin(), E = CurBB.rend(); I != E;) {
     MachineInstr *MI = &*I;
     ++I;
 
     // Track the operand index for use in Copy.
     SmallVector<unsigned, 2> UsedOpsInCopy;
     // Track the register number defed in Copy.
for (auto &MO : MI->operands()) {
       for (unsigned Reg : Units)
         for (auto *MI : SeenDbgInstrs.lookup(Reg))
           DbgValsToSinkSet.insert(MI);
     }
     DbgValsToSink.insert(DbgValsToSink.begin(), DbgValsToSinkSet.begin(),
                          DbgValsToSinkSet.end());
     llvm::sort(DbgValsToSink);
 
+    // Copy propagating these dbg values -- even though we only sink copies --
+    // isn't guaranteed to succeed, as the copy may be for a register that
+    // aliases the DBG_VALUE operand, which isn't propagated.
+    copyPropDbgValues(*MI, DbgValsToSink);
+
     // Clear the kill flag if SrcReg is killed between MI and the end of the
     // block.
     clearKillFlags(MI, CurBB, UsedOpsInCopy, UsedRegUnits, TRI);
     MachineBasicBlock::iterator InsertPos = SuccBB->getFirstNonPHI();
-    performSink(*MI, *SuccBB, InsertPos, DbgValsToSink);
+    performSink(*MI, *SuccBB, InsertPos, DbgValsToSink, LastDbgInst);
     updateLiveIn(MI, SuccBB, UsedOpsInCopy, DefedRegsInCopy);
 
     Changed = true;
     ++NumPostRACopySink;
   }
   return Changed;
 }
 

test/CodeGen/X86/postra-ignore-dbg-instrs.mir

 
 ...
 ---
 # CHECK: name: x1
 # CHECK: bb.0:
 # CHECK-NOT: $eax = COPY $edi
 # CHECK: bb.1:
 # CHECK: renamable $eax = COPY $edi
-# CHECK-NEXT: DBG_VALUE $eax,
 # CHECK: bb.2:
 name:            x1
 alignment:       4
 tracksRegLiveness: true
 body: |
   bb.0:
     successors: %bb.2, %bb.1; %bb.2, %bb.1
     liveins: $edi

test/CodeGen/X86/pr38952.mir

bb.0.entry:
     liveins: $edi
   
   ; Test that the DBG_VALUE on ebx below is sunk with the def of ebx, despite
   ; not being adjacent to the def, see PR38952
 
     DBG_VALUE $edi, $noreg, !21, !DIExpression()
     renamable $ebx = COPY $edi
     renamable $eax = MOV32r0 implicit-def dead $eflags
-    DBG_VALUE $ebx, $noreg, !21, !DIExpression()
+    DBG_VALUE $bx, $noreg, !21, !DIExpression()
     CMP32ri $edi, 255, implicit-def $eflags
     JG_1 %bb.2, implicit killed $eflags
     JMP_1 %bb.1
   
   bb.1.if.end:
   ; CHECK-LABEL: bb.1.if.end
     successors: %bb.2(0x80000000)
     liveins: $ebx
   
   ; CHECK: $ebx = COPY $edi
-  ; CHECK-NEXT: DBG_VALUE $ebx
+  ; CHECK-NEXT: DBG_VALUE $bx
     renamable $rdx = MOVSX64rr32 renamable $ebx
     renamable $rdx = nsw SHL64ri killed renamable $rdx, 2, implicit-def dead $eflags
     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
     $rdi = MOV32ri64 0
     $esi = MOV32r0 implicit-def dead $eflags
     CALL64pcrel32 &memset, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit killed $esi, implicit $rdx, implicit-def $rsp, implicit-def $ssp, implicit-def dead $rax
     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
   
   bb.2.return:
     liveins: $eax
   
     RET 0, $eax
 
 ...

test/DebugInfo/MIR/X86/machinesink.mir

 # RUN: llc -run-pass=machine-sink -o - %s | FileCheck %s
 # Check various things when we sink machine instructions:
 #   a) DBG_VALUEs should sink with defs
-#   b) Undefs should be left behind
-#   c) DBG_VALUEs not immediately following the defining inst should sink too
-#   d) If we generate debug-use-before-defs through sinking, and can copy
+#   b) DBG_VALUEs not immediately following the defining inst should sink too
+#   c) If we generate debug-use-before-defs through sinking, and can copy
 #      propagate to a different value, we should do that.
 --- |
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 
   @x = common local_unnamed_addr global i32 0, align 4, !dbg !0
 
   ; Function Attrs: noreturn nounwind uwtable

 liveins:
   - { reg: '$rdi', virtual-reg: '%2' }
   - { reg: '$rsi', virtual-reg: '%2' }
 body:             |
   bb.0.entry:
     successors: %bb.1.nou(0x80000000), %bb.2.exit
     liveins: $rdi, $esi
 
-    ; This block should have the vreg copy sunk from it, the DBG_VALUE with it,
-    ; and an undef DBG_VALUE left over.
+    ; This block should have the vreg copy sunk from it, the DBG_VALUE with it.
     ; CHECK-LABEL: bb.0.entry:
     ; CHECK:       [[ARG0VREG:%[0-9]+]]:gr64 = COPY $rdi
     ; CHECK-NEXT:  CMP32ri $esi, 0
-    ; CHECK-NEXT:  DBG_VALUE $noreg, $noreg, [[VARNUM]]
     ; CHECK-NEXT:  JE_1
     ; CHECK-NEXT:  JMP_1
 
     %2:gr64 = COPY $rdi
     %5:gr64 = COPY %2
     CMP32ri $esi, 0, implicit-def $eflags
     DBG_VALUE %5, _, !16, !17, debug-location !18
     JE_1 %bb.1.nou, implicit $eflags
body:             |
   bb.2.exit:
     ; The DBG_VALUE below should have its operand copy-propagated after
     ; the copy to %5 is sunk.
     ; CHECK-LABEL: bb.2.exit:
     ; CHECK:       DBG_VALUE [[ARG0VREG]], $noreg, [[VARNUM]]
     ; CHECK-NEXT:  $rax = MOV64rr [[ARG0VREG]]
     ; CHECK-NEXT:  RET 0
     DBG_VALUE %5, _, !16, !17, debug-location !18
-    $rax = MOV64rr %2, _, 0, _
+    $rax = MOV64rr %2
     RET 0
 ...

test/DebugInfo/MIR/X86/postra-subreg-sink.mir

body:             |
 
   ; CHECK: ![[ARGVAR:[0-9]+]] = !DILocalVariable(name: "argc",
   ; CHECK: ![[FOOVAR:[0-9]+]] = !DILocalVariable(name: "foo",
   ; CHECK: ![[BARVAR:[0-9]+]] = !DILocalVariable(name: "bar",
   ; CHECK: ![[BAZVAR:[0-9]+]] = !DILocalVariable(name: "baz",
 
   ; In the following code, the:
   ;   DBG_VALUE of $edi should not sink: it's an argument
-  ;   DBG_VALUE of $ebx should sink: it's a standard copy
+  ;   DBG_VALUE of $ebx should copy-prop: it's a standard copy
   ;   DBG_VALUE of $bx should sink: a write of its superregister sinks
   ;   DBG_VALUE of $ecx should sink: a write of one of its subregisters sinks
 
   ; CHECK-LABEL: name: main
   ; CHECK: bb.0.entry:
   ; CHECK:   successors: %bb.1(0x80000000)
   ; CHECK:   liveins: $edi
   ; CHECK:   DBG_VALUE $edi, $noreg, ![[BARVAR]]
   ; CHECK-NEXT:   DBG_VALUE $edi, $noreg, ![[ARGVAR]]
-  ; CHECK-NEXT:   DBG_VALUE $noreg, $noreg, ![[BAZVAR]]
   ; CHECK-NEXT:   renamable $cl = MOV8ri 1
-  ; CHECK-NEXT:   DBG_VALUE $noreg, $noreg, ![[FOOVAR]]
   ; CHECK-NEXT:   JMP_1 %bb.1
   ; CHECK: bb.1.return:
   ; CHECK:   liveins: $cl, $edi
   ; CHECK:   renamable $ebx = COPY $edi
-  ; CHECK-NEXT:   DBG_VALUE $ebx, $noreg, ![[ARGVAR]]
   ; CHECK-NEXT:   DBG_VALUE $bx, $noreg, ![[BAZVAR]]
   ; CHECK-NEXT:   renamable $ch = COPY renamable $cl
   ; CHECK-NEXT:   DBG_VALUE $ecx, $noreg, ![[FOOVAR]]
   ; CHECK-NEXT:   $rdi = MOV32ri64 0
   ; CHECK-NEXT:   $eax = MOV32r0 implicit-def dead $eflags
   ; CHECK-NEXT:   RET 0, $eax
   bb.0.entry:
     successors: %bb.1(0x40000000)

test/DebugInfo/MIR/X86/sink-leaves-undef.mir

 # RUN: llc %s -o - -run-pass=machine-sink -mtriple=x86_64-- | FileCheck %s
 # This is a copy of test/CodeGen/X86/MachineSink-DbgValue.ll, where we
-# additionally test that when the MOV32rm defining %0 is sunk, it leaves
-# an 'undef' DBG_VALUE behind to terminate earlier location ranges.
+# test that when the MOV32rm defining %0 is sunk past a later DBG_VALUE, it
+# leaves an 'undef' DBG_VALUE behind to terminate earlier location ranges, to
+# avoid re-ordering of assignments.
 --- |
   target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-apple-macosx10.7.0"
   
   ; Function Attrs: nounwind readonly ssp uwtable
   define i32 @foo(i32 %i, i32* nocapture %c) #0 !dbg !4 {
     call void @llvm.dbg.value(metadata i32 %i, metadata !9, metadata !DIExpression()), !dbg !14
     %ab = load i32, i32* %c, align 1, !dbg !15
; CHECK:       DBG_VALUE $noreg, $noreg, ![[VARNUM]]
   
     DBG_VALUE $edi, $noreg, !9, !DIExpression(), debug-location !14
     DBG_VALUE $rsi, $noreg, !10, !DIExpression(), debug-location !16
     %4:gr64 = COPY $rsi
     DBG_VALUE %4, $noreg, !10, !DIExpression(), debug-location !16
     %3:gr32 = COPY $edi
     DBG_VALUE %3, $noreg, !9, !DIExpression(), debug-location !14
     %0:gr32 = MOV32rm %4, 1, $noreg, 0, $noreg, debug-location !15 :: (load 4 from %ir.c, align 1)
+    ; The debug inst to sink:
     DBG_VALUE %0, $noreg, !12, !DIExpression(), debug-location !15
     %5:gr32 = MOV32r0 implicit-def dead $eflags
     %6:gr32 = SUB32ri8 %3, 42, implicit-def $eflags, debug-location !17
+    ; Earlier debug inst will re-order assignments with this debug inst.
+    DBG_VALUE %3, $noreg, !9, !DIExpression(), debug-location !14
     JNE_1 %bb.2, implicit $eflags, debug-location !17
     JMP_1 %bb.1, debug-location !17
   
   bb.1.bb1:
   ; CHECK-LABEL: bb.1.bb1:
   ; CHECK:       %[[VREG:[0-9]+]]:gr32 = MOV32rm
   ; CHECK-NEXT:  DBG_VALUE %[[VREG]], $noreg, ![[VARNUM]]
   ; CHECK-NEXT:  ADD32ri8
     %1:gr32 = nsw ADD32ri8 %0, 2, implicit-def dead $eflags, debug-location !18
   
   bb.2.bb2:
     %2:gr32 = PHI %5, %bb.0, %1, %bb.1
     $eax = COPY %2, debug-location !19
     RET 0, $eax, debug-location !19
 
 ...