[2/2][RemoveRedundantDebugValues] Introduce a MIR pass that removes redundant DBG_VALUEs

[djtodoro]

Summary

This patch adds the forward scan for finding redundant DBG_VALUEs.

This analysis aims to remove redundant DBG_VALUEs by going forward
in the basic block by considering the first DBG_VALUE as a valid
until its first (location) operand is not clobbered/modified.
For example:

(1) DBG_VALUE $edi, !"var1", ...
(2) <block of code that does affect $edi>
(3) DBG_VALUE $edi, !"var1", ...
 ...

in this case, we can remove (3).

[Orlando]

Hi @djtodoro, thank you for implementing this! I've left some inline comments.

I wonder if it would it be worth getting an llvm-locstats comparison on a codebase built with and without this patch-set to get confidence that it is a NFC?

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

96–97

I think you need to pass None as the second argument to the DebugVariable ctor (i.e. using the overload that takes an Optional<FragmentInfo>).

Otherwise this function may remove a DBG_VALUE for a variable fragment that overlaps with the fragment of a preceding DBG_VALUE because their FragmentInfo doesn't match. This would result in incorrect debugging information.

In the example below, reduceDbgValsForwardScan will currently (wrongly) remove DBG_VALUE 3 because 1 and 3 have the same variable location, and DBG_VALUE 2 has a different fragment so it is not found in the VariableMap lookup. This causes an inaccuracy, because DBG_VALUE 2 implicitly describes a new variable location for the fragment {0, 32} which means that DBG_VALUE 3 is not actually redundant.

1  DBG_VALUE $rax, "x", DIExpression(DW_OP_fragment, 0, 32)
   ...
2  DBG_VALUE $rdi, "x", DIExpression()
   ...
3  DBG_VALUE $rax, "x", DIExpression(DW_OP_fragment, 0, 32)

Using None for the Optional<FragmentInfo> means that the lookup will succeed for a {variable, inlined-at} pair regardless of the fragment. The downside is that this approach is slightly over-conservative; a DBG_VALUE may end up "blocking" the valid removal of a subsequent DBG_VALUE for the same variable with a non-overlapping fragment. But this is better than introducing inaccurate debug info IMO. Making this change would then match how
removeRedundantDbgInstrsUsingForwardScan in D71478 is implemented. Note that, as in D71478, you only need to do this in the forward scan.

115–117

nit/suggestion: I think this comment could be more concise, maybe something like: "Stop tracking any locations that are clobbered by this instruction."

[djtodoro]

In D105280#2853116, @Orlando wrote:

Hi @djtodoro, thank you for implementing this! I've left some inline comments.

I wonder if it would it be worth getting an llvm-locstats comparison on a codebase built with and without this patch-set to get confidence that it is a NFC?

Thanks for your comments!
Actually, the llvm-locstats numbers will improve, since this fixes MIR, and LiveDebugValues will generate more entry-values for example, since the analysis generates entry-values for unmodified parameters, but with these duplicates, we have had a lot of false positives with the respect to param's changing (the pass considered a new/redundant DBG_VALUE as an assignment). I'll share the locstats numbers anyway.

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

96–97

Nice catch! Thanks!

[Orlando]

In D105280#2853197, @djtodoro wrote:

Actually, the llvm-locstats numbers will improve, since this fixes MIR, and LiveDebugValues will generate more entry-values for example, since the analysis generates entry-values for unmodified parameters, but with these duplicates, we have had a lot of false positives with the respect to param's changing (the pass considered a new/redundant DBG_VALUE as an assignment). I'll share the locstats numbers anyway.

Ah okay that makes sense. Thanks, I'd be interested to see those numbers.

Is the coverage boost expected to come from only entry-values then? If that's the case you could try a before/after comparison with entry-values disabled to check the NFC-ness (but it's not a requirement - up to you).

[djtodoro]

-addressing comments

[djtodoro]

llvm-locstats numbers (on the gdb-7.11 binary compiled with -g -O2)

$ llvm-locstats ./gdb-before-the-patch
 =================================================
            Debug Location Statistics
 =================================================
     cov%           samples         percentage(~)
 -------------------------------------------------
    0%                 2517                2%
   (0%,10%)           5849                5%
   [10%,20%)          4992                4%
   [20%,30%)          4886                4%
   [30%,40%)          4468                4%
   [40%,50%)          4127                4%
   [50%,60%)          4535                4%
   [60%,70%)          4670                4%
   [70%,80%)          5529                5%
   [80%,90%)          6257                6%
   [90%,100%)        10197                9%
   100%              44979               43%
 =================================================
 -the number of debug variables processed: 103006
 -PC ranges covered: 57%
 -------------------------------------------------
 -total availability: 86%
 =================================================


bash-4.2$ ../../build/bin/llvm-locstats --ignore-debug-entry-values ./gdb-before-the-patch
 =================================================
            Debug Location Statistics
 =================================================
     cov%           samples         percentage(~)
 -------------------------------------------------
   0%                 2517                2%
   (0%,10%)           6898                6%
   [10%,20%)          6008                5%
   [20%,30%)          5870                5%
   [30%,40%)          5347                5%
   [40%,50%)          4971                4%
   [50%,60%)          5316                5%
   [60%,70%)          5241                5%
   [70%,80%)          6147                5%
   [80%,90%)          6826                6%
   [90%,100%)        12995               12%
   100%              34870               33%
 =================================================
 -the number of debug variables processed: 103006
 -PC ranges covered: 54%
 -------------------------------------------------
 -total availability: 86%
 =================================================

$ llvm-locstats ./gdb-after-the-patch
 =================================================
            Debug Location Statistics
 =================================================
     cov%           samples         percentage(~)
 -------------------------------------------------
   0%                 2517                2%
   (0%,10%)           5847                5%
   [10%,20%)          4991                4%
   [20%,30%)          4887                4%
   [30%,40%)          4470                4%
   [40%,50%)          4126                4%
   [50%,60%)          4535                4%
   [60%,70%)          4667                4%
   [70%,80%)          5528                5%
   [80%,90%)          6258                6%
   [90%,100%)        10176                9%
   100%              45004               43%
 =================================================
 -the number of debug variables processed: 103006
 -PC ranges covered: 57%
 -------------------------------------------------
 -total availability: 86%
 =================================================

$ llvm-locstats --ignore-debug-entry-values ./gdb-after-the-patch
 =================================================
            Debug Location Statistics
 =================================================
     cov%           samples         percentage(~)
 -------------------------------------------------
   0%                 2517                2%
   (0%,10%)           6897                6%
   [10%,20%)          6009                5%
   [20%,30%)          5869                5%
   [30%,40%)          5350                5%
   [40%,50%)          4969                4%
   [50%,60%)          5317                5%
   [60%,70%)          5239                5%
   [70%,80%)          6147                5%
   [80%,90%)          6827                6%
   [90%,100%)        12995               12%
   100%              34870               33%
 =================================================
 -the number of debug variables processed: 103006
 -PC ranges covered: 54%
 -------------------------------------------------
 -total availability: 86%
 =================================================

[Orlando]

Thank you for sharing the stats, they look great (both for NFC-ness and with entry-values)! There is an absolutely miniscule shift in numbers in the middle buckets in the non-entry-value case (NFC), but this is to be expected and acceptable imo.

LGTM - Same as for D105279 I'll give others a chance to comment before hitting Accept.

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

96–97

Please can you add a test for this too? Sorry - I should've asked for this in my first comment.

[djtodoro]

• addressing comments

[StephenTozer]

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

91

In order to make this compatible with DBG_VALUE_LIST, it would probably be best to add a check: if MI.isListDebugValue(), then terminate any existing VariableMap entry for Var. This should ensure that we don't incorrectly attempt to handle DBG_VALUE_LISTs by considering only their first debug operand, or ignore them entirely and potentially incorrectly remove identical DBG_VALUEs that have a DBG_VALUE_LIST for the same variable between them.

[djtodoro]

• adding TODO marker for DBG_VALUE_LIST for the forward scan only

[StephenTozer]

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

116

I may be missing something; is there a need for this to be lambda, since it looks like it's only invoked here?

[djtodoro]

• remove the lambda since it is not needed

[StephenTozer]

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

112

This LGTM with this edit, unless I've made a mistake in believing it necessary. I believe this will be necessary to prevent incorrect debug info from being caused in the following case:

1  DBG_VALUE $rax, "x", DIExpression()
   ...
2  DBG_VALUE_LIST "x", DIExpression(...), $rax, $rbx
   ...
3  DBG_VALUE $rax, "x", DIExpression()

Currently we would ignore the DBG_VALUE_LIST entirely, and so 3 would falsely appear to be redundant due to being a repeat of 1. Killing any existing mapping for the variable of a DBG_VALUE_LIST is the simplest way to ensure this doesn't happen, without needing a full implementation for list debug values.

[Orlando]

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

112

FWIW I agree with @StephenTozer and just wanted to add: please can you add a test for this too when you update the code?

[djtodoro]

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

112

Sure! Thanks! Good catch!

In addition, we should stop tracking a variable in this case as well (if VMI != VariableMap.end()):

if (!Loc.isReg())
  continue

I'll make tests for this before updating the patch.

[djtodoro]

• handle DBG_VALUE_LIST + test

[StephenTozer]

Latest revision LGTM.

[djtodoro]

@StephenTozer Thanks!

• in this revision, I am just fixing a comment in the test

[djtodoro]

• posting a right patch

[djtodoro]

• rebase

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

 //===- RemoveRedundantDebugValues.cpp - Remove Redundant Debug Value MIs --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Function.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 
 /// \file RemoveRedundantDebugValues.cpp
 ///
 /// The RemoveRedundantDebugValues pass removes redundant DBG_VALUEs that
 /// appear in MIR after the register allocator.
 
 #define DEBUG_TYPE "removeredundantdebugvalues"
 
 using namespace llvm;
 
 STATISTIC(NumRemovedBackward, "Number of DBG_VALUEs removed (backward scan)");
+STATISTIC(NumRemovedForward, "Number of DBG_VALUEs removed (forward scan)");
 
 namespace {
 
 class RemoveRedundantDebugValues : public MachineFunctionPass {
 public:
   static char ID;
 
   RemoveRedundantDebugValues();
INITIALIZE_PASS(RemoveRedundantDebugValues, DEBUG_TYPE,
                 "Remove Redundant DEBUG_VALUE analysis", false, false)
 
 /// Default construct and initialize the pass.
 RemoveRedundantDebugValues::RemoveRedundantDebugValues()
     : MachineFunctionPass(ID) {
   initializeRemoveRedundantDebugValuesPass(*PassRegistry::getPassRegistry());
 }
 
+// This analysis aims to remove redundant DBG_VALUEs by going forward
+// in the basic block by considering the first DBG_VALUE as a valid
+// until its first (location) operand is not clobbered/modified.
+// For example:
+//   (1) DBG_VALUE $edi, !"var1", ...
+//   (2) <block of code that does affect $edi>
+//   (3) DBG_VALUE $edi, !"var1", ...
+//   ...
+// in this case, we can remove (3).
+// TODO: Support DBG_VALUE_LIST and other debug instructions.
+static bool reduceDbgValsForwardScan(MachineBasicBlock &MBB) {
+  LLVM_DEBUG(dbgs() << "\n == Forward Scan == \n");
+
+  SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
+  DenseMap<DebugVariable, std::pair<MachineOperand *, const DIExpression *>>
+      VariableMap;
+  const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
+
+  for (auto &MI : MBB) {
+    if (MI.isDebugValue()) {
+      DebugVariable Var(MI.getDebugVariable(), NoneType(),
+                        MI.getDebugLoc()->getInlinedAt());
+      auto VMI = VariableMap.find(Var);
+      // Just stop tracking this variable, until we cover DBG_VALUE_LIST.
+      // 1  DBG_VALUE $rax, "x", DIExpression()
+      // ...
+      // 2  DBG_VALUE_LIST "x", DIExpression(...), $rax, $rbx
+      // ...
+      // 3  DBG_VALUE $rax, "x", DIExpression()
+      if (MI.isDebugValueList() && VMI != VariableMap.end()) {
+        VariableMap.erase(VMI);
+        continue;
+      }
+
+      MachineOperand &Loc = MI.getDebugOperand(0);
+      if (!Loc.isReg()) {
+        // If it it's not a register, just stop tracking such variable.
+        if (VMI != VariableMap.end())
+          VariableMap.erase(VMI);
+        continue;
+      }
+
+      // We have found a new value for a variable.
+      if (VMI == VariableMap.end() ||
+          VMI->second.first->getReg() != Loc.getReg() ||
+          VMI->second.second != MI.getDebugExpression()) {
+        VariableMap[Var] = {&Loc, MI.getDebugExpression()};
+        continue;
+      }
+
+      // Found an identical DBG_VALUE, so it can be considered
+      // for later removal.
+      DbgValsToBeRemoved.push_back(&MI);
+    }
+
+    if (MI.isMetaInstruction())
+      continue;
+
+    // Stop tracking any location that is clobbered by this instruction.
+    for (auto &Var : VariableMap) {
+      auto &LocOp = Var.second.first;
+      if (MI.modifiesRegister(LocOp->getReg(), TRI))
+        VariableMap.erase(Var.first);
+    }
+  }
+
+  for (auto &Instr : DbgValsToBeRemoved) {
+    LLVM_DEBUG(dbgs() << "removing "; Instr->dump());
+    Instr->eraseFromParent();
+    ++NumRemovedForward;
+  }
+
+  return !DbgValsToBeRemoved.empty();
+}
+
 // This analysis aims to remove redundant DBG_VALUEs by going backward
 // in the basic block and removing all but the last DBG_VALUE for any
 // given variable in a set of consecutive DBG_VALUE instructions.
 // For example:
 //   (1) DBG_VALUE $edi, !"var1", ...
 //   (2) DBG_VALUE $esi, !"var2", ...
 //   (3) DBG_VALUE $edi, !"var1", ...
 //   ...
static bool reduceDbgValsBackwardScan(MachineBasicBlock &MBB) {
   return !DbgValsToBeRemoved.empty();
 }
 
 bool RemoveRedundantDebugValues::reduceDbgValues(MachineFunction &MF) {
   LLVM_DEBUG(dbgs() << "\nDebug Value Reduction\n");
 
   bool Changed = false;
 
-  for (auto &MBB : MF)
+  for (auto &MBB : MF) {
     Changed |= reduceDbgValsBackwardScan(MBB);
+    Changed |= reduceDbgValsForwardScan(MBB);
+  }
 
   return Changed;
 }
 
 bool RemoveRedundantDebugValues::runOnMachineFunction(MachineFunction &MF) {
   // Skip functions without debugging information.
   if (!MF.getFunction().getSubprogram())
     return false;

llvm/test/CodeGen/PowerPC/non-debug-mi-search-frspxsrsp.ll

 ; CHECK-NEXT:          .loc    1 0 45
 ; CHECK-NEXT:          xxlxor 2, 2, 2
 ; CHECK-NEXT:          .loc    1 3 26 is_stmt 1
 ; CHECK-NEXT:          xxmrghd 0, 0, 2
 ; CHECK-NEXT:          xxmrghd 1, 2, 1
 ; CHECK-NEXT:          xvcvdpsp 34, 0
 ; CHECK-NEXT:          xvcvdpsp 35, 1
 ; CHECK-NEXT:          vmrgew 2, 2, 3
-; CHECK-NEXT:          #DEBUG_VALUE: test:Vptr <- $x4
 ; CHECK-NEXT:          .loc    1 3 9 is_stmt 0
 ; CHECK-NEXT:          stvx 2, 0, 4
 ; CHECK-NEXT:          .loc    1 4 1 is_stmt 1
 ; CHECK-NEXT:          blr
 entry:
   call void @llvm.dbg.value(metadata float* %Fptr, metadata !19, metadata !DIExpression()), !dbg !22
   call void @llvm.dbg.value(metadata <4 x float>* %Vptr, metadata !20, metadata !DIExpression()), !dbg !22
   %0 = load float, float* %Fptr, align 4, !dbg !23, !tbaa !24

llvm/test/DebugInfo/MIR/X86/remove-redundant-dbg-vals.mir

-# RUN: llc %s -o - -run-pass=removeredundantdebugvalues | FileCheck %s
+# RUN: llc %s -o - -run-pass=removeredundantdebugvalues | FileCheck --implicit-check-not=DBG_VALUE %s
 
 ## This checks that the RemoveRedundantDebugValues removes redundant
-## DBG_VALUEs.
+## DBG_VALUEs. The MIR was hand-written, and foo{[2-6]}() are just
+## copies of foo(), with an extra instruction that modifies the $edi register
+## and extra (artificial) DBG_VALUE and DBG_VALUE_LIST instructions.
 
 # CHECK-LABEL: foo
 # CHECK-LABEL: bb.0.entry:
 # CHECK:      DBG_VALUE $edi
 # CHECK-NOT:  DBG_VALUE $edi
 # CHECK:      frame-setup PUSH64r
+# CHECK:      MOV32mr $rip, 1, $noreg
+# CHECK-NOT:  DBG_VALUE $edi
 
 # CHECK-LABEL: foo6
 # CHECK-LABEL: bb.0.entry:
 # CHECK:      DBG_VALUE 0
 # CHECK:      DBG_VALUE 1
 # CHECK:      frame-setup PUSH64r
 
+# CHECK-LABEL: foo2
+# CHECK-LABEL: bb.0.entry:
+# CHECK:  DBG_VALUE $edi
+# CHECK:  MOV32mr $rip, 1, $noreg
+# CHECK:  DBG_VALUE $edi
+
+# CHECK-LABEL: foo3
+# CHECK-LABEL: bb.0.entry:
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+# CHECK:  DBG_VALUE $esi, {{.*}}, !DIExpression()
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+
+# CHECK-LABEL: foo4
+# CHECK-LABEL: bb.0.entry:
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+# CHECK:  DBG_VALUE_LIST !{{.*}}
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+
+# CHECK-LABEL: foo5
+# CHECK-LABEL: bb.0.entry:
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+# CHECK:  DBG_VALUE 0, {{.*}}, !DIExpression()
+# CHECK:  DBG_VALUE $edi, {{.*}}, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+
 --- |
   ; 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"
   
   @side_effect = external dso_local local_unnamed_addr global i32, align 4
   @value = external dso_local local_unnamed_addr global i32, align 4
--- |
   define dso_local i32 @foo6(i32 %param) local_unnamed_addr !dbg !34 {
   entry:
     store i32 %param, i32* @side_effect, align 4, !dbg !35
     %0 = load i32, i32* @value, align 4, !dbg !35
     tail call void @bar(i32 %0), !dbg !35
     ret i32 0, !dbg !35
   }
 
+  ; Function Attrs: nounwind uwtable
+  define dso_local i32 @foo2(i32 %param) local_unnamed_addr !dbg !26 {
+  entry:
+    store i32 %param, i32* @side_effect, align 4, !dbg !27
+    %0 = load i32, i32* @value, align 4, !dbg !27
+    tail call void @bar(i32 %0), !dbg !27
+    ret i32 0, !dbg !27
+  }
+
+  ; Function Attrs: nounwind uwtable
+  define dso_local i32 @foo3(i32 %param) local_unnamed_addr !dbg !28 {
+  entry:
+    store i32 %param, i32* @side_effect, align 4, !dbg !29
+    %0 = load i32, i32* @value, align 4, !dbg !29
+    tail call void @bar(i32 %0), !dbg !29
+    ret i32 0, !dbg !29
+  }
+
+  ; Function Attrs: nounwind uwtable
+  define dso_local i32 @foo4(i32 %param) local_unnamed_addr !dbg !30 {
+  entry:
+    store i32 %param, i32* @side_effect, align 4, !dbg !31
+    %0 = load i32, i32* @value, align 4, !dbg !31
+    tail call void @bar(i32 %0), !dbg !31
+    ret i32 0, !dbg !31
+  }
+
+  ; Function Attrs: nounwind uwtable
+  define dso_local i32 @foo5(i32 %param) local_unnamed_addr !dbg !32 {
+  entry:
+    store i32 %param, i32* @side_effect, align 4, !dbg !33
+    %0 = load i32, i32* @value, align 4, !dbg !33
+    tail call void @bar(i32 %0), !dbg !33
+    ret i32 0, !dbg !33
+  }
+
   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}
--- |
   !14 = !DILocation(line: 0, scope: !8)
   !15 = !DILocation(line: 5, column: 17, scope: !8)
   !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}
+  !26 = distinct !DISubprogram(name: "foo2", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !27 = !DILocation(line: 0, scope: !26)
+  !28 = distinct !DISubprogram(name: "foo3", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !29 = !DILocation(line: 0, scope: !28)
+  !30 = distinct !DISubprogram(name: "foo4", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !31 = !DILocation(line: 0, scope: !30)
+  !32 = distinct !DISubprogram(name: "foo5", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+  !33 = !DILocation(line: 0, scope: !32)
   !34 = distinct !DISubprogram(name: "foo6", scope: !1, file: !1, line: 4, type: !9, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
   !35 = !DILocation(line: 0, scope: !34)
 
 ...
 ---
 name:            foo
 alignment:       16
 liveins:
bb.0.entry:
     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
 
 ...
 ---
+name:            foo2
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+body:             |
+  bb.0.entry:
+    liveins: $edi, $esi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(), debug-location !14
+    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 $esi, debug-location !15 :: (store 4 into @side_effect)
+    renamable $edi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20 :: (dereferenceable load 4 from @value)
+    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
+
+...
+---
+name:            foo3
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+body:             |
+  bb.0.entry:
+    liveins: $edi, $esi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), 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 $esi, debug-location !15 :: (store 4 into @side_effect)
+    renamable $esi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20 :: (dereferenceable load 4 from @value)
+    DBG_VALUE $esi, $noreg, !13, !DIExpression(), debug-location !14
+    $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
+    $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
+
+...
+---
+name:            foo4
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+body:             |
+  bb.0.entry:
+    liveins: $edi, $esi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), 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 $esi, debug-location !15 :: (store 4 into @side_effect)
+    renamable $esi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20 :: (dereferenceable load 4 from @value)
+    DBG_VALUE_LIST !13, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_stack_value), $edi, $esi, debug-location !14
+    $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
+    $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
+
+...
+---
+name:            foo5
+alignment:       16
+liveins:
+  - { reg: '$edi', virtual-reg: '' }
+body:             |
+  bb.0.entry:
+    liveins: $edi, $esi
+  
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), 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 $esi, debug-location !15 :: (store 4 into @side_effect)
+    renamable $esi = MOV32rm $rip, 1, $noreg, @value, $noreg, debug-location !20 :: (dereferenceable load 4 from @value)
+    DBG_VALUE 0, $noreg, !13, !DIExpression(), debug-location !14
+    $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
+    DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
+    $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
+
+...
+---
 name:            foo6
 alignment:       16
 liveins:
   - { reg: '$edi', virtual-reg: '' }
 body:             |
   bb.0.entry:
     liveins: $edi, $esi