[DebugInfo] Use FrameDestroy to extend stack locations to the end of a function

[jmorse]

Summary

This patch depends on D61940, and is a small part split out of it. We use the FrameDestroy flag to detect the end of the stack frame, and extend stack variable locations past that point. This greatly enhances the chance that we can emit a single-value location.

Most of the discussion about this functionality is in the parent patch; the intention of splitting this part out, is so that out-of-tree backends can revert this patch if they have difficulties with FrameDestroy.

[aprantl]

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

277–280

Is this comment still up-to-date?

[dstenb]

test/DebugInfo/X86/dbg-addr.ll

11–12

Can we remove/change this comment now that we produce a single location description?

[jmorse]

Move the change in a comment into this patch; remove an un-necessary test comment.

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

for (const auto &MI : MBB) {
           // backend does this for aggregate function arguments.
           if (MI.isCall() && MO.getReg() == SP)
             continue;
           // If this is a virtual register, only clobber it since it doesn't
           // have aliases.
           if (TRI->isVirtualRegister(MO.getReg()))
             clobberRegisterUses(RegVars, MO.getReg(), DbgValues, LiveEntries,
                                 MI);
           // If this is a register def operand, it may end a debug value
-          // range. Ignore defs of the frame register in the prologue.
+          // range. Ignore frame-register defs in the epilogue and prologue,
+          // we expect debuggers to understand that stack-locations are
+          // invalid outside of the function body.
           else if (MO.getReg() != FrameReg ||
-                   !MI.getFlag(MachineInstr::FrameSetup)) {
+                   (!MI.getFlag(MachineInstr::FrameDestroy) &&
+                   !MI.getFlag(MachineInstr::FrameSetup))) {
             for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
                  ++AI)
               clobberRegisterUses(RegVars, *AI, DbgValues, LiveEntries, MI);
           }
         } else if (MO.isRegMask()) {
           // If this is a register mask operand, clobber all debug values in
           // non-CSRs.
           SmallVector<unsigned, 32> RegsToClobber;

test/DebugInfo/COFF/pieces.ll

 ; ASM:         xorl    %ecx, %ecx
 ; ASM:         callq   g
 ; ASM:         movl    %eax, [[offset_o_x:[0-9]+]](%rsp)          # 4-byte Spill
 ; ASM: [[spill_o_x_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offset_o_x]], DW_OP_LLVM_fragment 32 32] [$rsp+0]
 ; ASM:         #APP
 ; ASM:         #NO_APP
 ; ASM:         movl    [[offset_o_x]](%rsp), %eax          # 4-byte Reload
-; ASM: [[spill_o_x_end:\.Ltmp[0-9]+]]:
 ; ASM:         retq
+; ASM-NEXT: [[spill_o_x_end:\.Ltmp[0-9]+]]:
+; ASM-NEXT: .Lfunc_end4:
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "loop_csr"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
 ; ASM:        .cv_def_range    [[oy_ox_start]] [[ox_start]], "C\021\030\000\000\000\000\000\000\000"
 ; ASM:        .cv_def_range    [[oy_ox_start]] [[oy_start]], "C\021\027\000\000\000\004\000\000\000"

 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "bitpiece_spill"        # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[spill_o_x_start]] [[spill_o_x_end]], "E\021O\001A\000$\000\000\000"
+; ASM:        .cv_def_range    [[spill_o_x_start]] .Lfunc_end4, "E\021O\001A\000$\000\000\000"
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: bitpiece_spill
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }

test/DebugInfo/X86/dbg-addr.ll

 ; RUN: llc %s -o %t.s
 ; RUN: llvm-mc -triple x86_64--linux %t.s -filetype=obj -o %t.o
 ; RUN: FileCheck < %t.s %s
 ; RUN: llvm-dwarfdump %t.o | FileCheck %s --check-prefix=DWARF
 
 ; Unlike dbg.declare, dbg.addr should be lowered to DBG_VALUE instructions. It
 ; is control-dependent.
 
 ; CHECK-LABEL: use_dbg_addr:
 ; CHECK: #DEBUG_VALUE: use_dbg_addr:o <- [$rsp+0]
 
-; FIXME: Avoid the use of a single-location location list and use
-; DW_AT_start_offset instead.
-
 ; DWARF: DW_TAG_variable
-; DWARF-NEXT:              DW_AT_location (0x00000000
-; DWARF-NEXT:                          [0x{{.*}}, 0x{{.*}}): DW_OP_breg7 RSP+0)
+; DWARF-NEXT:              DW_AT_location (DW_OP_fbreg +0)
 ; DWARF-NEXT:              DW_AT_name ("o")
 
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 

test/DebugInfo/X86/debug-loc-offset.mir

 # RUN: llc -o - %s -start-after=patchable-function -filetype=obj -O0 -mtriple=i386-unknown-linux-gnu -dwarf-version=4 | llvm-dwarfdump -v - | FileCheck %s
 
-# XFAIL: *
-# Marked XFail due to the removal of "ChangingRegs" from
-# DbgEntityHistoryCalculator, shortening the checked range to not reach the
-# end of the function. Fixed by an about-to-land patch using the FrameDestroy
-# flag to identify the end of functions.
-
 # From the code:
 #
 # debug-loc-offset1.cc
 # int bar (int b) {
 #   return b+4;
 # }
 #
 # debug-loc-offset2.cc

test/DebugInfo/X86/pr19307.mir

 # RUN: llc -o - %s -start-after=patchable-function -O0 | FileCheck %s
 
-# XFAIL: *
-# Marked XFail due to the removal of "ChangingRegs" from
-# DbgEntityHistoryCalculator, shortening the checked range to not reach the
-# end of the function. Fixed by an about-to-land patch using the FrameDestroy
-# flag to identify the end of functions.
-
 # Generated from the source file pr19307.cc:
 # #include <string>
 # void parse_range(unsigned long long &offset, unsigned long long &limit,
 #                  std::string range) {
 #   if (range.compare(0, 6, "items=") != 0 || range[6] == '-')
 #     offset = 1;
 #   range.erase(0, 6);
 #   limit = 2;