[LiveDebugValues] Cleanup Transfers when removing Entry Value Location

[ntesic]

Summary

If we encounter a new debug value, describing the same parameter, we should stop tracking
the parameter's Entry Value. At that point, in some cases, the Transfer which uses the parameter's
Entry Value, is already emitted. Thanks to the RemoveRedundantDebugValues pass, many problems with
incorrect instruction order and number of DBG_VALUEs are fixed. However, we still cannot rely on the
rule that each new debug value is set by the previous non-debug instruction in Machine Basic Block.

When new parameter debug value triggers removal of Backup Entry Value for the same parameter,
do the cleanup of Transfers emitted from Backup Entry Values.
Get the Transfer Instruction which created the new debug value and search for debug values already
emitted from the to-be-deleted Backup Entry Value and attached to the Transfer Instruction.
If found, delete the Transfer and remove "primary" Entry Value Var Loc from OpenRanges.

This patch fixes PR47628.

[jmorse]

As I understand it, this patch is aiming to recognise patterns where an entry value is being copied to a new register location and then being DBG_VALUE'd, which is effectively a no-op as far as tracking entry values is concerned.

I think the EntryValTransfers container is going to suffer from not being aware that it's part of a dataflow algorithm: one transfer gets inserted per emitEntryValues, and we can repeatedly explore the same block in a loop as part of the dataflow algorithm. But cleanupEntryValueTransfers will only delete one entry -- I suspect it should try and delete all matching entries. (The uh, Transfers collection suffers from the same problem, which I had a patch for at D67500, but didn't push it particularly hard).

The RegSetterInstructionMap is purely to find COPYs that might mean the entry value doesn't have to be dropped, yes? This seems OK, so long as it's not relied upon to determine whether a register contains a different value -- values can be defined when blocks merge and the join method runs.

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

1237–1238

Always returns true -> should instead be void? This disguises the fact that removeEntryValue always intends to return true when it calls this function.

1248–1249

You might be able to use llvm::make_range and turn this into a range-based-loop, which would be a little more readable.

1251–1253

Any reason to not use the VarLoc operator==?

1284–1286

What about loop heads like this:

entry:
  DBG_VALUE $rdi

loop:
  DBG_VALUE $rdi
  $rdi = somedef
  JMP loop

The second DBG_VALUE refers to a different value, due to the def of rdi in the loop. On the first examination of loop, there wouldn't be any reason to remove an entry value; presumably we can rely on the join method to erase the EntryValueBackupKind locations when the loop is visited for a second time?

1315–1322

There are four identical return/calls like this after TransferInst is assigned, and two instances of "return false". Wouldn't it be better to switch the logic to return cleanupEntryValue... by default, and pick out the two instances where false is returned?

1422–1424

Could I recommend assert(EntryValueIDs.size() == 1 && "EntryValue loc should not be variadic");.

(Purely for communicating the assumptions this is based on to the reader)

[ntesic]

Hi Jeremy,
Thanks for the comments.

This patch purpose is to fix PR47628 and improve
the solution from D68209 .
Here is the more detailed explanation.

Typical MIR in focus of the patch:

$edi = MOV
DBG_VALUE $edi, ,"param"

Step_1: MI: $edi = MOV ...

• LDV detects parameter forwarding register is clobbered.
• As the primary location of parameter is lost, we use its EntryValue Backup location as the new primary location, and emit the Transfer.

Step_2: MI: DBG_VALUE $edi, ,"param"

• LDV detects parameter value is modified.
• The EntryValue Backup location of the parameter is not valid anymore.

Problem:
Step_2 means we shouldn't have used EntryValue Backup location in Step_1.

Old solution:

• removes EntryVarLoc from EntryValue Backup locations
• not from primary locations (OpenRanges) if inserted
• doesn't invalidate already emitted Transfer

Solution from this patch - do the cleanup to undo the Step_1:

• remove emitted EntryValueTransfer
• remove EntryVarLoc from OpenRanges

Bad MIR example from PR47628:

    renamable $edi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20
[1] DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_entry_value, 1), [...]
    DBG_VALUE $edi, $noreg, !13, !DIExpression(), debug-location !14
    ...
    CALL64pcrel32 @bar, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit-def $rsp, implicit-def $ssp, debug-location !20
[2] DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !13

Consequences of the main problem:
[1] Not-deleted Transfer that uses parameter Entry Value will result in bad DBG_VALUE in MIR.
[2] Not-deleted Entry Value Location from Open Ranges will result in usage of incorrect VarLoc later in code.

As I understand it, this patch is aiming to recognise patterns where an entry value is being copied to a new register location and then being DBG_VALUE'd, which is effectively a no-op as far as tracking entry values is concerned.

This patch is not focused on copyies of entry values. As I understand, that is already included in D68209 .

I think the EntryValTransfers container is going to suffer from not being aware that it's part of a dataflow algorithm: one transfer gets inserted per emitEntryValues, and we can repeatedly explore the same block in a loop as part of the dataflow algorithm. But cleanupEntryValueTransfers will only delete one entry -- I suspect it should try and delete all matching entries. (The uh, Transfers collection suffers from the same problem, which I had a patch for at D67500, but didn't push it particularly hard).

The EntryValTransfers container is managed in the similar way as the Transfers.
But, as it is used to do cleanup only for the previous register defining instruction, I don't see that as the problem further in dataflow algorithm.
(In short terms, if we find DBG_VALUE of changed parameter, do the cleanup only for the instruction that created that DBG_VALUE.)

The RegSetterInstructionMap is purely to find COPYs that might mean the entry value doesn't have to be dropped, yes? This seems OK, so long as it's not relied upon to determine whether a register contains a different value -- values can be defined when blocks merge and the join method runs.

When we find new DBG_VALUE of a parameter, if its debug operand is a Register, find which instruction clobbered the Register using RegSetterInstructionMap.
Then we can map that instruction to an emitted Entry Value Transfer.
The insertion into RegSetterInstructionMap is tied to definitions of a registers found by the transferRegisterDef function, so we don't pay attention to the value loaded into the Register.

[ntesic]

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

1251–1253

Well, the EntryVL is of a "backup" kind, and EmittedEV isn't. So, the == operator doesn't see them as equal.

1422–1424

Sure, I agree with that proposal.

[ntesic]

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

1237–1238

I agree. I should definitely find more elegant way to call the cleanupEntryValueTransfers .

[ntesic]

• Address comments
• Refactor removeEntryValue
• Add a test for the loop case emphasized by @jmorse

[ntesic]

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

1284–1286

Thanks for pointing this out!
I think we should stop tracking Entry Value if we find DBG_VALUE describing new definition, without taking into consideration why is the DBG_VALUE there. From this point, I don't see a way to use Entry Value location only for the first examination of loop and not for others, since it is the code at the same PC offset.

My proposal is to preserve Entry Value only for the parameter DBG_VALUEs at the start of entry BB. At this point those, parameter DBG_VALUEs, are not propagated into other BBs, so we don't need to worry about other BBs.

[djtodoro]

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

795

Please add comments describing these types (+ any better name for this type?)

796

RegDefToInstMap

1251–1253

can we use the std::tie() here?

[ntesic]

• Address comments from @djtodoro
• Rebase

[ntesic]

@djtodoro Thanks for the comments, I agree with all of them.

[ntesic]

Reformat the code.
@jmorse, @djtodoro Any additional comments? Thanks.

[djtodoro]

Thanks.

llvm/lib/CodeGen/LiveDebugValues/VarLocBasedImpl.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TypeSize.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <queue>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "livedebugvalues"
private:
   const TargetRegisterInfo *TRI;
   const TargetInstrInfo *TII;
   const TargetFrameLowering *TFI;
   TargetPassConfig *TPC;
   BitVector CalleeSavedRegs;
   LexicalScopes LS;
   VarLocSet::Allocator Alloc;
 
+  const MachineInstr *LastNonDbgMI;
+
   enum struct TransferKind { TransferCopy, TransferSpill, TransferRestore };
 
   using FragmentInfo = DIExpression::FragmentInfo;
   using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;
 
   /// A pair of debug variable and value location.
   struct VarLoc {
     // The location at which a spilled variable resides. It consists of a
#endif
 
   using VarLocInMBB =
       SmallDenseMap<const MachineBasicBlock *, std::unique_ptr<VarLocSet>>;
   struct TransferDebugPair {
     MachineInstr *TransferInst; ///< Instruction where this transfer occurs.
     LocIndex LocationID;        ///< Location number for the transfer dest.
   };
   using TransferMap = SmallVector<TransferDebugPair, 4>;
+  // Types for recording Entry Var Locations emitted by a single MachineInstr,
+  // as well as recording MachineInstr which last defined a register.
+  using InstToEntryLocMap = std::multimap<const MachineInstr *, LocIndex>;
+  using RegDefToInstMap = DenseMap<Register, MachineInstr *>;
 
   // Types for recording sets of variable fragments that overlap. For a given
   // local variable, we record all other fragments of that variable that could
   // overlap it, to reduce search time.
   using FragmentOfVar =
       std::pair<const DILocalVariable *, DIExpression::FragmentInfo>;
   using OverlapMap =
       DenseMap<FragmentOfVar, SmallVector<DIExpression::FragmentInfo, 1>>;
#endif
   VarLoc::SpillLoc extractSpillBaseRegAndOffset(const MachineInstr &MI);
   void insertTransferDebugPair(MachineInstr &MI, OpenRangesSet &OpenRanges,
                                TransferMap &Transfers, VarLocMap &VarLocIDs,
                                LocIndex OldVarID, TransferKind Kind,
                                const VarLoc::MachineLoc &OldLoc,
                                Register NewReg = Register());
 
   void transferDebugValue(const MachineInstr &MI, OpenRangesSet &OpenRanges,
-                          VarLocMap &VarLocIDs);
+                          VarLocMap &VarLocIDs,
+                          InstToEntryLocMap &EntryValTransfers,
+                          RegDefToInstMap &RegSetInstrs);
   void transferSpillOrRestoreInst(MachineInstr &MI, OpenRangesSet &OpenRanges,
                                   VarLocMap &VarLocIDs, TransferMap &Transfers);
-  bool removeEntryValue(const MachineInstr &MI, OpenRangesSet &OpenRanges,
-                        VarLocMap &VarLocIDs, const VarLoc &EntryVL);
+  void cleanupEntryValueTransfers(const MachineInstr *MI,
+                                  OpenRangesSet &OpenRanges,
+                                  VarLocMap &VarLocIDs, const VarLoc &EntryVL,
+                                  InstToEntryLocMap &EntryValTransfers);
+  void removeEntryValue(const MachineInstr &MI, OpenRangesSet &OpenRanges,
+                        VarLocMap &VarLocIDs, const VarLoc &EntryVL,
+                        InstToEntryLocMap &EntryValTransfers,
+                        RegDefToInstMap &RegSetInstrs);
   void emitEntryValues(MachineInstr &MI, OpenRangesSet &OpenRanges,
-                       VarLocMap &VarLocIDs, TransferMap &Transfers,
+                       VarLocMap &VarLocIDs,
+                       InstToEntryLocMap &EntryValTransfers,
                        VarLocsInRange &KillSet);
   void recordEntryValue(const MachineInstr &MI,
                         const DefinedRegsSet &DefinedRegs,
                         OpenRangesSet &OpenRanges, VarLocMap &VarLocIDs);
   void transferRegisterCopy(MachineInstr &MI, OpenRangesSet &OpenRanges,
                             VarLocMap &VarLocIDs, TransferMap &Transfers);
   void transferRegisterDef(MachineInstr &MI, OpenRangesSet &OpenRanges,
-                           VarLocMap &VarLocIDs, TransferMap &Transfers);
+                           VarLocMap &VarLocIDs,
+                           InstToEntryLocMap &EntryValTransfers,
+                           RegDefToInstMap &RegSetInstrs);
   bool transferTerminator(MachineBasicBlock *MBB, OpenRangesSet &OpenRanges,
                           VarLocInMBB &OutLocs, const VarLocMap &VarLocIDs);
 
   void process(MachineInstr &MI, OpenRangesSet &OpenRanges,
-               VarLocMap &VarLocIDs, TransferMap &Transfers);
+               VarLocMap &VarLocIDs, TransferMap &Transfers,
+               InstToEntryLocMap &EntryValTransfers,
+               RegDefToInstMap &RegSetInstrs);
 
   void accumulateFragmentMap(MachineInstr &MI, VarToFragments &SeenFragments,
                              OverlapMap &OLapMap);
 
   bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
             const VarLocMap &VarLocIDs,
             SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
             SmallPtrSetImpl<const MachineBasicBlock *> &ArtificialBlocks);
assert(PVal->kind() == PseudoSourceValue::FixedStack &&
          "Inconsistent memory operand in spill instruction");
   int FI = cast<FixedStackPseudoSourceValue>(PVal)->getFrameIndex();
   const MachineBasicBlock *MBB = MI.getParent();
   Register Reg;
   StackOffset Offset = TFI->getFrameIndexReference(*MBB->getParent(), FI, Reg);
   return {Reg, Offset};
 }
 
+/// Do cleanup of \p EntryValTransfers created by \p TRInst, by removing the
+/// Transfer, which uses the to-be-deleted \p EntryVL.
+void VarLocBasedLDV::cleanupEntryValueTransfers(
+    const MachineInstr *TRInst, OpenRangesSet &OpenRanges, VarLocMap &VarLocIDs,
+    const VarLoc &EntryVL, InstToEntryLocMap &EntryValTransfers) {
+  if (EntryValTransfers.empty() || TRInst == nullptr)
+    return;
+
+  auto TransRange = EntryValTransfers.equal_range(TRInst);
+  for (auto TDPair : llvm::make_range(TransRange.first, TransRange.second)) {
+    const VarLoc &EmittedEV = VarLocIDs[TDPair.second];
+    if (std::tie(EntryVL.Var, EntryVL.Locs[0].Value.RegNo, EntryVL.Expr) ==
+        std::tie(EmittedEV.Var, EmittedEV.Locs[0].Value.RegNo,
+                 EmittedEV.Expr)) {
+      OpenRanges.erase(EmittedEV);
+      EntryValTransfers.erase(TRInst);
+      break;
+    }
+  }
+}
+
 /// Try to salvage the debug entry value if we encounter a new debug value
 /// describing the same parameter, otherwise stop tracking the value. Return
-/// true if we should stop tracking the entry value, otherwise return false.
-bool VarLocBasedLDV::removeEntryValue(const MachineInstr &MI,
-                                       OpenRangesSet &OpenRanges,
-                                       VarLocMap &VarLocIDs,
-                                       const VarLoc &EntryVL) {
+/// true if we should stop tracking the entry value and do the cleanup of
+/// emitted Entry Value Transfers, otherwise return false.
+void VarLocBasedLDV::removeEntryValue(const MachineInstr &MI,
+                                      const VarLoc &EntryVL,
+                                      InstToEntryLocMap &EntryValTransfers,
+                                      RegDefToInstMap &RegSetInstrs) {
   // Skip the DBG_VALUE which is the debug entry value itself.
-  if (MI.isIdenticalTo(EntryVL.MI))
-    return false;
+  if (&MI == &EntryVL.MI)
+    return;
 
   // If the parameter's location is not register location, we can not track
-  // the entry value any more. In addition, if the debug expression from the
-  // DBG_VALUE is not empty, we can assume the parameter's value has changed
-  // indicating that we should stop tracking its entry value as well.
-  if (!MI.getDebugOperand(0).isReg() ||
-      MI.getDebugExpression()->getNumElements() != 0)
-    return true;
+  // the entry value any more. It doesn't have the TransferInst which defines
+  // register, so no Entry Value Transfers have been emitted already.
+  if (!MI.getDebugOperand(0).isReg())
+    return;
 
-  // If the DBG_VALUE comes from a copy instruction that copies the entry value,
-  // it means the parameter's value has not changed and we should be able to use
-  // its entry value.
+  // Try to get non-debug instruction responsible for the DBG_VALUE.
+  const MachineInstr *TransferInst = nullptr;
   Register Reg = MI.getDebugOperand(0).getReg();
-  auto I = std::next(MI.getReverseIterator());
-  const MachineOperand *SrcRegOp, *DestRegOp;
-  if (I != MI.getParent()->rend()) {
+  if (Reg.isValid() && RegSetInstrs.find(Reg) != RegSetInstrs.end())
+    TransferInst = RegSetInstrs.find(Reg)->second;
 
+  // Case of the parameter's DBG_VALUE at the start of entry MBB.
+  if (!TransferInst && !LastNonDbgMI && MI.getParent()->isEntryBlock())
+    return;
+
+  // If the debug expression from the DBG_VALUE is not empty, we can assume the
+  // parameter's value has changed indicating that we should stop tracking its
+  // entry value as well.
+  if (MI.getDebugExpression()->getNumElements() == 0 && TransferInst) {
+    // If the DBG_VALUE comes from a copy instruction that copies the entry
+    // value, it means the parameter's value has not changed and we should be
+    // able to use its entry value.
     // TODO: Try to keep tracking of an entry value if we encounter a propagated
     // DBG_VALUE describing the copy of the entry value. (Propagated entry value
     // does not indicate the parameter modification.)
-    auto DestSrc = TII->isCopyInstr(*I);
-    if (!DestSrc)
-      return true;
-
+    auto DestSrc = TII->isCopyInstr(*TransferInst);
+    if (DestSrc) {
+      const MachineOperand *SrcRegOp, *DestRegOp;
       SrcRegOp = DestSrc->Source;
       DestRegOp = DestSrc->Destination;
-    if (Reg != DestRegOp->getReg())
-      return true;
-
+      if (Reg == DestRegOp->getReg()) {
         for (uint64_t ID : OpenRanges.getEntryValueBackupVarLocs()) {
           const VarLoc &VL = VarLocIDs[LocIndex::fromRawInteger(ID)];
           if (VL.isEntryValueCopyBackupReg(Reg) &&
               // Entry Values should not be variadic.
               VL.MI.getDebugOperand(0).getReg() == SrcRegOp->getReg())
-        return false;
+            return;
+        }
+      }
     }
   }
 
-  return true;
+  LLVM_DEBUG(dbgs() << "Deleting a DBG entry value because of: ";
+             MI.print(dbgs(), /*IsStandalone*/ false,
+                      /*SkipOpers*/ false, /*SkipDebugLoc*/ false,
+                      /*AddNewLine*/ true, TII));
+  cleanupEntryValueTransfers(TransferInst, OpenRanges, VarLocIDs, EntryVL,
+                             EntryValTransfers);
+  OpenRanges.erase(EntryVL);
 }
 
 /// End all previous ranges related to @MI and start a new range from @MI
 /// if it is a DBG_VALUE instr.
 void VarLocBasedLDV::transferDebugValue(const MachineInstr &MI,
-                                         OpenRangesSet &OpenRanges,
-                                         VarLocMap &VarLocIDs) {
+                                        VarLocMap &VarLocIDs,
+                                        InstToEntryLocMap &EntryValTransfers,
+                                        RegDefToInstMap &RegSetInstrs) {
   if (!MI.isDebugValue())
     return;
   const DILocalVariable *Var = MI.getDebugVariable();
   const DIExpression *Expr = MI.getDebugExpression();
   const DILocation *DebugLoc = MI.getDebugLoc();
   const DILocation *InlinedAt = DebugLoc->getInlinedAt();
   assert(Var->isValidLocationForIntrinsic(DebugLoc) &&
          "Expected inlined-at fields to agree");
 
   DebugVariable V(Var, Expr, InlinedAt);
 
   // Check if this DBG_VALUE indicates a parameter's value changing.
   // If that is the case, we should stop tracking its entry value.
   auto EntryValBackupID = OpenRanges.getEntryValueBackup(V);
   if (Var->isParameter() && EntryValBackupID) {
     const VarLoc &EntryVL = VarLocIDs[EntryValBackupID->back()];
-    if (removeEntryValue(MI, OpenRanges, VarLocIDs, EntryVL)) {
-      LLVM_DEBUG(dbgs() << "Deleting a DBG entry value because of: ";
-                 MI.print(dbgs(), /*IsStandalone*/ false,
-                          /*SkipOpers*/ false, /*SkipDebugLoc*/ false,
-                          /*AddNewLine*/ true, TII));
-      OpenRanges.erase(EntryVL);
-    }
+    removeEntryValue(MI, OpenRanges, VarLocIDs, EntryVL, EntryValTransfers,
+                     RegSetInstrs);
   }
 
   if (all_of(MI.debug_operands(), [](const MachineOperand &MO) {
         return (MO.isReg() && MO.getReg()) || MO.isImm() || MO.isFPImm() ||
                MO.isCImm();
       })) {
     // Use normal VarLoc constructor for registers and immediates.
     VarLoc VL(MI, LS);
for (auto It = CollectFrom.find(FirstIndex), End = CollectFrom.end();
     Collected.push_back(VarLocIDs[RegIdx]);
   }
 }
 
 /// Turn the entry value backup locations into primary locations.
 void VarLocBasedLDV::emitEntryValues(MachineInstr &MI,
                                      OpenRangesSet &OpenRanges,
                                      VarLocMap &VarLocIDs,
-                                     TransferMap &Transfers,
+                                     InstToEntryLocMap &EntryValTransfers,
                                      VarLocsInRange &KillSet) {
   // Do not insert entry value locations after a terminator.
   if (MI.isTerminator())
     return;
 
   for (uint32_t ID : KillSet) {
     // The KillSet IDs are indices for the universal location bucket.
     LocIndex Idx = LocIndex(LocIndex::kUniversalLocation, ID);
for (uint32_t ID : KillSet) {
     // be able to use its entry value.
     if (!EntryValBackupIDs)
       continue;
 
     const VarLoc &EntryVL = VarLocIDs[EntryValBackupIDs->back()];
     VarLoc EntryLoc = VarLoc::CreateEntryLoc(EntryVL.MI, LS, EntryVL.Expr,
                                              EntryVL.Locs[0].Value.RegNo);
     LocIndices EntryValueIDs = VarLocIDs.insert(EntryLoc);
-    Transfers.push_back({&MI, EntryValueIDs.back()});
+    assert(EntryValueIDs.size() == 1 &&
+           "EntryValue loc should not be variadic");
+    EntryValTransfers.insert({&MI, EntryValueIDs.back()});
     OpenRanges.insert(EntryValueIDs, EntryLoc);
   }
 }
 
 /// Create new TransferDebugPair and insert it in \p Transfers. The VarLoc
 /// with \p OldVarID should be deleted form \p OpenRanges and replaced with
 /// new VarLoc. If \p NewReg is different than default zero value then the
 /// new location will be register location created by the copy like instruction,
case TransferKind::TransferRestore: {
     });
     return;
   }
   }
   llvm_unreachable("Invalid transfer kind");
 }
 
 /// A definition of a register may mark the end of a range.
-void VarLocBasedLDV::transferRegisterDef(
-    MachineInstr &MI, OpenRangesSet &OpenRanges, VarLocMap &VarLocIDs,
-    TransferMap &Transfers) {
+void VarLocBasedLDV::transferRegisterDef(MachineInstr &MI,
+                                         OpenRangesSet &OpenRanges,
+                                         VarLocMap &VarLocIDs,
+                                         InstToEntryLocMap &EntryValTransfers,
+                                         RegDefToInstMap &RegSetInstrs) {
 
   // Meta Instructions do not affect the debug liveness of any register they
   // define.
   if (MI.isMetaInstruction())
     return;
 
   MachineFunction *MF = MI.getMF();
   const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
   Register SP = TLI->getStackPointerRegisterToSaveRestore();
 
   // Find the regs killed by MI, and find regmasks of preserved regs.
   DefinedRegsSet DeadRegs;
   SmallVector<const uint32_t *, 4> RegMasks;
   for (const MachineOperand &MO : MI.operands()) {
     // Determine whether the operand is a register def.
     if (MO.isReg() && MO.isDef() && MO.getReg() &&
         Register::isPhysicalRegister(MO.getReg()) &&
         !(MI.isCall() && MO.getReg() == SP)) {
       // Remove ranges of all aliased registers.
       for (MCRegAliasIterator RAI(MO.getReg(), TRI, true); RAI.isValid(); ++RAI)
         // FIXME: Can we break out of this loop early if no insertion occurs?
         DeadRegs.insert(*RAI);
+      if (RegSetInstrs.find(MO.getReg()) != RegSetInstrs.end())
+        RegSetInstrs.erase(MO.getReg());
+      RegSetInstrs.insert({MO.getReg(), &MI});
     } else if (MO.isRegMask()) {
       RegMasks.push_back(MO.getRegMask());
     }
   }
 
   // Erase VarLocs which reside in one of the dead registers. For performance
   // reasons, it's critical to not iterate over the full set of open VarLocs.
   // Iterate over the set of dying/used regs instead.
for (Register Reg : UsedRegs) {
       if (Reg == SP)
         continue;
       bool AnyRegMaskKillsReg =
           any_of(RegMasks, [Reg](const uint32_t *RegMask) {
             return MachineOperand::clobbersPhysReg(RegMask, Reg);
           });
       if (AnyRegMaskKillsReg)
         DeadRegs.insert(Reg);
+      if (AnyRegMaskKillsReg) {
+        if (RegSetInstrs.find(Reg) != RegSetInstrs.end())
+          RegSetInstrs.erase(Reg);
+        RegSetInstrs.insert({Reg, &MI});
+      }
     }
   }
 
   if (DeadRegs.empty())
     return;
 
   VarLocsInRange KillSet;
   collectIDsForRegs(KillSet, DeadRegs, OpenRanges.getVarLocs(), VarLocIDs);
   OpenRanges.erase(KillSet, VarLocIDs, LocIndex::kUniversalLocation);
 
   if (TPC) {
     auto &TM = TPC->getTM<TargetMachine>();
     if (TM.Options.ShouldEmitDebugEntryValues())
-      emitEntryValues(MI, OpenRanges, VarLocIDs, Transfers, KillSet);
+      emitEntryValues(MI, OpenRanges, VarLocIDs, EntryValTransfers, KillSet);
   }
 }
 
 bool VarLocBasedLDV::isSpillInstruction(const MachineInstr &MI,
                                          MachineFunction *MF) {
   // TODO: Handle multiple stores folded into one.
   if (!MI.hasOneMemOperand())
     return false;
for (auto &ASeenFragment : AllSeenFragments) {
     }
   }
 
   AllSeenFragments.insert(ThisFragment);
 }
 
 /// This routine creates OpenRanges.
 void VarLocBasedLDV::process(MachineInstr &MI, OpenRangesSet &OpenRanges,
-                              VarLocMap &VarLocIDs, TransferMap &Transfers) {
-  transferDebugValue(MI, OpenRanges, VarLocIDs);
-  transferRegisterDef(MI, OpenRanges, VarLocIDs, Transfers);
+                             VarLocMap &VarLocIDs, TransferMap &Transfers,
+                             InstToEntryLocMap &EntryValTransfers,
+                             RegDefToInstMap &RegSetInstrs) {
+  if (!MI.isDebugInstr())
+    LastNonDbgMI = &MI;
+  transferDebugValue(MI, OpenRanges, VarLocIDs, EntryValTransfers,
+                     RegSetInstrs);
+  transferRegisterDef(MI, OpenRanges, VarLocIDs, EntryValTransfers,
+                      RegSetInstrs);
   transferRegisterCopy(MI, OpenRanges, VarLocIDs, Transfers);
   transferSpillOrRestoreInst(MI, OpenRanges, VarLocIDs, Transfers);
 }
 
 /// This routine joins the analysis results of all incoming edges in @MBB by
 /// inserting a new DBG_VALUE instruction at the start of the @MBB - if the same
 /// source variable in all the predecessors of @MBB reside in the same location.
 bool VarLocBasedLDV::join(
bool VarLocBasedLDV::ExtendRanges(MachineFunction &MF, TargetPassConfig *TPC,
   VarLocMap VarLocIDs;         // Map VarLoc<>unique ID for use in bitvectors.
   OverlapMap OverlapFragments; // Map of overlapping variable fragments.
   OpenRangesSet OpenRanges(Alloc, OverlapFragments);
                               // Ranges that are open until end of bb.
   VarLocInMBB OutLocs;        // Ranges that exist beyond bb.
   VarLocInMBB InLocs;         // Ranges that are incoming after joining.
   TransferMap Transfers;      // DBG_VALUEs associated with transfers (such as
                               // spills, copies and restores).
+  // Map responsible MI to attached Transfer emitted from Backup Entry Value.
+  InstToEntryLocMap EntryValTransfers;
+  // Map a Register to the last MI which clobbered it.
+  RegDefToInstMap RegSetInstrs;
 
   VarToFragments SeenFragments;
 
   // Blocks which are artificial, i.e. blocks which exclusively contain
   // instructions without locations, or with line 0 locations.
   SmallPtrSet<const MachineBasicBlock *, 16> ArtificialBlocks;
 
   DenseMap<unsigned int, MachineBasicBlock *> OrderToBB;
while (!Worklist.empty()) {
       if (MBBJoined) {
         MBBJoined = false;
         Changed = true;
         // Now that we have started to extend ranges across BBs we need to
         // examine spill, copy and restore instructions to see whether they
         // operate with registers that correspond to user variables.
         // First load any pending inlocs.
         OpenRanges.insertFromLocSet(getVarLocsInMBB(MBB, InLocs), VarLocIDs);
+        LastNonDbgMI = nullptr;
+        RegSetInstrs.clear();
         for (auto &MI : *MBB)
-          process(MI, OpenRanges, VarLocIDs, Transfers);
+          process(MI, OpenRanges, VarLocIDs, Transfers, EntryValTransfers,
+                  RegSetInstrs);
         OLChanged |= transferTerminator(MBB, OpenRanges, OutLocs, VarLocIDs);
 
         LLVM_DEBUG(printVarLocInMBB(MF, OutLocs, VarLocIDs,
                                     "OutLocs after propagating", dbgs()));
         LLVM_DEBUG(printVarLocInMBB(MF, InLocs, VarLocIDs,
                                     "InLocs after propagating", dbgs()));
 
         if (OLChanged) {
assert(!TR.TransferInst->isTerminator() &&
            "Cannot insert DBG_VALUE after terminator");
     MachineBasicBlock *MBB = TR.TransferInst->getParent();
     const VarLoc &VL = VarLocIDs[TR.LocationID];
     MachineInstr *MI = VL.BuildDbgValue(MF);
     MBB->insertAfterBundle(TR.TransferInst->getIterator(), MI);
   }
   Transfers.clear();
 
+  // Add DBG_VALUEs created using Backup Entry Value location.
+  for (auto &TR : EntryValTransfers) {
+    MachineInstr *TRInst = const_cast<MachineInstr *>(TR.first);
+    assert(!TRInst->isTerminator() &&
+           "Cannot insert DBG_VALUE after terminator");
+    MachineBasicBlock *MBB = TRInst->getParent();
+    const VarLoc &VL = VarLocIDs[TR.second];
+    MachineInstr *MI = VL.BuildDbgValue(MF);
+    MBB->insertAfterBundle(TRInst->getIterator(), MI);
+  }
+  EntryValTransfers.clear();
+
   // Deferred inlocs will not have had any DBG_VALUE insts created; do
   // that now.
   flushPendingLocs(InLocs, VarLocIDs);
 
   LLVM_DEBUG(printVarLocInMBB(MF, OutLocs, VarLocIDs, "Final OutLocs", dbgs()));
   LLVM_DEBUG(printVarLocInMBB(MF, InLocs, VarLocIDs, "Final InLocs", dbgs()));
   return Changed;
 }
 
 LDVImpl *
 llvm::makeVarLocBasedLiveDebugValues()
 {
   return new VarLocBasedLDV();
 }

llvm/test/DebugInfo/MIR/X86/backup-entry-values-usage.mir

+# RUN: llc -run-pass=livedebugvalues -emit-call-site-info -march=x86-64 -o - %s | FileCheck %s
+
+## Test from PR47628.
+## Compiled from source:
+##  extern void bar(int);
+##  extern int side_effect, value;
+##  int foo(int param) {
+##    side_effect = param;
+##    param = value;
+##    bar(param);
+##    return 0;
+##  }
+## Using command:
+## $ clang m.c -O1 -g -c -mllvm -stop-before=livedebugvalues
+
+## Confirm that Backup Entry Value is not used for modified parameter "param".
+
+# CHECK: ![[PARAM:.*]] = !DILocalVariable(name: "param"
+# CHECK: renamable $edi = MOV32rm $rip, 1, $noreg
+# CHECK-NOT: DBG_VALUE $edi, $noreg, ![[PARAM]], !DIExpression(DW_OP_LLVM_entry_value, 1)
+# CHECK-NEXT: DBG_VALUE $edi, $noreg, ![[PARAM]], !DIExpression()
+# CHECK-NEXT: CALL64pcrel32 @bar
+# CHECK-NOT: DBG_VALUE $edi, $noreg, ![[PARAM]], !DIExpression(DW_OP_LLVM_entry_value, 1)
+
+--- |
+  ; ModuleID = 'm.c'
+  source_filename = "m.c"
+  target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-unknown-linux-gnu"
+  
+  @side_effect = external dso_local local_unnamed_addr global i32, align 4
+  @value = external dso_local local_unnamed_addr global i32, align 4
+  
+  ; Function Attrs: nounwind uwtable
+  define dso_local i32 @foo(i32 %param) local_unnamed_addr !dbg !8 {
+  entry:
+    call void @llvm.dbg.value(metadata i32 %param, metadata !13, metadata !DIExpression()), !dbg !14
+    store i32 %param, i32* @side_effect, align 4, !dbg !15, !tbaa !16
+    %0 = load i32, i32* @value, align 4, !dbg !20, !tbaa !16
+    call void @llvm.dbg.value(metadata i32 %0, metadata !13, metadata !DIExpression()), !dbg !14
+    call void @bar(i32 %0), !dbg !21
+    ret i32 0, !dbg !22
+  }
+  
+  declare !dbg !23 dso_local void @bar(i32) local_unnamed_addr
+  
+  ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  !llvm.dbg.cu = !{!0}
+  !llvm.module.flags = !{!3, !4, !5, !6}
+  !llvm.ident = !{!7}
+  
+  !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 13.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+  !1 = !DIFile(filename: "m.c", directory: "/dir")
+  !2 = !{}
+  !3 = !{i32 7, !"Dwarf Version", i32 4}
+  !4 = !{i32 2, !"Debug Info Version", i32 3}
+  !5 = !{i32 1, !"wchar_size", i32 4}
+  !6 = !{i32 7, !"uwtable", i32 1}
+  !7 = !{!"clang version 13.0.0"}
+  !8 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !9 = !DISubroutineType(types: !10)
+  !10 = !{!11, !11}
+  !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+  !12 = !{!13}
+  !13 = !DILocalVariable(name: "param", arg: 1, scope: !8, file: !1, line: 4, type: !11)
+  !14 = !DILocation(line: 0, scope: !8)
+  !15 = !DILocation(line: 5, column: 17, scope: !8)
+  !16 = !{!17, !17, i64 0}
+  !17 = !{!"int", !18, i64 0}
+  !18 = !{!"omnipotent char", !19, i64 0}
+  !19 = !{!"Simple C/C++ TBAA"}
+  !20 = !DILocation(line: 6, column: 13, scope: !8)
+  !21 = !DILocation(line: 7, column: 5, scope: !8)
+  !22 = !DILocation(line: 8, column: 5, scope: !8)
+  !23 = !DISubprogram(name: "bar", scope: !1, file: !1, line: 1, type: !24, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+  !24 = !DISubroutineType(types: !25)
+  !25 = !{null, !11}
+
+...
+---
+name:            foo
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+callSites:
+  - { bb: 0, offset: 6, fwdArgRegs: 
+      - { arg: 0, reg: '$edi' } }
+body:             |
+  bb.0.entry:
+    liveins: $edi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(), debug-location !14
+    frame-setup PUSH64r undef $rax, implicit-def $rsp, implicit $rsp
+    CFI_INSTRUCTION def_cfa_offset 16
+    MOV32mr $rip, 1, $noreg, @side_effect, $noreg, killed renamable $edi, debug-location !15 :: (store 4 into @side_effect, !tbaa !16)
+    renamable $edi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20 :: (dereferenceable load 4 from @value, !tbaa !16)
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(), debug-location !14
+    CALL64pcrel32 @bar, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit-def $rsp, implicit-def $ssp, debug-location !21
+    $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
+    $rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
+    CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
+    RETQ killed $eax, debug-location !22
+
+...

llvm/test/DebugInfo/MIR/X86/dbgcall-site-reference.mir

body:             |
   bb.0.entry:
     liveins: $rdi
 
     DBG_VALUE $rdi, $noreg, !32, !DIExpression(), debug-location !35
     DBG_VALUE $rsi, $noreg, !34, !DIExpression(DW_OP_deref), debug-location !36
     frame-setup PUSH64r undef $rax, implicit-def $rsp, implicit $rsp
     CFI_INSTRUCTION def_cfa_offset 16
     $rsi = MOV64rr $rsp
-    DBG_VALUE $rdi, $noreg, !32, !DIExpression(), debug-location !35
     CALL64pcrel32 @_ZN1CC2E1B, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit $rsi, implicit-def $rsp, implicit-def $ssp, debug-location !36
     $rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !36
     CFI_INSTRUCTION def_cfa_offset 8, debug-location !36
     RETQ debug-location !36
 
 ...

llvm/test/DebugInfo/MIR/X86/entry-value-of-modified-param.mir

-# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
-# RUN: llc -force-instr-ref-livedebugvalues=1 -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s --check-prefixes=CHECK,VARLOCLDV
+# RUN: llc -force-instr-ref-livedebugvalues=1 -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s --check-prefixes=CHECK,INSTRREFLDV
 #
 #extern void fn1 (int, int, int);
 #
 #__attribute__((noinline))
 #int
 #fn2 (int a, int b, int c) {
 #  int q = 2 + a;
 #
 #  fn1 (5, 6, q);
 #
 #  b = b + 7;
 #  if (b < 17)
 #    return 1;
 #  else
 #    return 0;
 #}
 #
 # CHECK: ![[ARG_A:.*]] = !DILocalVariable(name: "a"
 # CHECK: ![[ARG_B:.*]] = !DILocalVariable(name: "b"
 # CHECK: ![[ARG_C:.*]] = !DILocalVariable(name: "c"
+## TODO: Support KILL instruction, which doesn't clobber parameter value.
+# VARLOCLDV: DBG_VALUE $edi, $noreg, ![[ARG_A]], !DIExpression()
 # CHECK: DBG_VALUE $edx, $noreg, ![[ARG_C]], !DIExpression(DW_OP_LLVM_entry_value, 1)
-# CHECK: DBG_VALUE $edi, $noreg, ![[ARG_A]], !DIExpression(DW_OP_LLVM_entry_value, 1)
+# VARLOCLDV-NOT: DBG_VALUE $edi, $noreg, ![[ARG_A]], !DIExpression(DW_OP_LLVM_entry_value, 1)
+# INSTRREFLDV: DBG_VALUE $edi, $noreg, ![[ARG_A]], !DIExpression(DW_OP_LLVM_entry_value, 1)
 # CHECK-NOT: DBG_VALUE $esi, $noreg, ![[ARG_B]], !DIExpression(DW_OP_LLVM_entry_value, 1)
 #
 --- |
   ; ModuleID = 'test.c'
   source_filename = "test.c"
   target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 

llvm/test/DebugInfo/MIR/X86/remove-entry-value-from-loop.mir

+# RUN: llc -emit-call-site-info -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+
+## Compiled from source:
+## __attribute__((noinline))
+## int foo (int x, int y, int a) {
+##   int i;
+##   for (i = 0; i < x * y; i++) {
+##     if (i < x) {
+##       a = a * x;
+##       break;
+##    }
+##   }
+##   return a;
+## }
+## Using commands:
+## $ clang -g -O1 test.c -emit-llvm -S -o test.ll
+## $ llc -emit-call-site-info -stop-after stackmap-liveness test.ll -o test.mir
+
+## Artificially added DBG_VALUE $esi, $noreg, !14, !DIExpression() into
+## for.cond Basic Block to prevent further usage of Entry Value in the loop.
+
+# CHECK: ![[ARG_Y:.*]] = !DILocalVariable(name: "y"
+# CHECK: for.cond:
+# CHECK: DBG_VALUE $esi, $noreg, ![[ARG_Y]], !DIExpression()
+# CHECK-NOT: DBG_VALUE $esi, $noreg, ![[ARG_Y]], !DIExpression(DW_OP_LLVM_entry_value, 1)
+--- |
+  ; ModuleID = 'test.ll'
+  source_filename = "test.c"
+  target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-unknown-linux-gnu"
+  
+  ; Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
+  define dso_local i32 @foo(i32 %x, i32 %y, i32 %a) local_unnamed_addr !dbg !8 {
+  entry:
+    call void @llvm.dbg.value(metadata i32 %x, metadata !13, metadata !DIExpression()), !dbg !17
+    call void @llvm.dbg.value(metadata i32 %y, metadata !14, metadata !DIExpression()), !dbg !17
+    call void @llvm.dbg.value(metadata i32 %a, metadata !15, metadata !DIExpression()), !dbg !17
+    call void @llvm.dbg.value(metadata i32 0, metadata !16, metadata !DIExpression()), !dbg !17
+    %mul = mul nsw i32 %y, %x
+    call void @llvm.dbg.value(metadata i32 0, metadata !16, metadata !DIExpression()), !dbg !17
+    %cmp9 = icmp sgt i32 %mul, 0, !dbg !18
+    br i1 %cmp9, label %for.body.preheader, label %for.end, !dbg !21
+  
+  for.body.preheader:                               ; preds = %entry
+    %0 = mul i32 %y, %x, !dbg !21
+    br label %for.body, !dbg !21
+  
+  for.cond:                                         ; preds = %for.body
+    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !17
+    %lsr.iv.next = add i32 %lsr.iv, -1, !dbg !18
+    %exitcond.not = icmp eq i32 %lsr.iv.next, 0, !dbg !18
+    br i1 %exitcond.not, label %for.end, label %for.body, !dbg !21, !llvm.loop !22
+  
+  for.body:                                         ; preds = %for.cond, %for.body.preheader
+    %lsr.iv = phi i32 [ %lsr.iv.next, %for.cond ], [ %0, %for.body.preheader ]
+    %1 = icmp sgt i32 %x, 0
+    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !17
+    call void @llvm.dbg.value(metadata i32 undef, metadata !16, metadata !DIExpression()), !dbg !17
+    br i1 %1, label %if.then, label %for.cond, !dbg !26
+  
+  if.then:                                          ; preds = %for.body
+    %mul2 = mul nsw i32 %a, %x, !dbg !28
+    call void @llvm.dbg.value(metadata i32 %mul2, metadata !15, metadata !DIExpression()), !dbg !17
+    br label %for.end, !dbg !31
+  
+  for.end:                                          ; preds = %for.cond, %if.then, %entry
+    %a.addr.0 = phi i32 [ %mul2, %if.then ], [ %a, %entry ], [ %a, %for.cond ]
+    call void @llvm.dbg.value(metadata i32 %a.addr.0, metadata !15, metadata !DIExpression()), !dbg !17
+    ret i32 %a.addr.0, !dbg !32
+  }
+  
+  ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+  !llvm.dbg.cu = !{!0}
+  !llvm.module.flags = !{!3, !4, !5, !6}
+  !llvm.ident = !{!7}
+  
+  !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 13.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+  !1 = !DIFile(filename: "test.c", directory: "/dir")
+  !2 = !{}
+  !3 = !{i32 7, !"Dwarf Version", i32 4}
+  !4 = !{i32 2, !"Debug Info Version", i32 3}
+  !5 = !{i32 1, !"wchar_size", i32 4}
+  !6 = !{i32 7, !"uwtable", i32 1}
+  !7 = !{!"clang version 13.0.0"}
+  !8 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 2, type: !9, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !9 = !DISubroutineType(types: !10)
+  !10 = !{!11, !11, !11, !11}
+  !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+  !12 = !{!13, !14, !15, !16}
+  !13 = !DILocalVariable(name: "x", arg: 1, scope: !8, file: !1, line: 2, type: !11)
+  !14 = !DILocalVariable(name: "y", arg: 2, scope: !8, file: !1, line: 2, type: !11)
+  !15 = !DILocalVariable(name: "a", arg: 3, scope: !8, file: !1, line: 2, type: !11)
+  !16 = !DILocalVariable(name: "i", scope: !8, file: !1, line: 3, type: !11)
+  !17 = !DILocation(line: 0, scope: !8)
+  !18 = !DILocation(line: 4, column: 17, scope: !19)
+  !19 = distinct !DILexicalBlock(scope: !20, file: !1, line: 4, column: 3)
+  !20 = distinct !DILexicalBlock(scope: !8, file: !1, line: 4, column: 3)
+  !21 = !DILocation(line: 4, column: 3, scope: !20)
+  !22 = distinct !{!22, !21, !23, !24, !25}
+  !23 = !DILocation(line: 9, column: 3, scope: !20)
+  !24 = !{!"llvm.loop.mustprogress"}
+  !25 = !{!"llvm.loop.unroll.disable"}
+  !26 = !DILocation(line: 5, column: 9, scope: !27)
+  !27 = distinct !DILexicalBlock(scope: !19, file: !1, line: 4, column: 31)
+  !28 = !DILocation(line: 6, column: 13, scope: !29)
+  !29 = distinct !DILexicalBlock(scope: !30, file: !1, line: 5, column: 16)
+  !30 = distinct !DILexicalBlock(scope: !27, file: !1, line: 5, column: 9)
+  !31 = !DILocation(line: 7, column: 7, scope: !29)
+  !32 = !DILocation(line: 10, column: 3, scope: !8)
+
+...
+---
+name:            foo
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+  - { reg: '$esi', virtual-reg: '' }
+  - { reg: '$edx', virtual-reg: '' }
+body:             |
+  bb.0.entry:
+    successors: %bb.2(0x50000000), %bb.4(0x30000000)
+    liveins: $edi, $edx, $esi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(), debug-location !17
+    DBG_VALUE $esi, $noreg, !14, !DIExpression(), debug-location !17
+    DBG_VALUE $edx, $noreg, !15, !DIExpression(), debug-location !17
+    $eax = MOV32rr $edx
+    DBG_VALUE 0, $noreg, !16, !DIExpression(), debug-location !17
+    DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
+    renamable $esi = nsw IMUL32rr killed renamable $esi, renamable $edi, implicit-def dead $eflags
+    TEST32rr renamable $esi, renamable $esi, implicit-def $eflags, debug-location !18
+    JCC_1 %bb.4, 14, implicit $eflags, debug-location !21
+  
+  bb.2.for.body (align 16):
+    successors: %bb.3(0x04000000), %bb.1(0x7c000000)
+    liveins: $eax, $edi, $esi
+  
+    TEST32rr renamable $edi, renamable $edi, implicit-def $eflags
+    DBG_VALUE $noreg, $noreg, !16, !DIExpression(), debug-location !17
+    JCC_1 %bb.3, 15, implicit $eflags, debug-location !26
+  
+  bb.1.for.cond:
+    successors: %bb.4(0x04000000), %bb.2(0x7c000000)
+    liveins: $eax, $edi, $esi
+  
+    DBG_VALUE $esi, $noreg, !14, !DIExpression(), debug-location !17
+    DBG_VALUE $noreg, $noreg, !16, !DIExpression(), debug-location !17
+    renamable $esi = ADD32ri8 killed renamable $esi, -1, implicit-def $eflags, debug-location !18
+    JCC_1 %bb.2, 5, implicit $eflags, debug-location !21
+  
+  bb.4.for.end:
+    liveins: $eax
+  
+    DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
+    RETQ $eax, debug-location !32
+  
+  bb.3.if.then:
+    liveins: $eax, $edi
+  
+    renamable $eax = nsw IMUL32rr killed renamable $eax, killed renamable $edi, implicit-def dead $eflags, debug-location !28
+    DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
+    DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
+    RETQ $eax, debug-location !32
+
+...