[DebugInfo] Discard invalid DBG_VALUE instructions in LiveDebugVariables

[bjope]

Summary

This is a workaround for pr36417
https://bugs.llvm.org/show_bug.cgi?id=36417

LiveDebugVariables will now verify that the DBG_VALUE instructions
are sane (prior to register allocation) by asking LIS if a virtual
register used in the DBG_VALUE is live (or dead def) in the slot
index before the DBG_VALUE. If it isn't sane the DBG_VALUE is
discarded.

One pass that was identified as introducing non-sane DBG_VALUE
instructtons, when analysing pr36417, was the DAG->DAG Instruction
Selection. It sometimes inserts DBG_VALUE instructions referring to
a virtual register that is defined later in the same basic block.
So it is a use before def kind of problem. The DBG_VALUE is
typically inserted in the beginning of a basic block when this
happens. The problem can be seen in the test case
test/DebugInfo/X86/dbg-value-inlined-parameter.ll

Change-Id: Ia55df65fbfb6d3bc561df4c1e27fd36d0e61e505

[aprantl]

Thanks! Two comments:

• How are these invalid DBG_VALUEs generated? Are they happening during or after instruction selection? If they are introduced earlier by IR passes, it would be better to catch them in the Verifier and fix the bugs in the passes instead.

• Dropping invalid DBG_VALUE instructions is not correct. What you want to do is insert a DBG_VALUE undef, .... For example:

    ; int x = 0;
    ; ...
    ; x = foo();
    ; ... // x is never used, but not necessarily zero

-->

    DBG_VALUE, 0, "x"
    ... 
    DBG_VALUE, noreg, "x"
    ...
    // if you delete the second DBG_VALUE, then "x" will be represented as still being constant 0 here. Inserting a DBG_VALUE undef will correctly terminate the live range of the constant above.

[bjope]

What I see now in test/DebugInfo/X86/dbg-value-inlined-parameter.ll

Input to ISel is OK as far as I can see:

define void @foobar() #0 !dbg !28 {
entry:
  tail call void @llvm.dbg.value(metadata %struct.S1* @p, metadata !19, metadata !DIExpression()) #3, !dbg !31
  tail call void @llvm.dbg.value(metadata i32 1, metadata !21, metadata !DIExpression()) #3, !dbg !34
  store i32 1, i32* getelementptr inbounds (%struct.S1, %struct.S1* @p, i64 0, i32 1), align 8, !dbg !35
  %call.i = tail call float* @bar(i32 1) #4, !dbg !36
  store float* %call.i, float** getelementptr inbounds (%struct.S1, %struct.S1* @p, i64 0, i32 0), align 8, !dbg !36
  ret void, !dbg !37
}

but then after ISel we get

*** MachineFunction at end of ISel ***
# Machine code for function foobar: IsSSA, TracksLiveness

bb.0.entry:
  DBG_VALUE 1, debug-use $noreg, !"nums", !DIExpression(), debug-location !34; line no:7
  DBG_VALUE debug-use %0:gr64, debug-use $noreg, !"sp", !DIExpression(), debug-location !31; line no:7
  %0:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @p, $noreg, debug-location !35; mem:LD8[GOT]
  MOV32mi %0:gr64, 1, $noreg, 8, $noreg, 1, debug-location !35; mem:ST4[getelementptr inbounds (%struct.S1, %struct.S1* @p, i64 0, i32 1)](align=8)
  ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp, debug-location !36
  %1:gr32 = MOV32ri 1, debug-location !35
  $edi = COPY %1:gr32, debug-location !36
  CALL64pcrel32 @bar, <regmask $bh $bl $bp $bpl $bx $ebp $ebx $rbp $rbx $r12 $r13 $r14 $r15 $r12b $r13b $r14b $r15b $r12d $r13d $r14d $r15d $r12w $r13w $r14w $r15w>, implicit $rsp, implicit $ssp, implic
it $edi, implicit-def $rsp, implicit-def $ssp, implicit-def $rax, debug-location !36
  ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp, debug-location !36
  %2:gr64 = COPY $rax, debug-location !36
  MOV64mr %0:gr64, 1, $noreg, 0, $noreg, %2:gr64, debug-location !36; mem:ST8[getelementptr inbounds (%struct.S1, %struct.S1* @p, i64 0, i32 0)]
  RET 0, debug-location !37

So for some reason the

DBG_VALUE debug-use %0:gr64

ends up before

%0:gr64 = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @p, $noreg, debug-location !35; mem:LD8[GOT]

As far as I can see this is a ISel problem. I haven't tracked down exactly how this happens.

Historical debugging

I was actually hunting similar problems to this, with ISel inserting DBG_VALUE in the wrong location, a few months ago (unfortunately haven't had time to finalize the work...).
If I remember correctly there are some problems in ScheduleDAGSDNodes.cpp (methods ScheduleDAGSDNodes::EmitSchedule, ProcessSourceNode, ProcessSDDbgValues).

For example ProcessSourceNode is selecting between three different choices:
a) process SDDbgValue even if the node does not have any order (use IROrder 0)
b) save it in Orders and associate with nullptr
c) save it in Orders and associate with prev, and process SDDbgValue (using given IROrder)

I think the conditions for the (b) choice could cause problems sometimes, as it looks for PHI-nodes, but does not take any already inserted DBG_VALUES into consideration (it should skip past debug values somehow).
And I think processing the SDDbgValue also in situation (b) could improve things.

The ProcessSDDbgValues is having a condition like this

if (!Order || DVOrder == Order)

but we could get there also with DVOrder < Order (don't remember the exact situation, but I suspected that

if (!Order || DVOrder <= Order)

would be better.

I think that some of the problems might originate from situations where SelectionDAGBuilder::visitIntrinsicCall creates DanglingDebugInfo and then the IROrder is weird or missing (don't remember exactly).

Summary

Code like the one in test/DebugInfo/X86/dbg-value-inlined-parameter.ll (I actually made a C-reproducer ending up in such IR as well) seems to be lowered incorrectly by ISel.
I was analysing problem were ISel lowering caused similar problems a few month ago.
And the RUST-based code in https://bugs.llvm.org/show_bug.cgi?id=36417 also suffered from ISel creating "use before def" situations when inserting DBG_VALUE nodes.

So I guess I need to dig up that old patch I was working on in ScheduleDAGSDNodes.cpp to see if it helps...

[bjope]

In D43956#1024090, @aprantl wrote:

• Dropping invalid DBG_VALUE instructions is not correct. What you want to do is insert a DBG_VALUE undef, ....

Yes, that should be more correct. I'll look into such a solution tomorrow.

[aprantl]

Thanks for the write-up! Do we have a bugreport for that issue?

[bjope]

In D43956#1024189, @bjope wrote:

In D43956#1024090, @aprantl wrote:

• Dropping invalid DBG_VALUE instructions is not correct. What you want to do is insert a DBG_VALUE undef, ....

Yes, that should be more correct. I'll look into such a solution tomorrow.

Although, since the DBG_VALUE is misplaced from the start, then we do not know if it is correct to insert a DBG_VALUE undef, ..., !"x" in that position in the code. Perhaps it could be in a scope where "x" doesn't exist?

[bjope]

In D43956#1024194, @aprantl wrote:

Thanks for the write-up! Do we have a bugreport for that issue?

The historical debugging thing was for our out-of-tree-target. I never got to the point of publishing anything in Phabricator, maybe due to problems with getting any good reproducer for an in-tree-target. I need to do some digging here.

[bjope]

In D43956#1024200, @bjope wrote:

In D43956#1024194, @aprantl wrote:

Thanks for the write-up! Do we have a bugreport for that issue?

The historical debugging thing was for our out-of-tree-target. I never got to the point of publishing anything in Phabricator, maybe due to problems with getting any good reproducer for an in-tree-target. I need to do some digging here.

Maybe this one is related: https://bugs.llvm.org/show_bug.cgi?id=34477
I also found a note that this patch https://reviews.llvm.org/D38197 resolved some problems (maybe that is why I started prioritizing other tasks...).

[bjope]

I'm having some problems with replacing the location for the DBG_VALUE that should be discarded by %noreg.
If I do that, then the UserValue created in LDVImpl::handleDebugValue will get a location that has the UndefLocNo.
However, after collectDebugValues we do computeIntervals, and in UserValue::computeIntervals there is a loop that discards all undefs. So there is really no point in adding them? The result will be the same as in my original patch.

But maybe it is a bug that LiveDebugVariables removes all DBG_VALUE undef, ...?

If I simply replace the DBG_VALUE by DBG_VALUE %noreg, ... and leave it in the code during register allocation, then it has an impact codegen (might be another bug in the register allocator?), but it is also different from having such DBG_VALUE instruction in the input to LiveDebugVariables (the remove before regalloc phase).

[aprantl]

But maybe it is a bug that LiveDebugVariables removes all DBG_VALUE undef, ...?

I think it is.

If you compile the function at -O1 (to force the constant to be described with a dbg.value)

void foo() {
  // single basic block
  int x = 42;
  bar();
  x = 23;
  bar();
}

and replace the second dbg.value with a dbg.value(undef) in the LLVM IR and run it through llc, do we get the range of the constant 42 correct in the resulting location list for x? Does it end before the second call to bar()?

[bjope]

In D43956#1025531, @aprantl wrote:

But maybe it is a bug that LiveDebugVariables removes all DBG_VALUE undef, ...?

I think it is.

If you compile the function at -O1 (to force the constant to be described with a dbg.value)

void foo() {
  // single basic block
  int x = 42;
  bar();
  x = 23;
  bar();
}

and replace the second dbg.value with a dbg.value(undef) in the LLVM IR and run it through llc, do we get the range of the constant 42 correct in the resulting location list for x? Does it end before the second call to bar()?

Nope, if I do that the DBG_VALUE is removed by LiveDebugVariables. And we no longer get a .debug_loc range for "x". Instead we get

	.byte	3                       # Abbrev [3] 0x3f:0xc DW_TAG_variable
	.byte	42                      # DW_AT_const_value
	.long	.Linfo_string4          # DW_AT_name
	.byte	1                       # DW_AT_decl_file
	.byte	5                       # DW_AT_decl_line
	.long	76                      # DW_AT_type

So "x" will appear as being 42 throughout the function.

[aprantl]

Congratulations, you found a bug! :-)
I think the right way forward would be to fix LiveDebugVariables to not drop undef DBG_VALUEs. This will be slightly more expensive in terms of compile time and size of the debug info (since we now need to use location lists for cases like the one you found), but it will be far more accurate. Let me know if you would be interested in working on that otherwise we can also just file a PR as a plan of record.

[bjope]

Ok, but then I will update this patch with the one that adds and undef DBG_VALUE instead of just discarding it. And then things should work as expected when we solve that other bug.

I think you should file a PR for the other problem. I have some other things to look into, for example trying to hunt down why ISel is inserting these DBG_VALUEs outside of the live range for the virtual reg in the first place.

[bjope]

Updated to replace the faulty DBG_VALUE by 'DBG_VALUE %noreg' instead of
discarding it completely (as suggested by Adrian).

Currently this has little impact, as computeIntervals will discard such
DBG_VALUE instructions anyway. But doing it like this will give the wanted
result when https://bugs.llvm.org/show_bug.cgi?id=36579 has been solved.

[bjope]

lib/CodeGen/LiveDebugVariables.cpp

762

Oops. I did not intend to include this in the patch.

[bjope]

Remove accidentally published debug printout in computeIntervals.

lib/CodeGen/LiveDebugVariables.cpp

bool LDVImpl::handleDebugValue(MachineInstr &MI, SlotIndex Idx) {
   // DBG_VALUE loc, offset, variable
   if (MI.getNumOperands() != 4 ||
       !(MI.getOperand(1).isReg() || MI.getOperand(1).isImm()) ||
       !MI.getOperand(2).isMetadata()) {
     DEBUG(dbgs() << "Can't handle " << MI);
     return false;
   }
 
+  // Detect invalid DBG_VALUE instructions, with a debug-use of a virtual
+  // register that hasn't been defined yet. If we do not remove those here, then
+  // the re-insertion of the DBG_VALUE instruction after register allocation
+  // will be incorrect.
+  // TODO: If earlier passes are corrected to generate sane debug information
+  // (and if the machine verifier is improved to catch this), then these checks
+  // could be removed or replaced by asserts.
+  bool Discard = false;
+  if (MI.getOperand(0).isReg() &&
+      TargetRegisterInfo::isVirtualRegister(MI.getOperand(0).getReg())) {
+    const unsigned Reg = MI.getOperand(0).getReg();
+    if (!LIS->hasInterval(Reg)) {
+      // The DBG_VALUE is described by a virtual register that does not have a
+      // live interval. Discard the DBG_VALUE.
+      Discard = true;
+      DEBUG(dbgs() << "Discarding debug info (no LIS interval): "
+            << Idx << " " << MI);
+    } else {
+      // The DBG_VALUE is only valid if either Reg is live out from Idx, or Reg
+      // is defined dead at Idx (where Idx is the slot index for the instruction
+      // preceeding the DBG_VALUE).
+      const LiveInterval &LI = LIS->getInterval(Reg);
+      LiveQueryResult LRQ = LI.Query(Idx);
+      if (!LRQ.valueOutOrDead()) {
+        // We have found a DBG_VALUE with the value in a virtual register that
+        // is not live. Discard the DBG_VALUE.
+        Discard = true;
+        DEBUG(dbgs() << "Discarding debug info (reg not live): "
+              << Idx << " " << MI);
+      }
+    }
+  }
+
   // Get or create the UserValue for (variable,offset) here.
   bool IsIndirect = MI.getOperand(1).isImm();
   if (IsIndirect)
     assert(MI.getOperand(1).getImm() == 0 && "DBG_VALUE with nonzero offset");
   const DILocalVariable *Var = MI.getDebugVariable();
   const DIExpression *Expr = MI.getDebugExpression();
   UserValue *UV =
       getUserValue(Var, Expr, MI.getDebugLoc());
+  if (!Discard)
     UV->addDef(Idx, MI.getOperand(0), IsIndirect);
+  else
+    UV->addDef(Idx, MachineOperand::CreateReg(0U, RegState::Debug), false);
   return true;
 }
 
 bool LDVImpl::collectDebugValues(MachineFunction &mf) {
   bool Changed = false;
   for (MachineFunction::iterator MFI = mf.begin(), MFE = mf.end(); MFI != MFE;
        ++MFI) {
     MachineBasicBlock *MBB = &*MFI;
for (unsigned i = 0; i != Defs.size(); ++i) {
     // the next def of the physical register. So we do not need to extend the
     // range. It might actually happen that the DBG_VALUE is the last use of
     // the physical register (e.g. if this is an unused input argument to a
     // function).
   }
 
   // Erase all the undefs.
   for (LocMap::iterator I = locInts.begin(); I.valid();)
-    if (I.value().isUndef())
+    if (I.value().isUndef()) {
+      dbgs() << "Erasing " << I.start() << "\n";
       I.erase();
+    }
     else
       ++I;
 
   // The computed intervals may extend beyond the range of the debug
   // location's lexical scope. In this case, splitting of an interval
   // can result in an interval outside of the scope being created,
   // causing extra unnecessary DBG_VALUEs to be emitted. To prevent
   // this, trim the intervals to the lexical scope.

test/DebugInfo/X86/dbg-value-inlined-parameter.ll

 ;CHECK: DW_TAG_inlined_subroutine
 ;CHECK-NEXT: DW_AT_abstract_origin {{.*}} "foo"
 ;CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr]
 ;CHECK-NEXT: DW_AT_high_pc [DW_FORM_data4]
 ;CHECK-NEXT: DW_AT_call_file
 ;CHECK-NEXT: DW_AT_call_line
 
 ;CHECK: DW_TAG_formal_parameter
-;FIXME: Linux shouldn't drop this parameter either...
 ;CHECK-NOT: DW_TAG
-;DARWIN:   DW_AT_abstract_origin {{.*}} "sp"
-;DARWIN: DW_TAG_formal_parameter
+;FIXME: Shouldn't drop this parameter...
+;XCHECK:   DW_AT_abstract_origin {{.*}} "sp"
+;XCHECK: DW_TAG_formal_parameter
 ;CHECK: DW_AT_abstract_origin {{.*}} "nums"
 ;CHECK-NOT: DW_TAG_formal_parameter
 
 source_filename = "test/DebugInfo/X86/dbg-value-inlined-parameter.ll"
 
 %struct.S1 = type { float*, i32 }
 
 @p = common global %struct.S1 zeroinitializer, align 8, !dbg !0

test/DebugInfo/X86/live-debug-vars-discard-invalid.mir

+# RUN: llc -mtriple=x86_64-linux-gnu -start-before greedy -stop-after virtregrewriter -o - %s | FileCheck %s
+
+--- |
+  ; ModuleID = '<stdin>'
+  source_filename = "test/DebugInfo/X86/dbg-value-inlined-parameter.ll"
+  target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-apple-darwin"
+
+  %struct.S1 = type { float*, i32 }
+
+  @p = common global %struct.S1 zeroinitializer, align 8, !dbg !0
+
+  ; Function Attrs: nounwind optsize ssp
+  define void @foobar() !dbg !15 {
+  entry:
+    tail call void @llvm.dbg.value(metadata %struct.S1* @p, metadata !18, metadata !DIExpression()) , !dbg !25
+    ret void, !dbg !32
+  }
+
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+  !llvm.dbg.cu = !{!2}
+  !llvm.module.flags = !{!14}
+
+  !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+  !1 = !DIGlobalVariable(name: "p", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+  !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 2.9 (trunk 125693)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !5, imports: !4)
+  !3 = !DIFile(filename: "nm2.c", directory: "/private/tmp")
+  !4 = !{}
+  !5 = !{!0}
+  !6 = !DIDerivedType(tag: DW_TAG_typedef, name: "S1", scope: !2, file: !3, line: 4, baseType: !7)
+  !7 = !DICompositeType(tag: DW_TAG_structure_type, name: "S1", scope: !2, file: !3, line: 1, size: 128, align: 64, elements: !8)
+  !8 = !{!9, !12}
+  !9 = !DIDerivedType(tag: DW_TAG_member, name: "m", scope: !3, file: !3, line: 2, baseType: !10, size: 64, align: 64)
+  !10 = !DIDerivedType(tag: DW_TAG_pointer_type, scope: !2, baseType: !11, size: 64, align: 64)
+  !11 = !DIBasicType(name: "float", size: 32, align: 32, encoding: DW_ATE_float)
+  !12 = !DIDerivedType(tag: DW_TAG_member, name: "nums", scope: !3, file: !3, line: 3, baseType: !13, size: 32, align: 32, offset: 64)
+  !13 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+  !14 = !{i32 1, !"Debug Info Version", i32 3}
+  !15 = distinct !DISubprogram(name: "foobar", scope: !3, file: !3, line: 15, type: !16, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, unit: !2)
+  !16 = !DISubroutineType(types: !17)
+  !17 = !{null}
+  !18 = !DILocalVariable(name: "sp", arg: 1, scope: !19, file: !3, line: 7, type: !24)
+  !19 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 8, type: !20, isLocal: false, isDefinition: true, scopeLine: 8, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true, unit: !2, variables: !22)
+  !20 = !DISubroutineType(types: !21)
+  !21 = !{!13}
+  !22 = !{!18, !23}
+  !23 = !DILocalVariable(name: "nums", arg: 2, scope: !19, file: !3, line: 7, type: !13)
+  !24 = !DIDerivedType(tag: DW_TAG_pointer_type, scope: !2, baseType: !6, size: 64, align: 64)
+  !25 = !DILocation(line: 7, column: 13, scope: !19, inlinedAt: !26)
+  !26 = !DILocation(line: 16, column: 3, scope: !27)
+  !27 = distinct !DILexicalBlock(scope: !15, file: !3, line: 15, column: 15)
+  !32 = !DILocation(line: 17, column: 1, scope: !27)
+
+...
+---
+name:            foobar
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    %1:gr64 = IMPLICIT_DEF
+    %2:gr64 = IMPLICIT_DEF
+
+  bb.1:
+    ; This DBG_VALUE will be discarded (use before def of %0).
+    DBG_VALUE debug-use %0, debug-use $noreg, !18, !DIExpression(), debug-location !25
+    %0:gr64 = IMPLICIT_DEF
+    %0:gr64 = IMPLICIT_DEF
+    %0:gr64 = IMPLICIT_DEF
+    %0:gr64 = IMPLICIT_DEF
+
+  bb.2:
+    ; This DBG_VALUE will be discarded (%1 is defined earlier, but it is not live in, so we do not know where %1 is stored).
+    DBG_VALUE debug-use %1, debug-use $noreg, !18, !DIExpression(), debug-location !25
+    %1:gr64 = IMPLICIT_DEF
+    %1:gr64 = IMPLICIT_DEF
+    %1:gr64 = IMPLICIT_DEF
+    %1:gr64 = IMPLICIT_DEF
+    ; This DBG_VALUE is kept, even if %1 is dead, it was defined in the prev instruction,
+    ; so the value should be available for as long as the register allocated to %1 is live.
+    DBG_VALUE debug-use %1, debug-use $noreg, !18, !DIExpression(), debug-location !25
+
+  bb.3:
+    %1:gr64 = IMPLICIT_DEF
+    DBG_VALUE 0, debug-use $noreg, !23, !DIExpression(), debug-location !25
+    ; This DBG_VALUE is kept, even if %1 is dead, it was defined in the prev non-dbg instruction,
+    ; so the value should be available for as long as the register allocated to %1 is live.
+    DBG_VALUE debug-use %1, debug-use $noreg, !18, !DIExpression(), debug-location !25
+
+  bb.4:
+    ; All DBG_VALUEs here should survive. %2 is livein as it was defined in bb.0, and it has use/def in the BTS64rr instruction.
+    DBG_VALUE debug-use %2, debug-use $noreg, !18, !DIExpression(), debug-location !25
+    %2:gr64 = BTS64rr %2, 0, implicit-def $eflags
+    DBG_VALUE 0, debug-use $noreg, !23, !DIExpression(), debug-location !25
+    DBG_VALUE debug-use %2, debug-use $noreg, !18, !DIExpression(), debug-location !25
+    %2:gr64 = BTS64rr %2, 0, implicit-def $eflags
+    DBG_VALUE debug-use %2, debug-use $noreg, !18, !DIExpression(), debug-location !25
+    %2:gr64 = BTS64rr %2, 0, implicit-def $eflags
+    DBG_VALUE debug-use %2, debug-use $noreg, !18, !DIExpression(), debug-location !25
+
+  bb.5:
+    RET 0, debug-location !32
+...
+
+# CHECK-LABEL: name: foobar
+
+# CHECK-LABEL: bb.1:
+## After solving https://bugs.llvm.org/show_bug.cgi?id=36579 we expect to get a
+##   DBG_VALUE debug-use $noreg
+## here.
+# CHECK-NOT:    DBG_VALUE
+
+# CHECK-LABEL: bb.2:
+## After solving https://bugs.llvm.org/show_bug.cgi?id=36579 we expect to get a
+##   DBG_VALUE debug-use $noreg
+## here.
+# CHECK-NOT:    DBG_VALUE
+# CHECK:        dead renamable $rcx = IMPLICIT_DEF
+# CHECK-NEXT:   dead renamable $rcx = IMPLICIT_DEF
+# CHECK-NEXT:   dead renamable $rcx = IMPLICIT_DEF
+# CHECK-NEXT:   dead renamable $rcx = IMPLICIT_DEF
+# CHECK-NEXT:   DBG_VALUE debug-use $rcx, debug-use $noreg, !18, !DIExpression()
+
+# CHECK-LABEL: bb.3:
+# CHECK:        dead renamable $rcx = IMPLICIT_DEF
+# CHECK-NEXT:   DBG_VALUE 0, debug-use $noreg, !23, !DIExpression()
+# CHECK-NEXT:   DBG_VALUE debug-use $rcx, debug-use $noreg, !18, !DIExpression()
+
+# CHECK-LABEL: bb.4:
+# CHECK:        liveins: $rax
+# CHECK:        DBG_VALUE debug-use $rax, debug-use $noreg, !18, !DIExpression()
+# CHECK-NEXT:   renamable $rax = BTS64rr killed renamable $rax, 0, implicit-def $eflags
+# CHECK-NEXT:   DBG_VALUE 0, debug-use $noreg, !23, !DIExpression()
+# CHECK-NEXT:   DBG_VALUE debug-use $rax, debug-use $noreg, !18, !DIExpression()
+# CHECK-NEXT:   renamable $rax = BTS64rr killed renamable $rax, 0, implicit-def $eflags
+# CHECK-NEXT:   DBG_VALUE debug-use $rax, debug-use $noreg, !18, !DIExpression()
+# CHECK-NEXT:   dead renamable $rax = BTS64rr killed renamable $rax, 0, implicit-def $eflags
+
+# CHECK-LABEL: bb.5:
+# CHECK-NEXT:   RET 0