[llvm] a975472 - [DebugInfo][InstrRef] Describe value sizes when spilt to stack
Jeremy Morse via llvm-commits
llvm-commits at lists.llvm.org
Thu May 12 07:53:05 PDT 2022
Author: Jeremy Morse
Date: 2022-05-12T15:52:55+01:00
New Revision: a975472fa6972bced6a6075fe248bffedeecd96d
URL: https://github.com/llvm/llvm-project/commit/a975472fa6972bced6a6075fe248bffedeecd96d
DIFF: https://github.com/llvm/llvm-project/commit/a975472fa6972bced6a6075fe248bffedeecd96d.diff
LOG: [DebugInfo][InstrRef] Describe value sizes when spilt to stack
This is a re-apply of D123599, which was reverted in 4fe2ab5279408, now
with a more appropriate assertion. Original commit message follow:
InstrRefBasedLDV can track and describe variable values that are spilt to
the stack -- however it does not current describe the size of the value on
the stack. This can cause uninitialized bytes to be read from the stack if
a small register is spilt for a larger variable, or theoretically on
big-endian machines if a large value on the stack is used for a small
variable.
Fix this by using DW_OP_deref_size to specify the amount of data to load
from the stack, if there's any possibility for ambiguity. There are a few
scenarios where this can be omitted (such as when using DW_OP_piece and a
non-DW_OP_stack_value location), see deref-spills-with-size.mir for an
explicit table of inputs flavours and output expressions.
Differential Revision: https://reviews.llvm.org/D123599
Added:
llvm/test/DebugInfo/MIR/InstrRef/deref-spills-with-size.mir
llvm/test/DebugInfo/MIR/InstrRef/follow-spill-of-indir-value.mir
Modified:
llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h
llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir
llvm/test/DebugInfo/MIR/X86/livedebugvalues_load_in_loop.mir
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp b/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
index ab1fb3f743ea8..6735837ec98c4 100644
--- a/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
+++ b/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp
@@ -870,19 +870,72 @@ MachineInstrBuilder MLocTracker::emitLoc(Optional<LocIdx> MLoc,
// the variable is.
if (Offset == 0) {
const SpillLoc &Spill = SpillLocs[SpillID.id()];
- Expr = TRI.prependOffsetExpression(Expr, DIExpression::ApplyOffset,
- Spill.SpillOffset);
unsigned Base = Spill.SpillBase;
MIB.addReg(Base);
- MIB.addImm(0);
- // Being on the stack makes this location indirect; if it was _already_
- // indirect though, we need to add extra indirection. See this test for
- // a scenario where this happens:
- // llvm/test/DebugInfo/X86/spill-nontrivial-param.ll
+ // There are several ways we can dereference things, and several inputs
+ // to consider:
+ // * NRVO variables will appear with IsIndirect set, but should have
+ // nothing else in their DIExpressions,
+ // * Variables with DW_OP_stack_value in their expr already need an
+ // explicit dereference of the stack location,
+ // * Values that don't match the variable size need DW_OP_deref_size,
+ // * Everything else can just become a simple location expression.
+
+ // We need to use deref_size whenever there's a mismatch between the
+ // size of value and the size of variable portion being read.
+ // Additionally, we should use it whenever dealing with stack_value
+ // fragments, to avoid the consumer having to determine the deref size
+ // from DW_OP_piece.
+ bool UseDerefSize = false;
+ unsigned ValueSizeInBits = getLocSizeInBits(*MLoc);
+ unsigned DerefSizeInBytes = ValueSizeInBits / 8;
+ if (auto Fragment = Var.getFragment()) {
+ unsigned VariableSizeInBits = Fragment->SizeInBits;
+ if (VariableSizeInBits != ValueSizeInBits || Expr->isComplex())
+ UseDerefSize = true;
+ } else if (auto Size = Var.getVariable()->getSizeInBits()) {
+ if (*Size != ValueSizeInBits) {
+ UseDerefSize = true;
+ }
+ }
+
if (Properties.Indirect) {
- std::vector<uint64_t> Elts = {dwarf::DW_OP_deref};
- Expr = DIExpression::append(Expr, Elts);
+ // This is something like an NRVO variable, where the pointer has been
+ // spilt to the stack, or a dbg.addr pointing at a coroutine frame
+ // field. It should end up being a memory location, with the pointer
+ // to the variable loaded off the stack with a deref. It can't be a
+ // DW_OP_stack_value expression.
+ assert(!Expr->isImplicit());
+ Expr = TRI.prependOffsetExpression(
+ Expr, DIExpression::ApplyOffset | DIExpression::DerefAfter,
+ Spill.SpillOffset);
+ MIB.addImm(0);
+ } else if (UseDerefSize) {
+ // We're loading a value off the stack that's not the same size as the
+ // variable. Add / subtract stack offset, explicitly deref with a size,
+ // and add DW_OP_stack_value if not already present.
+ SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size,
+ DerefSizeInBytes};
+ Expr = DIExpression::prependOpcodes(Expr, Ops, true);
+ unsigned Flags = DIExpression::StackValue | DIExpression::ApplyOffset;
+ Expr = TRI.prependOffsetExpression(Expr, Flags, Spill.SpillOffset);
+ MIB.addReg(0);
+ } else if (Expr->isComplex()) {
+ // A variable with no size ambiguity, but with extra elements in it's
+ // expression. Manually dereference the stack location.
+ assert(Expr->isComplex());
+ Expr = TRI.prependOffsetExpression(
+ Expr, DIExpression::ApplyOffset | DIExpression::DerefAfter,
+ Spill.SpillOffset);
+ MIB.addReg(0);
+ } else {
+ // A plain value that has been spilt to the stack, with no further
+ // context. Request a location expression, marking the DBG_VALUE as
+ // IsIndirect.
+ Expr = TRI.prependOffsetExpression(Expr, DIExpression::ApplyOffset,
+ Spill.SpillOffset);
+ MIB.addImm(0);
}
} else {
// This is a stack location with a weird subregister offset: emit an undef
diff --git a/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h b/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h
index efca5884fd2fc..70aae47c8bdc5 100644
--- a/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h
+++ b/llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h
@@ -633,6 +633,19 @@ class MLocTracker {
/// Return true if Idx is a spill machine location.
bool isSpill(LocIdx Idx) const { return LocIdxToLocID[Idx] >= NumRegs; }
+ /// How large is this location (aka, how wide is a value defined there?).
+ unsigned getLocSizeInBits(LocIdx L) const {
+ unsigned ID = LocIdxToLocID[L];
+ if (!isSpill(L)) {
+ return TRI.getRegSizeInBits(Register(ID), MF.getRegInfo());
+ } else {
+ // The slot location on the stack is uninteresting, we care about the
+ // position of the value within the slot (which comes with a size).
+ StackSlotPos Pos = locIDToSpillIdx(ID);
+ return Pos.first;
+ }
+ }
+
MLocIterator begin() { return MLocIterator(LocIdxToIDNum, 0); }
MLocIterator end() {
diff --git a/llvm/test/DebugInfo/MIR/InstrRef/deref-spills-with-size.mir b/llvm/test/DebugInfo/MIR/InstrRef/deref-spills-with-size.mir
new file mode 100644
index 0000000000000..2a43902cef024
--- /dev/null
+++ b/llvm/test/DebugInfo/MIR/InstrRef/deref-spills-with-size.mir
@@ -0,0 +1,371 @@
+# RUN: llc %s -o - -experimental-debug-variable-locations=true \
+# RUN: -run-pass=livedebugvalues \
+# RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
+# RUN: llc %s -o - -experimental-debug-variable-locations=true \
+# RUN: -start-before=livedebugvalues -filetype=obj \
+# RUN: | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+#
+# LLVM can produce DIExpressions that convert from one value of arbitrary size
+# to another. This is normally fine, however that means the value for a
+# variable tracked in instruction referencing might not be the same size as the
+# variable itself.
+#
+# This becomes a problem when values move onto the stack and we emit
+# DW_OP_deref: there is no information about how large a value the consumer
+# should load from the stack. The convention today appears to be the size of
+# the variable, and as a result if you have a value that's smaller than the
+# variable size, extra information is loaded onto the DWARF expression stack.
+# This then appears as a false variable value to the consumer.
+#
+# In this test, there are various scenarios to test where the size of the value
+# needs to reach the expression emitter in LiveDebugValues. However, there are
+# even more scenarios to consider where the value is in a spill slot, and:
+# * The value is larger than the variable, the same, or smaller,
+# * The variable is a normal scalar, or a fragment,
+# * There is a DW_OP_stack_value in the expression, or not
+# That gives us twelve situations to consider, and the easiest way to confirm
+# correctness is to write them all out. The final DWARF expressions to
+# produce are:
+# * No stack value,
+# * Scalar (32 bits),
+# * Larger value (64 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value
+# * Same value (32 bits)
+# DW_OP_breg7 RSP-8
+# * Smaller value (8 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value
+# * Fragment (32 bits)
+# * Larger value (64 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value, DW_OP_piece 0x4
+# * Same value (32 bits)
+# DW_OP_breg7 RSP-8, DW_OP_piece 0x4
+# * Smaller value (8 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value, DW_OP_piece 0x4
+# * Stack value (imagine there was some arithmetic on the stack before the
+# DW_OP_stack_value opcode),
+# * Scalar (32 bits),
+# * Larger value (64 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value
+# * Same value (32 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref, DW_OP_stack_value
+# * Smaller value (8 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value
+# * Fragment (32 bits)
+# * Larger value (64 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value, DW_OP_piece 0x4
+# * Same value (32 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x4, DW_OP_stack_value, DW_OP_piece 0x4
+# * Smaller value (8 bits)
+# DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value, DW_OP_piece 0x4
+#
+# The outlier from the pattern is (Stack value, Fragment, Same value size): we
+# put a DW_OP_deref_size in where a DW_OP_deref could have sufficied. However,
+# if we used DW_OP_deref, it would force the consumer to derive the deref size
+# from the DW_OP_piece, which is un-necessarily hard.
+
+## Capture variable num,
+# CHECK-DAG: ![[VARNUM:[0-9]+]] = !DILocalVariable(name: "flannel",
+# CHECK-DAG: ![[VARNUM2:[0-9]+]] = !DILocalVariable(name: "shoes",
+
+# DWARF: DW_TAG_variable
+# DWARF-NEXT: DW_AT_location
+## Defined in register, spilt to stack.
+# DWARF-NEXT: DW_OP_breg0 RAX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x00000026) "DW_ATE_signed_8", DW_OP_convert (0x0000002a) "DW_ATE_signed_32", DW_OP_stack_value
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_convert (0x00000026) "DW_ATE_signed_8", DW_OP_convert (0x0000002a) "DW_ATE_signed_32", DW_OP_stack_value
+## Defined on stack.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_convert (0x00000026) "DW_ATE_signed_8", DW_OP_convert (0x0000002a) "DW_ATE_signed_32", DW_OP_stack_value
+## DBG_PHI that moves to stack.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value
+## DBG_PHI of stack with size.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x2, DW_OP_stack_value
+## Followed by scalar / no-stack-value locations with various sizes.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value
+# DWARF-NEXT: DW_OP_breg7 RSP-8
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value
+## scalar / stack value with various sizes.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value)
+# DWARF: DW_AT_name ("flannel")
+
+# Variable with fragments.
+# DWARF: DW_TAG_variable
+# DWARF-NEXT: DW_AT_location
+## Scalar / no-stack-value locations with various sizes.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_stack_value, DW_OP_piece 0x4
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_piece 0x4
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_stack_value, DW_OP_piece 0x4
+## Scalar / stack value with various sizes.
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x8, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value, DW_OP_piece 0x4
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x4, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value, DW_OP_piece 0x4
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref_size 0x1, DW_OP_lit1, DW_OP_plus, DW_OP_stack_value, DW_OP_piece 0x4)
+# DWARF: DW_AT_name ("shoes")
+
+--- |
+ ; ModuleID = 'missingvar.ll'
+ source_filename = "a"
+ 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"
+
+ define linkonce_odr void @_ZNSt5dequeIPN4llvm4LoopESaIS2_EE13_M_insert_auxESt15_Deque_iteratorIS2_RS2_PS2_EmRKS2_() local_unnamed_addr align 2 !dbg !3 {
+ entry:
+ call void @llvm.dbg.value(metadata i32 0, metadata !8, metadata !DIExpression()), !dbg !7
+ call void @llvm.dbg.value(metadata i32 0, metadata !10, metadata !DIExpression()), !dbg !7
+ ret void
+ }
+
+ declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+ !llvm.module.flags = !{!0, !9}
+ !llvm.dbg.cu = !{!1}
+
+ !0 = !{i32 2, !"Debug Info Version", i32 3}
+ !1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "beards", isOptimized: true, runtimeVersion: 4, emissionKind: FullDebug)
+ !2 = !DIFile(filename: "bees.cpp", directory: "")
+ !3 = distinct !DISubprogram(name: "nope", scope: !2, file: !2, line: 1, type: !4, spFlags: DISPFlagDefinition, unit: !1)
+ !4 = !DISubroutineType(types: !5)
+ !5 = !{!6}
+ !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+ !7 = !DILocation(line: 1, scope: !3)
+ !8 = !DILocalVariable(name: "flannel", scope: !3, type: !6)
+ !9 = !{i32 2, !"Dwarf Version", i32 5}
+ !10 = !DILocalVariable(name: "shoes", scope: !3, type: !11)
+ !11 = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed)
+
+
+...
+---
+name: _ZNSt5dequeIPN4llvm4LoopESaIS2_EE13_M_insert_auxESt15_Deque_iteratorIS2_RS2_PS2_EmRKS2_
+alignment: 16
+tracksRegLiveness: true
+liveins:
+ - { reg: '$rdi' }
+ - { reg: '$rsi' }
+ - { reg: '$rdx' }
+frameInfo:
+ stackSize: 48
+ offsetAdjustment: -48
+ maxAlignment: 8
+ maxCallFrameSize: 0
+ cvBytesOfCalleeSavedRegisters: 48
+fixedStack:
+ - { id: 0, type: spill-slot, offset: -56, size: 8, alignment: 8, callee-saved-register: '$rbx' }
+ - { id: 1, type: spill-slot, offset: -48, size: 8, alignment: 16, callee-saved-register: '$r12' }
+ - { id: 2, type: spill-slot, offset: -40, size: 8, alignment: 8, callee-saved-register: '$r13' }
+ - { id: 3, type: spill-slot, offset: -32, size: 8, alignment: 16, callee-saved-register: '$r14' }
+ - { id: 4, type: spill-slot, offset: -24, size: 8, alignment: 8, callee-saved-register: '$r15' }
+ - { id: 5, type: spill-slot, offset: -16, size: 8, alignment: 16, callee-saved-register: '$rbp' }
+stack:
+ - { id: 0, type: spill-slot, offset: -64, size: 8, alignment: 8 }
+machineFunctionInfo: {}
+body: |
+ bb.0.entry:
+ liveins: $rdi, $rdx, $rsi, $rbp, $r15, $r14, $r13, $r12, $rbx
+
+ ; CHECK-LABEL: bb.0.entry:
+
+ ;; PART ONE: For this first block of tests, check that information about
+ ;; the size of the value on the stack makes it through to the expression.
+
+ $al = MOV8ri 0, debug-instr-number 1, debug-location !7
+ DBG_INSTR_REF 1, 0, !8, !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value), debug-location !7
+ ; CHECK: DBG_VALUE $al, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed,
+ ; CHECK-SAME : DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)
+
+ MOV8mr $rsp, 1, $noreg, -8, $noreg, renamable $al :: (store 1 into %stack.0)
+ ;; Clobber to force variable location onto stack. We should use a
+ ;; deref_size 1 because the value is smaller than the variable.
+ $al = MOV8ri 0, debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus,
+ ; CHECK-SAME: DW_OP_deref_size, 1, DW_OP_LLVM_convert, 8, DW_ATE_signed,
+ ; CHECK-SAME: DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value),
+
+ ; Terminate the current variable location,
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg, ![[VARNUM]], !DIExpression()
+
+ ;; Try again, but with the value originating on the stack, to ensure that
+ ;; we can find its size. It should be deref_size 1 again.
+ INC8m $rsp, 1, $noreg, 4, $noreg, implicit-def dead $eflags, debug-instr-number 2, debug-location !7 :: (store (s8) into %stack.0)
+ DBG_INSTR_REF 2, 1000000, !8, !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus,
+ ; CHECK-SAME: DW_OP_deref_size, 1, DW_OP_LLVM_convert, 8, DW_ATE_signed,
+ ; CHECK-SAME: DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value),
+
+ $eax = MOV32ri 0, debug-location !7
+
+ ;; How about DBG_PHIs? The size of the value is communicated by the register
+ ;; size, or an extra DBG_PHI operand, and that should feed through into the
+ ;; decision of whether to deref_size or not.
+
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg
+
+ $al = MOV8ri 0, debug-location !7
+ DBG_PHI $al, 7
+
+ MOV32mr $rsp, 1, $noreg, -8, $noreg, renamable $eax :: (store 4 into %stack.0)
+ $eax = MOV32ri 0, debug-location !7
+ DBG_INSTR_REF 7, 0, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 1, DW_OP_stack_value)
+
+ $eax = MOV32ri 0, debug-location !7
+
+ ;; And for when the DBG_PHI specifies a stack size...
+ DBG_PHI %stack.0, 8, 16
+ DBG_INSTR_REF 8, 0, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 2, DW_OP_stack_value)
+
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; PART TWO: test the twelve kinds of location expression mentioned in the
+ ;; opening comment of this test, in that order. Please update the opening
+ ;; comment, these lines and the DWARF check lines at the same time.
+ ;; In each test we'll state a location, give it an instruction to cover,
+ ;; and then terminate it.
+
+ ;; Scalar (32), Large value (64), no stack value,
+ $rax = MOV64ri 0, debug-instr-number 10, debug-location !7
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, renamable $rax :: (store 8 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 10, 0, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 8, DW_OP_stack_value),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Scalar (32), Same value size (32), no stack value,
+ $eax = MOV32ri 0, debug-instr-number 11, debug-location !7
+ MOV32mr $rsp, 1, $noreg, -8, $noreg, renamable $eax :: (store 4 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 11, 0, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, 0, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Scalar (32), Smaller value (8), no stack value,
+ $al = MOV8ri 0, debug-instr-number 12, debug-location !7
+ MOV8mr $rsp, 1, $noreg, -8, $noreg, renamable $al :: (store 1 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 12, 0, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 1, DW_OP_stack_value),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Larger value (64), no stack value,
+ $rax = MOV64ri 0, debug-instr-number 13, debug-location !7
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, renamable $rax :: (store 8 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 13, 0, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 8, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Same value size (32), no stack value,
+ $eax = MOV32ri 0, debug-instr-number 14, debug-location !7
+ MOV32mr $rsp, 1, $noreg, -8, $noreg, renamable $eax :: (store 4 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 14, 0, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, 0, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Smaller value (8), no stack value,
+ $al = MOV8ri 0, debug-instr-number 15, debug-location !7
+ MOV8mr $rsp, 1, $noreg, -8, $noreg, renamable $al :: (store 1 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 15, 0, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 1, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+
+
+ ;; Scalar (32), Large value (64), with stack value,
+ $rax = MOV64ri 0, debug-instr-number 16, debug-location !7
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, renamable $rax :: (store 8 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 16, 0, !8, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 8, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Scalar (32), Same value size (32), no stack value,
+ $eax = MOV32ri 0, debug-instr-number 17, debug-location !7
+ MOV32mr $rsp, 1, $noreg, -8, $noreg, renamable $eax :: (store 4 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 17, 0, !8, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Scalar (32), Smaller value (8), no stack value,
+ $al = MOV8ri 0, debug-instr-number 18, debug-location !7
+ MOV8mr $rsp, 1, $noreg, -8, $noreg, renamable $al :: (store 1 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 18, 0, !8, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 1, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !8, !DIExpression(), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Larger value (64), no stack value,
+ $rax = MOV64ri 0, debug-instr-number 19, debug-location !7
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, renamable $rax :: (store 8 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 19, 0, !10, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 8, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Same value size (32), no stack value,
+ $eax = MOV32ri 0, debug-instr-number 20, debug-location !7
+ MOV32mr $rsp, 1, $noreg, -8, $noreg, renamable $eax :: (store 4 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 20, 0, !10, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 4, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ ;; Fragment (32), Smaller value (8), no stack value,
+ $al = MOV8ri 0, debug-instr-number 21, debug-location !7
+ MOV8mr $rsp, 1, $noreg, -8, $noreg, renamable $al :: (store 1 into %stack.0)
+ $rax = MOV64ri 0, debug-location !7
+ DBG_INSTR_REF 21, 0, !10, !DIExpression(DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $rsp, $noreg, ![[VARNUM2]],
+ ; CHECK-SAME: !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref_size, 1, DW_OP_constu, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 32),
+ $eax = MOV32ri 0, debug-location !7
+ DBG_VALUE $noreg, $noreg, !10, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !7
+ ; CHECK: DBG_VALUE $noreg, $noreg
+
+ RET64 0, debug-location !7
+...
diff --git a/llvm/test/DebugInfo/MIR/InstrRef/follow-spill-of-indir-value.mir b/llvm/test/DebugInfo/MIR/InstrRef/follow-spill-of-indir-value.mir
new file mode 100644
index 0000000000000..abd8710615745
--- /dev/null
+++ b/llvm/test/DebugInfo/MIR/InstrRef/follow-spill-of-indir-value.mir
@@ -0,0 +1,143 @@
+# RUN: llc %s -o - -experimental-debug-variable-locations=true \
+# RUN: -run-pass=livedebugvalues \
+# RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
+# RUN: llc %s -o - -experimental-debug-variable-locations=true \
+# RUN: -start-before=livedebugvalues -filetype=obj \
+# RUN: | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+
+## Test that we can spill indirect plain variable locations, and those with
+## non-empty expressions, to the stack. And that the derefs go in the right
+## place.
+
+## Capture variable num,
+# CHECK-DAG: ![[VARNUM:[0-9]+]] = !DILocalVariable(name: "nt",
+
+# DWARF: DW_TAG_formal_parameter
+# DWARF-NEXT: DW_AT_location
+# DWARF-NEXT: DW_OP_breg5 RDI+0
+##
+## First location: variable pointed to by basereg $rdi
+##
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref
+##
+## Spilt to stack: push stack address and deref, variable pointed to by the
+## pointer loaded off the stack.
+##
+# DWARF-NEXT: DW_OP_breg5 RDI+8
+##
+## Second location, variable pointed to by the register value plus eight.
+##
+# DWARF-NEXT: DW_OP_breg7 RSP-8, DW_OP_deref, DW_OP_lit8, DW_OP_plus)
+##
+## Spilt to stack: push stack location and deref the pointer onto the dwarf
+## expr stack. Then add eight to it, and it points to the variable.
+##
+
+
+--- |
+ source_filename = "t.cpp"
+ 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--linux"
+
+ %struct.NonTrivial = type { i32 }
+
+ ; Function Attrs: nounwind uwtable
+ define i32 @_Z3foo10NonTrivial(%struct.NonTrivial* nocapture readonly %nt) local_unnamed_addr #0 !dbg !7 {
+ entry:
+ tail call void @llvm.dbg.declare(metadata %struct.NonTrivial* %nt, metadata !20, metadata !DIExpression()), !dbg !21
+ tail call void asm sideeffect "", "~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{dirflag},~{fpsr},~{flags}"() #2, !dbg !22, !srcloc !23
+ %i1 = bitcast %struct.NonTrivial* %nt to i32*, !dbg !24
+ %0 = load i32, i32* %i1, align 4, !dbg !24, !tbaa !25
+ ret i32 %0, !dbg !30
+ }
+
+ ; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
+ declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+ attributes #0 = { nounwind uwtable }
+ attributes #1 = { nocallback nofree nosync nounwind readnone speculatable willreturn }
+ attributes #2 = { nounwind }
+
+ !llvm.dbg.cu = !{!0}
+ !llvm.module.flags = !{!3, !4, !5}
+ !llvm.ident = !{!6}
+
+ !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 6.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+ !1 = !DIFile(filename: "t.cpp", directory: "C:\\src\\llvm-project\\build")
+ !2 = !{}
+ !3 = !{i32 2, !"Dwarf Version", i32 4}
+ !4 = !{i32 2, !"Debug Info Version", i32 3}
+ !5 = !{i32 1, !"wchar_size", i32 4}
+ !6 = !{!"clang version 6.0.0 "}
+ !7 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foo10NonTrivial", scope: !1, file: !1, line: 10, type: !8, scopeLine: 10, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !19)
+ !8 = !DISubroutineType(types: !9)
+ !9 = !{!10, !11}
+ !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+ !11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "NonTrivial", file: !1, line: 5, size: 32, elements: !12, identifier: "_ZTS10NonTrivial")
+ !12 = !{!13, !14, !18}
+ !13 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !11, file: !1, line: 8, baseType: !10, size: 32)
+ !14 = !DISubprogram(name: "NonTrivial", scope: !11, file: !1, line: 6, type: !15, scopeLine: 6, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized)
+ !15 = !DISubroutineType(types: !16)
+ !16 = !{null, !17}
+ !17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+ !18 = !DISubprogram(name: "~NonTrivial", scope: !11, file: !1, line: 7, type: !15, scopeLine: 7, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized)
+ !19 = !{!20}
+ !20 = !DILocalVariable(name: "nt", arg: 1, scope: !7, file: !1, line: 10, type: !11)
+ !21 = !DILocation(line: 10, column: 20, scope: !7)
+ !22 = !DILocation(line: 11, column: 3, scope: !7)
+ !23 = !{i32 -2147471481}
+ !24 = !DILocation(line: 12, column: 13, scope: !7)
+ !25 = !{!26, !27, i64 0}
+ !26 = !{!"_ZTS10NonTrivial", !27, i64 0}
+ !27 = !{!"int", !28, i64 0}
+ !28 = !{!"omnipotent char", !29, i64 0}
+ !29 = !{!"Simple C++ TBAA"}
+ !30 = !DILocation(line: 12, column: 3, scope: !7)
+
+...
+---
+name: _Z3foo10NonTrivial
+alignment: 16
+tracksRegLiveness: true
+tracksDebugUserValues: true
+liveins:
+ - { reg: '$rdi' }
+frameInfo:
+ stackSize: 48
+ offsetAdjustment: -48
+ maxAlignment: 8
+ maxCallFrameSize: 0
+ cvBytesOfCalleeSavedRegisters: 48
+fixedStack:
+ - { id: 0, type: spill-slot, offset: -56, size: 8, alignment: 8, callee-saved-register: '$rbx' }
+ - { id: 1, type: spill-slot, offset: -48, size: 8, alignment: 16, callee-saved-register: '$r12' }
+ - { id: 2, type: spill-slot, offset: -40, size: 8, alignment: 8, callee-saved-register: '$r13' }
+ - { id: 3, type: spill-slot, offset: -32, size: 8, alignment: 16, callee-saved-register: '$r14' }
+ - { id: 4, type: spill-slot, offset: -24, size: 8, alignment: 8, callee-saved-register: '$r15' }
+ - { id: 5, type: spill-slot, offset: -16, size: 8, alignment: 16, callee-saved-register: '$rbp' }
+stack:
+ - { id: 0, type: spill-slot, offset: -64, size: 8, alignment: 8 }
+machineFunctionInfo: {}
+body: |
+ bb.0.entry:
+ liveins: $rdi, $rbp, $r15, $r14, $r13, $r12, $rbx
+
+ DBG_VALUE $rdi, 0, !20, !DIExpression(), debug-location !21
+ ; CHECK: DBG_VALUE $rdi,
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, $rdi :: (store (s64) into %stack.0)
+ $rdi = MOV64ri 0
+ ; CHECK: DBG_VALUE $rsp, 0, ![[VARNUM]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref),
+
+ $rdi = MOV64ri 0 ; dummy instr for the above DBG_VALUE to cover in a loclist
+
+ DBG_VALUE $rdi, 0, !20, !DIExpression(DW_OP_constu, 8, DW_OP_plus), debug-location !21
+ ; CHECK: DBG_VALUE $rdi,
+ MOV64mr $rsp, 1, $noreg, -8, $noreg, $rdi :: (store (s64) into %stack.0)
+ $rdi = MOV64ri 0
+ ; CHECK: DBG_VALUE $rsp, 0, ![[VARNUM]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_constu, 8, DW_OP_plus),
+
+ renamable $rax = MOV64rm $rsp, 1, $noreg, -8, $noreg :: (load (s64) from %stack.0)
+ renamable $eax = MOV32rm killed renamable $rax, 1, $noreg, 0, $noreg, debug-location !24 :: (load (s32) from %ir.i1, !tbaa !25)
+ RET64 $eax, debug-location !30
+
+...
diff --git a/llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir b/llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir
index 65c57761621bd..ec99617165061 100644
--- a/llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir
+++ b/llvm/test/DebugInfo/MIR/X86/live-debug-values-restore.mir
@@ -414,15 +414,12 @@ body: |
# This third function tests that complex expressions are spilt, and restored
# correctly within a basic block.
-# FIXME: the spilt location below is wrong, there should be a deref between
-# the spill-offset and the DW_OP_plus_uconst.
-
# CHECK-LABEL: name: h
# CHECK-LABEL: bb.0.entry:
# CHECK: DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
# CHECK-LABEL: bb.1.if.then:
# CHECK: DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
-# CHECK: DBG_VALUE $rsp, 0, ![[RVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK: DBG_VALUE $rsp, $noreg, ![[RVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
# CHECK: DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
# CHECK-LABEL: bb.2.if.end:
# CHECK: DBG_VALUE $rdi, $noreg, ![[RVAR]], !DIExpression(DW_OP_plus_uconst, 1)
@@ -527,8 +524,6 @@ body: |
# bb 2 and 3, neither of which modifies the stack loc. The exit block (3)
# should still be tracking the spill, and restore it on stack load.
-# FIXME: this test too contains a broken spill location.
-
# Summary: loc is in $rdi in bb0, spills to stack in bb1, remains in stack
# in bb2, starts in stack then loaded in bb3.
@@ -537,11 +532,11 @@ body: |
# CHECK: DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
# CHECK-LABEL: bb.1.foo:
# CHECK: DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
-# CHECK: DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK: DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
# CHECK-LABEL: bb.2.if.then:
-# CHECK: DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK: DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
# CHECK-LABEL: bb.3.if.end
-# CHECK: DBG_VALUE $rsp, 0, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_plus_uconst, 1)
+# CHECK: DBG_VALUE $rsp, $noreg, ![[SVAR]], !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref, DW_OP_plus_uconst, 1)
# CHECK: DBG_VALUE $rdi, $noreg, ![[SVAR]], !DIExpression(DW_OP_plus_uconst, 1)
name: i
alignment: 16
diff --git a/llvm/test/DebugInfo/MIR/X86/livedebugvalues_load_in_loop.mir b/llvm/test/DebugInfo/MIR/X86/livedebugvalues_load_in_loop.mir
index dd0288ddadf0a..95d2c879f09b6 100644
--- a/llvm/test/DebugInfo/MIR/X86/livedebugvalues_load_in_loop.mir
+++ b/llvm/test/DebugInfo/MIR/X86/livedebugvalues_load_in_loop.mir
@@ -52,7 +52,7 @@
!3 = !{!4}
!4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
!5 = distinct !DIGlobalVariable(name: "start", scope: !0, file: !1, line: 4, type: !6, isLocal: false, isDefinition: true)
- !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+ !6 = !DIBasicType(name: "int", size: 64, encoding: DW_ATE_signed)
!7 = !{i32 2, !"Dwarf Version", i32 4}
!8 = !{i32 2, !"Debug Info Version", i32 3}
!9 = !{i32 1, !"wchar_size", i32 2}
More information about the llvm-commits
mailing list