[llvm] [SROA] Fix debug locations for variables with non-zero offsets (PR #97750)
Orlando Cazalet-Hyams via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 4 08:54:17 PDT 2024
https://github.com/OCHyams created https://github.com/llvm/llvm-project/pull/97750
```
Fixes https://github.com/llvm/llvm-project/issues/61981 by adjusting variable location offsets (in the DIExpression) when
splittign allocas.
AKA Fix debug locations for C++ structured bindings in SROA.
NOTE: There's still a bug in mem2reg which generates incorrect locations in some
situations: if the variable fragment has an offset into the new (split) alloca,
mem2reg will fail to convert that into a bit shift (the location contains a
garbage offset). That's not addressed here.
insertNewDbgInst - Now takes the address-expression and FragmentInfo as
serperate parameters because unlike dbg_declares dbg_assigns want those to go
to different places. dbg_assign records put the variable fragment info in the
value expression only (whereas dbg_declare has only one expression so puts it
there - ideally this information wouldn't live in DIExpression, but that's
another issue).
MigrateOne - Modified to correctly compute the necessary offsets and fragment
adjustments. The previous implementation produced bogus locations for variables
with non-zero offsets. The changes replace most of the body of this lambda, so
it might be easier to review in a split-diff view and focus on the change as a
whole than to compare it to the old implementation.
This uses calculateFragmentIntersect and extractLeadingOffset added in previous
patches in this series, and createOrReplaceFragment described below.
createOrReplaceFragment - Similar to DIExpression::createFragmentExpression
except for 3 important distinctions:
1. The new fragment isn't relative to an existing fragment.
2. There are no checks on the the operation types because it is assumed
the location this expression is computing is not implicit (i.e., it's
always safe to create a fragment because arithmetic operations apply
to the address computation, not to an implicit value computation).
3. Existing extract_bits are modified independetly of fragment changes
using \p BitExtractOffset. A change to the fragment offset or size
may affect a bit extract. But a bit extract offset can change
independently of the fragment dimensions.
Returns the new expression, or nullptr if one couldn't be created. Ideally
this is only used to signal that a bit-extract has become zero-sized (and thus
the new debug record has no size and can be dropped), however, it fails for
other reasons too - see the FIXME below.
FIXME: To keep this patch NFC the function bails in situations that
DIExpression::createFragmentExpression fails in.E.g. when fragment and bit
extract sizes differ. These limitations can be removed in the future.
```
---
Based on top of https://github.com/llvm/llvm-project/pull/97705, https://github.com/llvm/llvm-project/pull/97719 and https://github.com/llvm/llvm-project/pull/97738. Ignore the first 3 commits, which are under review over there.
>From a2afaca93280247206f426539050fcaa1c1887d3 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 4 Jul 2024 00:08:06 +0100
Subject: [PATCH 1/4] [NFC] Add fragment-getting functions to DbgRecord
Patch [1/x] to fix structured bindings debug info in SROA.
Copy getFragment and getFragmentOrEntireVariable from DbgVariableIntrinsic.
Move FragmentInfo out of DIExpression and DebugInfoMetadata.h into a new file
DbgVariableFragmentInfo.h so it can be included into DebugProgramInstruction.h
without pulling in other includes and classes.
These functions will be used in subsequent patches.
Move FragmentInfo out of DIExpression
---
.../include/llvm/IR/DbgVariableFragmentInfo.h | 45 +++++++++++++++++++
llvm/include/llvm/IR/DebugInfoMetadata.h | 25 +----------
.../include/llvm/IR/DebugProgramInstruction.h | 14 ++++++
llvm/lib/IR/DebugProgramInstruction.cpp | 4 ++
4 files changed, 65 insertions(+), 23 deletions(-)
create mode 100644 llvm/include/llvm/IR/DbgVariableFragmentInfo.h
diff --git a/llvm/include/llvm/IR/DbgVariableFragmentInfo.h b/llvm/include/llvm/IR/DbgVariableFragmentInfo.h
new file mode 100644
index 0000000000000..40326d5792f9f
--- /dev/null
+++ b/llvm/include/llvm/IR/DbgVariableFragmentInfo.h
@@ -0,0 +1,45 @@
+//===- llvm/IR/DbgVariableFragmentInfo.h ------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Helper struct to describe a fragment of a debug variable.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_IR_DBGVARIABLEFRAGMENTINFO_H
+#define LLVM_IR_DBGVARIABLEFRAGMENTINFO_H
+
+#include <cstdint>
+
+namespace llvm {
+struct DbgVariableFragmentInfo {
+ DbgVariableFragmentInfo() = default;
+ DbgVariableFragmentInfo(uint64_t SizeInBits, uint64_t OffsetInBits)
+ : SizeInBits(SizeInBits), OffsetInBits(OffsetInBits) {}
+ uint64_t SizeInBits;
+ uint64_t OffsetInBits;
+ /// Return the index of the first bit of the fragment.
+ uint64_t startInBits() const { return OffsetInBits; }
+ /// Return the index of the bit after the end of the fragment, e.g. for
+ /// fragment offset=16 and size=32 return their sum, 48.
+ uint64_t endInBits() const { return OffsetInBits + SizeInBits; }
+
+ /// Returns a zero-sized fragment if A and B don't intersect.
+ static DbgVariableFragmentInfo intersect(DbgVariableFragmentInfo A,
+ DbgVariableFragmentInfo B) {
+ // Don't use std::max or min to avoid including <algorithm>.
+ uint64_t StartInBits =
+ A.OffsetInBits > B.OffsetInBits ? A.OffsetInBits : B.OffsetInBits;
+ uint64_t EndInBits =
+ A.endInBits() < B.endInBits() ? A.endInBits() : B.endInBits();
+ if (EndInBits <= StartInBits)
+ return {0, 0};
+ return DbgVariableFragmentInfo(EndInBits - StartInBits, StartInBits);
+ }
+};
+} // end namespace llvm
+
+#endif // LLVM_IR_DBGVARIABLEFRAGMENTINFO_H
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index 524945862e8d4..d953ce46efb30 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -21,6 +21,7 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/IR/Constants.h"
+#include "llvm/IR/DbgVariableFragmentInfo.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/PseudoProbe.h"
#include "llvm/Support/Casting.h"
@@ -2886,29 +2887,7 @@ class DIExpression : public MDNode {
/// Return whether there is exactly one operator and it is a DW_OP_deref;
bool isDeref() const;
- /// Holds the characteristics of one fragment of a larger variable.
- struct FragmentInfo {
- FragmentInfo() = default;
- FragmentInfo(uint64_t SizeInBits, uint64_t OffsetInBits)
- : SizeInBits(SizeInBits), OffsetInBits(OffsetInBits) {}
- uint64_t SizeInBits;
- uint64_t OffsetInBits;
- /// Return the index of the first bit of the fragment.
- uint64_t startInBits() const { return OffsetInBits; }
- /// Return the index of the bit after the end of the fragment, e.g. for
- /// fragment offset=16 and size=32 return their sum, 48.
- uint64_t endInBits() const { return OffsetInBits + SizeInBits; }
-
- /// Returns a zero-sized fragment if A and B don't intersect.
- static DIExpression::FragmentInfo intersect(DIExpression::FragmentInfo A,
- DIExpression::FragmentInfo B) {
- uint64_t StartInBits = std::max(A.OffsetInBits, B.OffsetInBits);
- uint64_t EndInBits = std::min(A.endInBits(), B.endInBits());
- if (EndInBits <= StartInBits)
- return {0, 0};
- return DIExpression::FragmentInfo(EndInBits - StartInBits, StartInBits);
- }
- };
+ using FragmentInfo = DbgVariableFragmentInfo;
/// Return the number of bits that have an active value, i.e. those that
/// aren't known to be zero/sign (depending on the type of Var) and which
diff --git a/llvm/include/llvm/IR/DebugProgramInstruction.h b/llvm/include/llvm/IR/DebugProgramInstruction.h
index ed8081a3cad19..fd93dd9b89f7c 100644
--- a/llvm/include/llvm/IR/DebugProgramInstruction.h
+++ b/llvm/include/llvm/IR/DebugProgramInstruction.h
@@ -50,6 +50,7 @@
#include "llvm/ADT/ilist.h"
#include "llvm/ADT/ilist_node.h"
#include "llvm/ADT/iterator.h"
+#include "llvm/IR/DbgVariableFragmentInfo.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/SymbolTableListTraits.h"
@@ -460,6 +461,19 @@ class DbgVariableRecord : public DbgRecord, protected DebugValueUser {
resetDebugValue(0, NewLocation);
}
+ std::optional<DbgVariableFragmentInfo> getFragment() const;
+ /// Get the FragmentInfo for the variable if it exists, otherwise return a
+ /// FragmentInfo that covers the entire variable if the variable size is
+ /// known, otherwise return a zero-sized fragment.
+ DbgVariableFragmentInfo getFragmentOrEntireVariable() const {
+ DbgVariableFragmentInfo VariableSlice(0, 0);
+ // Get the fragment or variable size, or zero.
+ if (auto Sz = getFragmentSizeInBits())
+ VariableSlice.SizeInBits = *Sz;
+ if (auto Frag = getFragment())
+ VariableSlice.OffsetInBits = Frag->OffsetInBits;
+ return VariableSlice;
+ }
/// Get the size (in bits) of the variable, or fragment of the variable that
/// is described.
std::optional<uint64_t> getFragmentSizeInBits() const;
diff --git a/llvm/lib/IR/DebugProgramInstruction.cpp b/llvm/lib/IR/DebugProgramInstruction.cpp
index 9a4926c81dca2..1711fd6943517 100644
--- a/llvm/lib/IR/DebugProgramInstruction.cpp
+++ b/llvm/lib/IR/DebugProgramInstruction.cpp
@@ -371,6 +371,10 @@ bool DbgVariableRecord::isKillLocation() const {
any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
}
+std::optional<DbgVariableFragmentInfo> DbgVariableRecord::getFragment() const {
+ return getExpression()->getFragmentInfo();
+}
+
std::optional<uint64_t> DbgVariableRecord::getFragmentSizeInBits() const {
if (auto Fragment = getExpression()->getFragmentInfo())
return Fragment->SizeInBits;
>From 9a5bd0a697a4c0358662261b305391ec798f7327 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 4 Jul 2024 02:31:40 +0100
Subject: [PATCH 2/4] [NFC] Add DIExpression::extractLeadingOffset
Patch [2/x] to fix structured bindings debug info in SROA.
It extracts a constant offset from the DIExpression if there is one and fills
RemainingOps with the ops that come after it.
This function will be used in a subsequent patch.
---
llvm/include/llvm/IR/DebugInfoMetadata.h | 10 +++
llvm/lib/IR/DebugInfoMetadata.cpp | 39 ++++++++++++
llvm/unittests/IR/MetadataTest.cpp | 78 ++++++++++++++++++++++++
3 files changed, 127 insertions(+)
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index d953ce46efb30..a316c7bde64b0 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -2982,6 +2982,16 @@ class DIExpression : public MDNode {
/// return true with an offset of zero.
bool extractIfOffset(int64_t &Offset) const;
+ /// Assuming that the expression operates on an address, extract a constant
+ /// offset and the succsessive ops. Return false if the expression contains
+ /// any incompatible ops (including non-zero DW_OP_LLVM_args - only a single
+ /// address operand to the expression is permitted).
+ ///
+ /// We don't try very hard to interpret the expression because we assume that
+ /// foldConstantMath has canonicalized the expression.
+ bool extractLeadingOffset(int64_t &Offset,
+ SmallVectorImpl<uint64_t> &RemainingOps) const;
+
/// Returns true iff this DIExpression contains at least one instance of
/// `DW_OP_LLVM_arg, n` for all n in [0, N).
bool hasAllLocationOps(unsigned N) const;
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index 161a30dfb3828..f800f324d05ac 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -1760,6 +1760,45 @@ bool DIExpression::extractIfOffset(int64_t &Offset) const {
return false;
}
+bool DIExpression::extractLeadingOffset(
+ int64_t &Offset, SmallVectorImpl<uint64_t> &RemainingOps) const {
+ Offset = 0;
+ RemainingOps.clear();
+
+ auto SingleLocEltsOpt = getSingleLocationExpressionElements();
+ if (!SingleLocEltsOpt)
+ return false;
+
+ auto ExprOpEnd = expr_op_iterator(SingleLocEltsOpt->end());
+ auto ExprOpIt = expr_op_iterator(SingleLocEltsOpt->begin());
+ while (ExprOpIt != ExprOpEnd) {
+ uint64_t Op = ExprOpIt->getOp();
+ if (Op == dwarf::DW_OP_deref || Op == dwarf::DW_OP_deref_size ||
+ Op == dwarf::DW_OP_deref_type || Op == dwarf::DW_OP_LLVM_fragment ||
+ Op == dwarf::DW_OP_LLVM_extract_bits_zext ||
+ Op == dwarf::DW_OP_LLVM_extract_bits_sext) {
+ break;
+ } else if (Op == dwarf::DW_OP_plus_uconst) {
+ Offset += ExprOpIt->getArg(0);
+ } else if (Op == dwarf::DW_OP_constu) {
+ uint64_t Value = ExprOpIt->getArg(0);
+ ++ExprOpIt;
+ if (ExprOpIt->getOp() == dwarf::DW_OP_plus)
+ Offset += Value;
+ else if (ExprOpIt->getOp() == dwarf::DW_OP_minus)
+ Offset -= Value;
+ else
+ return false;
+ } else {
+ // Not a const plus/minus operation or deref.
+ return false;
+ }
+ ++ExprOpIt;
+ }
+ RemainingOps.append(ExprOpIt.getBase(), ExprOpEnd.getBase());
+ return true;
+}
+
bool DIExpression::hasAllLocationOps(unsigned N) const {
SmallDenseSet<uint64_t, 4> SeenOps;
for (auto ExprOp : expr_ops())
diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp
index 3f766a414f08f..29c9bd0a4cd9a 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -3870,6 +3870,84 @@ TEST_F(DIExpressionTest, createFragmentExpression) {
#undef EXPECT_INVALID_FRAGMENT
}
+TEST_F(DIExpressionTest, extractLeadingOffset) {
+ int64_t Offset;
+ SmallVector<uint64_t> Remaining;
+ using namespace dwarf;
+#define OPS(...) SmallVector<uint64_t>(ArrayRef<uint64_t>{__VA_ARGS__})
+#define EXTRACT_FROM(...) \
+ DIExpression::get(Context, {__VA_ARGS__}) \
+ ->extractLeadingOffset(Offset, Remaining)
+ // Test the number of expression inputs
+ // ------------------------------------
+ //
+ // Single location expressions are permitted.
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_plus_uconst, 2));
+ EXPECT_EQ(Offset, 2);
+ EXPECT_EQ(Remaining.size(), 0);
+ // This is also a single-location.
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 2));
+ EXPECT_EQ(Offset, 2);
+ EXPECT_EQ(Remaining.size(), 0);
+ // Variadic locations are not permitted. A non-zero arg is assumed to
+ // indicate multiple inputs.
+ EXPECT_FALSE(EXTRACT_FROM(DW_OP_LLVM_arg, 1));
+ EXPECT_FALSE(EXTRACT_FROM(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus));
+
+ // Test offsets expressions
+ // ------------------------
+ EXPECT_TRUE(EXTRACT_FROM());
+ EXPECT_EQ(Offset, 0);
+ EXPECT_EQ(Remaining.size(), 0u);
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_constu, 4, DW_OP_plus));
+ EXPECT_EQ(Offset, 4);
+ EXPECT_EQ(Remaining.size(), 0u);
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_constu, 2, DW_OP_minus));
+ EXPECT_EQ(Offset, -2);
+ EXPECT_EQ(Remaining.size(), 0u);
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_plus_uconst, 8));
+ EXPECT_EQ(Offset, 8);
+ EXPECT_EQ(Remaining.size(), 0u);
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_plus_uconst, 4, DW_OP_constu, 2, DW_OP_minus));
+ EXPECT_EQ(Offset, 2);
+ EXPECT_EQ(Remaining.size(), 0u);
+
+ // Not all operations are permitted for simplicity. Can be added
+ // if needed in future.
+ EXPECT_FALSE(EXTRACT_FROM(DW_OP_constu, 2, DW_OP_mul));
+
+ // Test "remaining ops"
+ // --------------------
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_plus_uconst, 4, DW_OP_constu, 8, DW_OP_minus,
+ DW_OP_LLVM_fragment, 0, 32));
+ EXPECT_EQ(Remaining, OPS(DW_OP_LLVM_fragment, 0, 32));
+ EXPECT_EQ(Offset, -4);
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_deref));
+ EXPECT_EQ(Remaining, OPS(DW_OP_deref));
+ EXPECT_EQ(Offset, 0);
+
+ // Check things after the non-offset ops are added too.
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_plus_uconst, 2, DW_OP_deref_size, 4,
+ DW_OP_stack_value));
+ EXPECT_EQ(Remaining, OPS(DW_OP_deref_size, 4, DW_OP_stack_value));
+ EXPECT_EQ(Offset, 2);
+
+ // DW_OP_deref_type isn't supported in LLVM so this currently fails.
+ EXPECT_FALSE(EXTRACT_FROM(DW_OP_deref_type, 0));
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_LLVM_extract_bits_zext, 0, 8));
+ EXPECT_EQ(Remaining, OPS(DW_OP_LLVM_extract_bits_zext, 0, 8));
+
+ EXPECT_TRUE(EXTRACT_FROM(DW_OP_LLVM_extract_bits_sext, 4, 4));
+ EXPECT_EQ(Remaining, OPS(DW_OP_LLVM_extract_bits_sext, 4, 4));
+#undef EXTRACT_FROM
+}
+
TEST_F(DIExpressionTest, convertToUndefExpression) {
#define EXPECT_UNDEF_OPS_EQUAL(TestExpr, Expected) \
do { \
>From e1c71d81d27bddc7fc91d7538cf05778f4585a9b Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 4 Jul 2024 05:23:22 +0100
Subject: [PATCH 3/4] [NFC] Add DIExpression::calculateFragmentIntersect
Patch [3/x] to fix structured bindings debug info in SROA.
This function computes a fragment, bit-extract operation if needed, and new
constant offset to describe a part of a variable covered by some memory.
This generalises, simplifies, and replaces at::calculateFragmentIntersect. That
version is still used as a wrapper for now though to keep this change NFC.
The new version takes doesn't have a DbgRecord parameter, instead using an
explicit address and address offset. The old version only operates on
dbg_assigns and this change means it can also operate on dbg_declare records
easily, which it will do in a subsequent patch.
The new version has a new out-param OffsetFromLocationInBits which is set to the
difference between the first bit of the variable location and the first bit of
the memory slice. This will be used in a subsequent patch in SROA to determine
the new offset to use in the address expression after splitting an alloca.
---
llvm/include/llvm/IR/DebugInfoMetadata.h | 37 +++++
llvm/lib/IR/DebugInfo.cpp | 181 ++++-------------------
llvm/lib/IR/DebugInfoMetadata.cpp | 69 +++++++++
3 files changed, 134 insertions(+), 153 deletions(-)
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index a316c7bde64b0..e50ff1b9f286c 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -3084,6 +3084,43 @@ class DIExpression : public MDNode {
return 0;
}
+ /// Computes a fragment, bit-extract operation if needed, and new constant
+ /// offset to describe a part of a variable covered by some memory.
+ ///
+ /// The memory region starts at:
+ /// \p SliceStart + \p SliceOffsetInBits
+ /// And is size:
+ /// \p SliceSizeInBits
+ ///
+ /// The location of the existing variable fragment \p VarFrag is:
+ /// \p DbgPtr + \p DbgPtrOffsetInBits + \p DbgExtractOffsetInBits.
+ ///
+ /// It is intended that these arguments are derived from a debug record:
+ /// - \p DbgPtr is the (single) DIExpression operand.
+ /// - \p DbgPtrOffsetInBits is the constant offset applied to \p DbgPtr.
+ /// - \p DbgExtractOffsetInBits is the offset from a
+ /// DW_OP_LLVM_bit_extract_[sz]ext operation.
+ ///
+ /// Results and return value:
+ /// - Return false if the result can't be calculated for any reason.
+ /// - \p Result is set to nullopt if the intersect equals \p VarFarg.
+ /// - \p Result contains a zero-sized fragment if there's no intersect.
+ /// - \p OffsetFromLocationInBits is set to the difference between the first
+ /// bit of the variable location and the first bit of the slice. The
+ /// magnitude of a negative value therefore indicates the number of bits
+ /// into the variable fragment that the memory region begins.
+ ///
+ /// We don't pass in a debug record directly to get the constituent parts
+ /// and offsets because different debug records store the information in
+ /// different places (dbg_assign has two DIExpressions - one contains the
+ /// fragment info for the entire intrinsic).
+ static bool calculateFragmentIntersect(
+ const DataLayout &DL, const Value *SliceStart, uint64_t SliceOffsetInBits,
+ uint64_t SliceSizeInBits, const Value *DbgPtr, int64_t DbgPtrOffsetInBits,
+ int64_t DbgExtractOffsetInBits, DIExpression::FragmentInfo VarFrag,
+ std::optional<DIExpression::FragmentInfo> &Result,
+ int64_t &OffsetFromLocationInBits);
+
using ExtOps = std::array<uint64_t, 6>;
/// Returns the ops for a zero- or sign-extension in a DIExpression.
diff --git a/llvm/lib/IR/DebugInfo.cpp b/llvm/lib/IR/DebugInfo.cpp
index 7f1489ebbd740..d86e7c7da2d63 100644
--- a/llvm/lib/IR/DebugInfo.cpp
+++ b/llvm/lib/IR/DebugInfo.cpp
@@ -1864,181 +1864,56 @@ void at::deleteAll(Function *F) {
DVR->eraseFromParent();
}
-/// Get the FragmentInfo for the variable if it exists, otherwise return a
-/// FragmentInfo that covers the entire variable if the variable size is
-/// known, otherwise return a zero-sized fragment.
-static DIExpression::FragmentInfo
-getFragmentOrEntireVariable(const DbgVariableRecord *DVR) {
- DIExpression::FragmentInfo VariableSlice(0, 0);
- // Get the fragment or variable size, or zero.
- if (auto Sz = DVR->getFragmentSizeInBits())
- VariableSlice.SizeInBits = *Sz;
- if (auto Frag = DVR->getExpression()->getFragmentInfo())
- VariableSlice.OffsetInBits = Frag->OffsetInBits;
- return VariableSlice;
-}
-
-static DIExpression::FragmentInfo
-getFragmentOrEntireVariable(const DbgVariableIntrinsic *DVI) {
- DIExpression::FragmentInfo VariableSlice(0, 0);
- // Get the fragment or variable size, or zero.
- if (auto Sz = DVI->getFragmentSizeInBits())
- VariableSlice.SizeInBits = *Sz;
- if (auto Frag = DVI->getExpression()->getFragmentInfo())
- VariableSlice.OffsetInBits = Frag->OffsetInBits;
- return VariableSlice;
-}
+/// FIXME: Remove this wrapper function and call
+/// DIExpression::calculateFragmentIntersect directly.
template <typename T>
bool calculateFragmentIntersectImpl(
const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits,
uint64_t SliceSizeInBits, const T *AssignRecord,
std::optional<DIExpression::FragmentInfo> &Result) {
- // There are multiple offsets at play in this function, so let's break it
- // down. Starting with how variables may be stored in allocas:
- //
- // 1 Simplest case: variable is alloca sized and starts at offset 0.
- // 2 Variable is larger than the alloca: the alloca holds just a part of it.
- // 3 Variable is smaller than the alloca: the alloca may hold multiple
- // variables.
- //
- // Imagine we have a store to the entire alloca. In case (3) the store
- // affects bits outside of the bounds of each variable. In case (2), where
- // the alloca holds the Xth bit to the Yth bit of a variable, the
- // zero-offset store doesn't represent an assignment at offset zero to the
- // variable. It is an assignment to offset X.
- //
- // # Example 1
- // Obviously, not all stores are alloca-sized and have zero offset. Imagine
- // the lower 32 bits of this store are dead and are going to be DSEd:
- //
- // store i64 %v, ptr %dest, !DIAssignID !1
- // dbg.assign(..., !DIExpression(fragment, 128, 32), !1, %dest,
- // !DIExpression(DW_OP_plus_uconst, 4))
- //
- // Goal: Given our dead bits at offset:0 size:32 for the store, determine the
- // part of the variable, which fits in the fragment expressed by the
- // dbg.assign, that has been killed, if any.
- //
- // calculateFragmentIntersect(..., SliceOffsetInBits=0,
- // SliceSizeInBits=32, Dest=%dest, Assign=dbg.assign)
- //
- // Drawing the store (s) in memory followed by the shortened version ($),
- // then the dbg.assign (d), with the fragment information on a separate scale
- // underneath:
- //
- // Memory
- // offset
- // from
- // dest 0 63
- // | |
- // s[######] - Original stores 64 bits to Dest.
- // $----[##] - DSE says the lower 32 bits are dead, to be removed.
- // d [##] - Assign's address-modifying expression adds 4 bytes to
- // dest.
- // Variable | |
- // Fragment 128|
- // Offsets 159
- //
- // The answer is achieved in a few steps:
- // 1. Add the fragment offset to the store offset:
- // SliceOffsetInBits:0 + VarFrag.OffsetInBits:128 = 128
- //
- // 2. Subtract the address-modifying expression offset plus difference
- // between d.address and dest:
- // 128 - (expression_offset:32 + (d.address - dest):0) = 96
- //
- // 3. That offset along with the store size (32) represents the bits of the
- // variable that'd be affected by the store. Call it SliceOfVariable.
- // Intersect that with Assign's fragment info:
- // SliceOfVariable ∩ Assign_fragment = none
- //
- // In this case: none of the dead bits of the store affect Assign.
- //
- // # Example 2
- // Similar example with the same goal. This time the upper 16 bits
- // of the store are going to be DSE'd.
- //
- // store i64 %v, ptr %dest, !DIAssignID !1
- // dbg.assign(..., !DIExpression(fragment, 128, 32), !1, %dest,
- // !DIExpression(DW_OP_plus_uconst, 4))
- //
- // calculateFragmentIntersect(..., SliceOffsetInBits=48,
- // SliceSizeInBits=16, Dest=%dest, Assign=dbg.assign)
- //
- // Memory
- // offset
- // from
- // dest 0 63
- // | |
- // s[######] - Original stores 64 bits to Dest.
- // $[####]-- - DSE says the upper 16 bits are dead, to be removed.
- // d [##] - Assign's address-modifying expression adds 4 bytes to
- // dest.
- // Variable | |
- // Fragment 128|
- // Offsets 159
- //
- // Using the same steps in the first example:
- // 1. SliceOffsetInBits:48 + VarFrag.OffsetInBits:128 = 176
- // 2. 176 - (expression_offset:32 + (d.address - dest):0) = 144
- // 3. SliceOfVariable offset = 144, size = 16:
- // SliceOfVariable ∩ Assign_fragment = (offset: 144, size: 16)
- // SliceOfVariable tells us the bits of the variable described by Assign that
- // are affected by the DSE.
+ // No overlap if this DbgRecord describes a killed location.
if (AssignRecord->isKillAddress())
return false;
- DIExpression::FragmentInfo VarFrag =
- getFragmentOrEntireVariable(AssignRecord);
- if (VarFrag.SizeInBits == 0)
- return false; // Variable size is unknown.
-
- // Calculate the difference between Dest and the dbg.assign address +
- // address-modifying expression.
- int64_t PointerOffsetInBits;
- {
- auto DestOffsetInBytes =
- AssignRecord->getAddress()->getPointerOffsetFrom(Dest, DL);
- if (!DestOffsetInBytes)
- return false; // Can't calculate difference in addresses.
-
- int64_t ExprOffsetInBytes;
- if (!AssignRecord->getAddressExpression()->extractIfOffset(
- ExprOffsetInBytes))
- return false;
+ int64_t AddrOffsetInBytes;
+ SmallVector<uint64_t> PostOffsetOps; //< Unused.
+ // Bail if we can't find a constant offset (or none) in the expression.
+ if (!AssignRecord->getAddressExpression()->extractLeadingOffset(
+ AddrOffsetInBytes, PostOffsetOps))
+ return false;
+ int64_t AddrOffsetInBits = AddrOffsetInBytes * 8;
- int64_t PointerOffsetInBytes = *DestOffsetInBytes + ExprOffsetInBytes;
- PointerOffsetInBits = PointerOffsetInBytes * 8;
- }
+ Value *Addr = AssignRecord->getAddress();
+ // FIXME: It may not always be zero.
+ int64_t BitExtractOffsetInBits = 0;
+ DIExpression::FragmentInfo VarFrag =
+ AssignRecord->getFragmentOrEntireVariable();
- // Adjust the slice offset so that we go from describing the a slice
- // of memory to a slice of the variable.
- int64_t NewOffsetInBits =
- SliceOffsetInBits + VarFrag.OffsetInBits - PointerOffsetInBits;
- if (NewOffsetInBits < 0)
- return false; // Fragment offsets can only be positive.
- DIExpression::FragmentInfo SliceOfVariable(SliceSizeInBits, NewOffsetInBits);
- // Intersect the variable slice with AssignRecord's fragment to trim it down
- // to size.
- DIExpression::FragmentInfo TrimmedSliceOfVariable =
- DIExpression::FragmentInfo::intersect(SliceOfVariable, VarFrag);
- if (TrimmedSliceOfVariable == VarFrag)
- Result = std::nullopt;
- else
- Result = TrimmedSliceOfVariable;
- return true;
+ int64_t OffsetFromLocationInBits; //< Unused.
+ return DIExpression::calculateFragmentIntersect(
+ DL, Dest, SliceOffsetInBits, SliceSizeInBits, Addr, AddrOffsetInBits,
+ BitExtractOffsetInBits, VarFrag, Result, OffsetFromLocationInBits);
}
+
+/// FIXME: Remove this wrapper function and call
+/// DIExpression::calculateFragmentIntersect directly.
bool at::calculateFragmentIntersect(
const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits,
uint64_t SliceSizeInBits, const DbgAssignIntrinsic *DbgAssign,
std::optional<DIExpression::FragmentInfo> &Result) {
+
return calculateFragmentIntersectImpl(DL, Dest, SliceOffsetInBits,
SliceSizeInBits, DbgAssign, Result);
}
+
+/// FIXME: Remove this wrapper function and call
+/// DIExpression::calculateFragmentIntersect directly.
bool at::calculateFragmentIntersect(
const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits,
uint64_t SliceSizeInBits, const DbgVariableRecord *DVRAssign,
std::optional<DIExpression::FragmentInfo> &Result) {
+ // FIXME: Remove this wrapper function and call
+ // DIExpression::calculateFragmentIntersect directly.
return calculateFragmentIntersectImpl(DL, Dest, SliceOffsetInBits,
SliceSizeInBits, DVRAssign, Result);
}
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index f800f324d05ac..5f0f620684b18 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -2091,6 +2091,75 @@ std::optional<DIExpression *> DIExpression::createFragmentExpression(
return DIExpression::get(Expr->getContext(), Ops);
}
+/// See declaration for more info.
+bool DIExpression::calculateFragmentIntersect(
+ const DataLayout &DL, const Value *SliceStart, uint64_t SliceOffsetInBits,
+ uint64_t SliceSizeInBits, const Value *DbgPtr, int64_t DbgPtrOffsetInBits,
+ int64_t DbgExtractOffsetInBits, DIExpression::FragmentInfo VarFrag,
+ std::optional<DIExpression::FragmentInfo> &Result,
+ int64_t &OffsetFromLocationInBits) {
+
+ if (VarFrag.SizeInBits == 0)
+ return false; // Variable size is unknown.
+
+ // Difference between mem slice start and the dbg location start.
+ // 0 4 8 12 16 ...
+ // | |
+ // dbg location start
+ // |
+ // mem slice start
+ // Here MemStartRelToDbgStartInBits is 8. Note this can be negative.
+ int64_t MemStartRelToDbgStartInBits;
+ {
+ auto MemOffsetFromDbgInBytes = SliceStart->getPointerOffsetFrom(DbgPtr, DL);
+ if (!MemOffsetFromDbgInBytes)
+ return false; // Can't calculate difference in addresses.
+ // Difference between the pointers.
+ MemStartRelToDbgStartInBits = *MemOffsetFromDbgInBytes * 8;
+ // Add the difference of the offsets.
+ MemStartRelToDbgStartInBits +=
+ SliceOffsetInBits - (DbgPtrOffsetInBits + DbgExtractOffsetInBits);
+ }
+
+ // Out-param. Invert offset to get offset from debug location.
+ OffsetFromLocationInBits = -MemStartRelToDbgStartInBits;
+
+ // Check if the variable fragment sits outside (before) this memory slice.
+ int64_t MemEndRelToDbgStart = MemStartRelToDbgStartInBits + SliceSizeInBits;
+ if (MemEndRelToDbgStart < 0) {
+ Result = {0, 0}; // Out-param.
+ return true;
+ }
+
+ // Work towards creating SliceOfVariable which is the bits of the variable
+ // that the memory region covers.
+ // 0 4 8 12 16 ...
+ // | |
+ // dbg location start with VarFrag offset=32
+ // |
+ // mem slice start: SliceOfVariable offset=40
+ int64_t MemStartRelToFragInBits =
+ MemStartRelToDbgStartInBits + VarFrag.OffsetInBits;
+ int64_t MemEndRelToFragInBits = MemStartRelToFragInBits + SliceSizeInBits;
+ // If the memory region starts before the debug location the fragment
+ // offset would be negative, which we can't encode. Limit those to 0. This
+ // is fine becausethose bits necessarily don't overlap with the variable
+ // fragment.
+ int64_t MemFragStart = std::max<int64_t>(0, MemStartRelToFragInBits);
+ int64_t MemFragSize =
+ std::max<int64_t>(0, MemEndRelToFragInBits - MemFragStart);
+ DIExpression::FragmentInfo SliceOfVariable(MemFragSize, MemFragStart);
+
+ // Intersect the memory region fragment with the variable location fragment.
+ DIExpression::FragmentInfo TrimmedSliceOfVariable =
+ DIExpression::FragmentInfo::intersect(SliceOfVariable, VarFrag);
+ if (TrimmedSliceOfVariable == VarFrag)
+ Result = std::nullopt; // Out-param.
+ else
+ Result = TrimmedSliceOfVariable; // Out-param.
+ return true;
+}
+
std::pair<DIExpression *, const ConstantInt *>
DIExpression::constantFold(const ConstantInt *CI) {
// Copy the APInt so we can modify it.
>From 9fc478649d8d3166e6c2a3cb30097a50b20df6e7 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Thu, 4 Jul 2024 05:48:37 +0100
Subject: [PATCH 4/4] [SROA] Fix debug locations for variables with non-zero
offsets
Fixes #61981 by adjusting variable location offsets (in the DIExpression) when
splittign allocas.
AKA Fix debug locations for C++ structured bindings in SROA.
NOTE: There's still a bug in mem2reg which generates incorrect locations in some
situations: if the variable fragment has an offset into the new (split) alloca,
mem2reg will fail to convert that into a bit shift (the location contains a
garbage offset). That's not addressed here.
insertNewDbgInst - Now takes the address-expression and FragmentInfo as
serperate parameters because unlike dbg_declares dbg_assigns want those to go
to different places. dbg_assign records put the variable fragment info in the
value expression only (whereas dbg_declare has only one expression so puts it
there - ideally this information wouldn't live in DIExpression, but that's
another issue).
MigrateOne - Modified to correctly compute the necessary offsets and fragment
adjustments. The previous implementation produced bogus locations for variables
with non-zero offsets. The changes replace most of the body of this lambda, so
it might be easier to review in a split-diff view and focus on the change as a
whole than to compare it to the old implementation.
This uses calculateFragmentIntersect and extractLeadingOffset added in previous
patches in this series, and createOrReplaceFragment described below.
createOrReplaceFragment - Similar to DIExpression::createFragmentExpression
except for 3 important distinctions:
1. The new fragment isn't relative to an existing fragment.
2. There are no checks on the the operation types because it is assumed
the location this expression is computing is not implicit (i.e., it's
always safe to create a fragment because arithmetic operations apply
to the address computation, not to an implicit value computation).
3. Existing extract_bits are modified independetly of fragment changes
using \p BitExtractOffset. A change to the fragment offset or size
may affect a bit extract. But a bit extract offset can change
independently of the fragment dimensions.
Returns the new expression, or nullptr if one couldn't be created. Ideally
this is only used to signal that a bit-extract has become zero-sized (and thus
the new debug record has no size and can be dropped), however, it fails for
other reasons too - see the FIXME below.
FIXME: To keep this patch NFC the function bails in situations that
DIExpression::createFragmentExpression fails in.E.g. when fragment and bit
extract sizes differ. These limitations can be removed in the future.
---
llvm/lib/Transforms/Scalar/SROA.cpp | 327 ++++++++++++++----
.../sroa/var-sized-fragment.ll | 5 +-
.../DebugInfo/Generic/sroa-alloca-offset.ll | 256 ++++++++++++++
3 files changed, 521 insertions(+), 67 deletions(-)
create mode 100644 llvm/test/DebugInfo/Generic/sroa-alloca-offset.ll
diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp
index 4d8fd5d3b9f5c..7d9bab78c7e15 100644
--- a/llvm/lib/Transforms/Scalar/SROA.cpp
+++ b/llvm/lib/Transforms/Scalar/SROA.cpp
@@ -4967,32 +4967,207 @@ AllocaInst *SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS,
return NewAI;
}
-static void insertNewDbgInst(DIBuilder &DIB, DbgDeclareInst *Orig,
- AllocaInst *NewAddr, DIExpression *NewFragmentExpr,
- Instruction *BeforeInst) {
- DIB.insertDeclare(NewAddr, Orig->getVariable(), NewFragmentExpr,
+// There isn't a shared interface to get the "address" parts out of a
+// dbg.declare and dbg.assign, so provide some wrappers now for
+// both debug intrinsics and records.
+const Value *getAddress(const DbgVariableIntrinsic *DVI) {
+ if (const auto *DAI = dyn_cast<DbgAssignIntrinsic>(DVI))
+ return DAI->getAddress();
+ return cast<DbgDeclareInst>(DVI)->getAddress();
+}
+const Value *getAddress(const DbgVariableRecord *DVR) {
+ assert(DVR->getType() == DbgVariableRecord::LocationType::Declare ||
+ DVR->getType() == DbgVariableRecord::LocationType::Assign);
+ return DVR->getAddress();
+}
+bool isKillAddress(const DbgVariableIntrinsic *DVI) {
+ if (const auto *DAI = dyn_cast<DbgAssignIntrinsic>(DVI))
+ return DAI->isKillAddress();
+ return cast<DbgDeclareInst>(DVI)->isKillLocation();
+}
+bool isKillAddress(const DbgVariableRecord *DVR) {
+ assert(DVR->getType() == DbgVariableRecord::LocationType::Declare ||
+ DVR->getType() == DbgVariableRecord::LocationType::Assign);
+ if (DVR->getType() == DbgVariableRecord::LocationType::Assign)
+ return DVR->isKillAddress();
+ return DVR->isKillLocation();
+}
+const DIExpression *getAddressExpression(const DbgVariableIntrinsic *DVI) {
+ if (const auto *DAI = dyn_cast<DbgAssignIntrinsic>(DVI))
+ return DAI->getAddressExpression();
+ return cast<DbgDeclareInst>(DVI)->getExpression();
+}
+const DIExpression *getAddressExpression(const DbgVariableRecord *DVR) {
+ assert(DVR->getType() == DbgVariableRecord::LocationType::Declare ||
+ DVR->getType() == DbgVariableRecord::LocationType::Assign);
+ if (DVR->getType() == DbgVariableRecord::LocationType::Assign)
+ return DVR->getAddressExpression();
+ return DVR->getExpression();
+}
+
+/// Similar to DIExpression::createFragmentExpression except for 3 important
+/// distinctions:
+/// 1. The new fragment isn't relative to an existing fragment.
+/// 2. There are no checks on the the operation types because it is assumed
+/// the location this expression is computing is not implicit (i.e., it's
+/// always safe to create a fragment because arithmetic operations apply
+/// to the address computation, not to an implicit value computation).
+/// 3. Existing extract_bits are modified independetly of fragment changes
+/// using \p BitExtractOffset. A change to the fragment offset or size
+/// may affect a bit extract. But a bit extract offset can change
+/// independently of the fragment dimensions.
+///
+/// Returns the new expression, or nullptr if one couldn't be created.
+/// Ideally this is only used to signal that a bit-extract has become
+/// zero-sized (and thus the new debug record has no size and can be
+/// dropped), however, it fails for other reasons too - see the FIXME below.
+///
+/// FIXME: To keep the change that introduces this function NFC it bails
+/// in some situations unecessarily, e.g. when fragment and bit extract
+/// sizes differ.
+static DIExpression *createOrReplaceFragment(const DIExpression *Expr,
+ DIExpression::FragmentInfo Frag,
+ int64_t BitExtractOffset) {
+ SmallVector<uint64_t, 8> Ops;
+ bool HasFragment = false;
+ bool HasBitExtract = false;
+
+ for (auto &Op : Expr->expr_ops()) {
+ if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
+ HasFragment = true;
+ continue;
+ }
+ if (Op.getOp() == dwarf::DW_OP_LLVM_extract_bits_zext ||
+ Op.getOp() == dwarf::DW_OP_LLVM_extract_bits_sext) {
+ HasBitExtract = true;
+ int64_t ExtractOffsetInBits = Op.getArg(0);
+ int64_t ExtractSizeInBits = Op.getArg(1);
+
+ // DIExpression::createFragmentExpression doesn't know how to handle
+ // a fragment that is smaller than the extract. Copy the behaviour
+ // (bail) to avoid non-NFC changes.
+ // FIXME: Don't do this.
+ if (Frag.SizeInBits < uint64_t(ExtractSizeInBits))
+ return nullptr;
+
+ assert(BitExtractOffset <= 0);
+ int64_t AdjustedOffset = ExtractOffsetInBits + BitExtractOffset;
+
+ // DIExpression::createFragmentExpression doesn't know what to do
+ // if the new extract starts "outside" the existing one. Copy the
+ // behaviour (bail) to avoid non-NFC changes.
+ // FIXME: Don't do this.
+ if (AdjustedOffset < 0)
+ return nullptr;
+
+ Ops.push_back(Op.getOp());
+ Ops.push_back(std::max<int64_t>(0, AdjustedOffset));
+ Ops.push_back(ExtractSizeInBits);
+ continue;
+ }
+ Op.appendToVector(Ops);
+ }
+
+ // Unsupported by createFragmentExpression, so don't support it here yet to
+ // preserve NFC-ness.
+ if (HasFragment && HasBitExtract)
+ return nullptr;
+
+ if (!HasBitExtract) {
+ Ops.push_back(dwarf::DW_OP_LLVM_fragment);
+ Ops.push_back(Frag.OffsetInBits);
+ Ops.push_back(Frag.SizeInBits);
+ }
+ return DIExpression::get(Expr->getContext(), Ops);
+}
+
+/// Insert a new dbg.declare.
+/// \p Orig Original to copy debug loc and variable from.
+/// \p NewAddr Location's new base address.
+/// \p NewAddrExpr New expression to apply to address.
+/// \p BeforeInst Insert position.
+/// \p NewFragment New fragment (absolute, non-relative).
+/// \p BitExtractAdjustment Offset to apply to any extract_bits op.
+static void
+insertNewDbgInst(DIBuilder &DIB, DbgDeclareInst *Orig, AllocaInst *NewAddr,
+ DIExpression *NewAddrExpr, Instruction *BeforeInst,
+ std::optional<DIExpression::FragmentInfo> NewFragment,
+ int64_t BitExtractAdjustment) {
+ if (NewFragment)
+ NewAddrExpr = createOrReplaceFragment(NewAddrExpr, *NewFragment,
+ BitExtractAdjustment);
+ if (!NewAddrExpr)
+ return;
+
+ DIB.insertDeclare(NewAddr, Orig->getVariable(), NewAddrExpr,
Orig->getDebugLoc(), BeforeInst);
}
-static void insertNewDbgInst(DIBuilder &DIB, DbgAssignIntrinsic *Orig,
- AllocaInst *NewAddr, DIExpression *NewFragmentExpr,
- Instruction *BeforeInst) {
+
+/// Insert a new dbg.assign.
+/// \p Orig Original to copy debug loc, variable, value and value expression
+/// from.
+/// \p NewAddr Location's new base address.
+/// \p NewAddrExpr New expression to apply to address.
+/// \p BeforeInst Insert position.
+/// \p NewFragment New fragment (absolute, non-relative).
+/// \p BitExtractAdjustment Offset to apply to any extract_bits op.
+static void
+insertNewDbgInst(DIBuilder &DIB, DbgAssignIntrinsic *Orig, AllocaInst *NewAddr,
+ DIExpression *NewAddrExpr, Instruction *BeforeInst,
+ std::optional<DIExpression::FragmentInfo> NewFragment,
+ int64_t BitExtractAdjustment) {
(void)BeforeInst;
+
+ // A dbg.assign puts fragment info in the value expression only. The address
+ // expression has already been built: NewAddrExpr.
+ DIExpression *NewFragmentExpr = Orig->getExpression();
+ if (NewFragment)
+ NewFragmentExpr = createOrReplaceFragment(NewFragmentExpr, *NewFragment,
+ BitExtractAdjustment);
+ if (!NewFragmentExpr)
+ return;
+
+ // Apply a DIAssignID to the store if it doesn't already have it.
if (!NewAddr->hasMetadata(LLVMContext::MD_DIAssignID)) {
NewAddr->setMetadata(LLVMContext::MD_DIAssignID,
DIAssignID::getDistinct(NewAddr->getContext()));
}
+
Instruction *NewAssign =
DIB.insertDbgAssign(NewAddr, Orig->getValue(), Orig->getVariable(),
- NewFragmentExpr, NewAddr,
- Orig->getAddressExpression(), Orig->getDebugLoc())
+ NewFragmentExpr, NewAddr, NewAddrExpr,
+ Orig->getDebugLoc())
.get<Instruction *>();
LLVM_DEBUG(dbgs() << "Created new assign intrinsic: " << *NewAssign << "\n");
(void)NewAssign;
}
-static void insertNewDbgInst(DIBuilder &DIB, DbgVariableRecord *Orig,
- AllocaInst *NewAddr, DIExpression *NewFragmentExpr,
- Instruction *BeforeInst) {
+
+/// Insert a new DbgRecord.
+/// \p Orig Original to copy record type, debug loc and variable from, and
+/// additionally value and value expression for dbg_assign records.
+/// \p NewAddr Location's new base address.
+/// \p NewAddrExpr New expression to apply to address.
+/// \p BeforeInst Insert position.
+/// \p NewFragment New fragment (absolute, non-relative).
+/// \p BitExtractAdjustment Offset to apply to any extract_bits op.
+static void
+insertNewDbgInst(DIBuilder &DIB, DbgVariableRecord *Orig, AllocaInst *NewAddr,
+ DIExpression *NewAddrExpr, Instruction *BeforeInst,
+ std::optional<DIExpression::FragmentInfo> NewFragment,
+ int64_t BitExtractAdjustment) {
(void)DIB;
+
+ // A dbg_assign puts fragment info in the value expression only. The address
+ // expression has already been built: NewAddrExpr. A dbg_declare puts the
+ // new fragment info into NewAddrExpr (as it only has one expression).
+ DIExpression *NewFragmentExpr =
+ Orig->isDbgAssign() ? Orig->getExpression() : NewAddrExpr;
+ if (NewFragment)
+ NewFragmentExpr = createOrReplaceFragment(NewFragmentExpr, *NewFragment,
+ BitExtractAdjustment);
+ if (!NewFragmentExpr)
+ return;
+
if (Orig->isDbgDeclare()) {
DbgVariableRecord *DVR = DbgVariableRecord::createDVRDeclare(
NewAddr, Orig->getVariable(), NewFragmentExpr, Orig->getDebugLoc());
@@ -5000,13 +5175,16 @@ static void insertNewDbgInst(DIBuilder &DIB, DbgVariableRecord *Orig,
BeforeInst->getIterator());
return;
}
+
+ // Apply a DIAssignID to the store if it doesn't already have it.
if (!NewAddr->hasMetadata(LLVMContext::MD_DIAssignID)) {
NewAddr->setMetadata(LLVMContext::MD_DIAssignID,
DIAssignID::getDistinct(NewAddr->getContext()));
}
+
DbgVariableRecord *NewAssign = DbgVariableRecord::createLinkedDVRAssign(
NewAddr, Orig->getValue(), Orig->getVariable(), NewFragmentExpr, NewAddr,
- Orig->getAddressExpression(), Orig->getDebugLoc());
+ NewAddrExpr, Orig->getDebugLoc());
LLVM_DEBUG(dbgs() << "Created new DVRAssign: " << *NewAssign << "\n");
(void)NewAssign;
}
@@ -5019,7 +5197,7 @@ bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
unsigned NumPartitions = 0;
bool Changed = false;
- const DataLayout &DL = AI.getDataLayout();
+ const DataLayout &DL = AI.getModule()->getDataLayout();
// First try to pre-split loads and stores.
Changed |= presplitLoadsAndStores(AI, AS);
@@ -5110,57 +5288,79 @@ bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
NumAllocaPartitions += NumPartitions;
MaxPartitionsPerAlloca.updateMax(NumPartitions);
- // Migrate debug information from the old alloca to the new alloca(s)
- // and the individual partitions.
auto MigrateOne = [&](auto *DbgVariable) {
- auto *Expr = DbgVariable->getExpression();
- DIBuilder DIB(*AI.getModule(), /*AllowUnresolved*/ false);
- uint64_t AllocaSize =
- DL.getTypeSizeInBits(AI.getAllocatedType()).getFixedValue();
- for (auto Fragment : Fragments) {
- // Create a fragment expression describing the new partition or reuse AI's
- // expression if there is only one partition.
- auto *FragmentExpr = Expr;
- if (Fragment.Size < AllocaSize || Expr->isFragment()) {
- // If this alloca is already a scalar replacement of a larger aggregate,
- // Fragment.Offset describes the offset inside the scalar.
- auto ExprFragment = Expr->getFragmentInfo();
- uint64_t Offset = ExprFragment ? ExprFragment->OffsetInBits : 0;
- uint64_t Start = Offset + Fragment.Offset;
- uint64_t Size = Fragment.Size;
- if (ExprFragment) {
- uint64_t AbsEnd =
- ExprFragment->OffsetInBits + ExprFragment->SizeInBits;
- if (Start >= AbsEnd) {
- // No need to describe a SROAed padding.
- continue;
- }
- Size = std::min(Size, AbsEnd - Start);
- }
- // The new, smaller fragment is stenciled out from the old fragment.
- if (auto OrigFragment = FragmentExpr->getFragmentInfo()) {
- assert(Start >= OrigFragment->OffsetInBits &&
- "new fragment is outside of original fragment");
- Start -= OrigFragment->OffsetInBits;
- }
+ // Can't overlap with undef memory.
+ if (isKillAddress(DbgVariable))
+ return;
- // The alloca may be larger than the variable.
- auto VarSize = DbgVariable->getVariable()->getSizeInBits();
- if (VarSize) {
- if (Size > *VarSize)
- Size = *VarSize;
- if (Size == 0 || Start + Size > *VarSize)
- continue;
- }
+ const Value *DbgPtr = getAddress(DbgVariable);
+ DIExpression::FragmentInfo VarFrag =
+ DbgVariable->getFragmentOrEntireVariable();
+ // Get the address expression constant offset if one exists and the ops
+ // that come after it.
+ int64_t CurrentExprOffsetInBytes = 0;
+ SmallVector<uint64_t> PostOffsetOps;
+ if (!getAddressExpression(DbgVariable)
+ ->extractLeadingOffset(CurrentExprOffsetInBytes, PostOffsetOps))
+ return; // Couldn't interpret this DIExpression - drop the var.
+
+ // Offset defined by a DW_OP_LLVM_extract_bits_[sz]ext.
+ int64_t ExtractOffsetInBits = 0;
+ for (auto Op : getAddressExpression(DbgVariable)->expr_ops()) {
+ if (Op.getOp() == dwarf::DW_OP_LLVM_extract_bits_zext ||
+ Op.getOp() == dwarf::DW_OP_LLVM_extract_bits_sext) {
+ ExtractOffsetInBits = Op.getArg(0);
+ break;
+ }
+ }
- // Avoid creating a fragment expression that covers the entire variable.
- if (!VarSize || *VarSize != Size) {
- if (auto E =
- DIExpression::createFragmentExpression(Expr, Start, Size))
- FragmentExpr = *E;
- else
- continue;
- }
+ DIBuilder DIB(*AI.getModule(), /*AllowUnresolved*/ false);
+ for (auto Fragment : Fragments) {
+ int64_t OffsetFromLocationInBits;
+ std::optional<DIExpression::FragmentInfo> NewDbgFragment;
+ // Find the variable fragment that the new alloca slice covers.
+ // Drop debug info for this variable fragment if we can't compute an
+ // intersect between it and the alloca slice.
+ if (!DIExpression::calculateFragmentIntersect(
+ DL, &AI, Fragment.Offset, Fragment.Size, DbgPtr,
+ CurrentExprOffsetInBytes * 8, ExtractOffsetInBits, VarFrag,
+ NewDbgFragment, OffsetFromLocationInBits))
+ continue; // Do not migrate this fragment to this slice.
+
+ // Zero sized fragment indicates there's no intersect between the variable
+ // fragment and the alloca slice. Skip this slice for this variable
+ // fragment.
+ if (NewDbgFragment && !NewDbgFragment->SizeInBits)
+ continue; // Do not migrate this fragment to this slice.
+
+ // No fragment indicates DbgVariable's variable or fragment exactly
+ // overlaps the slice; copy its fragment (or nullopt if there isn't one).
+ if (!NewDbgFragment)
+ NewDbgFragment = DbgVariable->getFragment();
+
+ // Reduce the new expression offset by the bit-extract offset since
+ // we'll be keeping that.
+ int64_t OffestFromNewAllocaInBits =
+ OffsetFromLocationInBits - ExtractOffsetInBits;
+ // We need to adjust an existing bit extract if the offset expression
+ // can't eat the slack (i.e., if the new offset would be negative).
+ int64_t BitExtractOffset =
+ std::min<int64_t>(0, OffestFromNewAllocaInBits);
+ // The magnitude of a negative value indicates the number of bits into
+ // the existing variable fragment that the memory region begins. The new
+ // variable fragment already excludes those bits - the new DbgPtr offset
+ // only needs to be applied if it's positive.
+ OffestFromNewAllocaInBits =
+ std::max(int64_t(0), OffestFromNewAllocaInBits);
+
+ // Rebuild the expression:
+ // {Offset(OffestFromNewAllocaInBits), PostOffsetOps, NewDbgFragment}
+ // Add NewDbgFragment later, because dbg.assigns don't want it in the
+ // address expression but the value expression instead.
+ DIExpression *NewExpr = DIExpression::get(AI.getContext(), PostOffsetOps);
+ if (OffestFromNewAllocaInBits > 0) {
+ int64_t OffsetInBytes = (OffestFromNewAllocaInBits + 7) / 8;
+ NewExpr = DIExpression::prepend(NewExpr, /*flags=*/0, OffsetInBytes);
}
// Remove any existing intrinsics on the new alloca describing
@@ -5177,7 +5377,8 @@ bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
for_each(findDbgDeclares(Fragment.Alloca), RemoveOne);
for_each(findDVRDeclares(Fragment.Alloca), RemoveOne);
- insertNewDbgInst(DIB, DbgVariable, Fragment.Alloca, FragmentExpr, &AI);
+ insertNewDbgInst(DIB, DbgVariable, Fragment.Alloca, NewExpr, &AI,
+ NewDbgFragment, BitExtractOffset);
}
};
diff --git a/llvm/test/DebugInfo/Generic/assignment-tracking/sroa/var-sized-fragment.ll b/llvm/test/DebugInfo/Generic/assignment-tracking/sroa/var-sized-fragment.ll
index 55119114bd602..c2bcd4dcfeeee 100644
--- a/llvm/test/DebugInfo/Generic/assignment-tracking/sroa/var-sized-fragment.ll
+++ b/llvm/test/DebugInfo/Generic/assignment-tracking/sroa/var-sized-fragment.ll
@@ -19,10 +19,7 @@
;; return a;
;; }
-;; FIXME: Variable 'b' gets an incorrect location (value and expression) - see
-;; llvm.org/PR61981. This check just ensures that no fragment info is added to
-;; the dbg.value.
-; CHECK: #dbg_value(i32 %.sroa.0.0.extract.trunc, ![[B:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 4),
+; CHECK: #dbg_value(i32 %.sroa.2.0.extract.trunc, ![[B:[0-9]+]], !DIExpression(),
; CHECK: #dbg_value(i32 %.sroa.0.0.extract.trunc, ![[A:[0-9]+]], !DIExpression(),
; CHECK: ![[A]] = !DILocalVariable(name: "a",
; CHECK: ![[B]] = !DILocalVariable(name: "b",
diff --git a/llvm/test/DebugInfo/Generic/sroa-alloca-offset.ll b/llvm/test/DebugInfo/Generic/sroa-alloca-offset.ll
new file mode 100644
index 0000000000000..2d3bbc236b54f
--- /dev/null
+++ b/llvm/test/DebugInfo/Generic/sroa-alloca-offset.ll
@@ -0,0 +1,256 @@
+; RUN: opt %s -passes=sroa -S | FileCheck %s --check-prefixes=COMMON,OLD
+; RUN: opt %s -passes=declare-to-assign,sroa -S | FileCheck %s --check-prefixes=COMMON,NEW
+
+;; C++17 source:
+;; struct two { int a, b; } gt;
+;; int fun1() {
+;; auto [x, y] = gt;
+;; return x + y;
+;; }
+;;
+;; struct four { two a, b; } gf;
+;; int fun2() {
+;; auto [x, y] = gf;
+;; return x.a + y.b;
+;; }
+;; Plus some hand-written IR.
+;;
+;; Check that SROA understands how to split dbg.declares and dbg.assigns with
+;; offsets into their storge (e.g., the second variable in a structured binding
+;; is stored at an offset into the shared alloca).
+;;
+;; Additional notes:
+;; We expect the same dbg.value intrinsics to come out of SROA whether assignment
+;; tracking is enabled or not. However, the order of the debug intrinsics may
+;; differ, and assignment tracking replaces some dbg.declares with dbg.assigns.
+;;
+;; Structured bindings produce an artificial variable that covers the entire
+;; alloca. Although they add clutter to the test, they've been preserved in
+;; order to increase coverage. These use the placehold name 'A' in comments and
+;; checks.
+
+%struct.two = type { i32, i32 }
+%struct.four = type { %struct.two, %struct.two }
+
+ at gt = dso_local global %struct.two zeroinitializer, align 4, !dbg !0
+ at gf = dso_local global %struct.four zeroinitializer, align 4, !dbg !5
+
+
+; COMMON-LABEL: @_Z4fun1v
+; COMMON-NEXT: entry
+;; 32 bit variable x (!27): value a_reg.
+;;
+;; 32 bit variable y (!28): value b_reg.
+;;
+;; 64 bit variable A (!29) bits [0, 32): value a_reg.
+;; 64 bit variable A (!29) bits [32, 64): value b_reg.
+
+; OLD-NEXT: %[[a_reg:.*]] = load i32, ptr @gt
+; OLD-NEXT: #dbg_value(i32 %[[a_reg]], ![[x0:[0-9]+]], !DIExpression(),
+; OLD-NEXT: #dbg_value(i32 %[[a_reg]], ![[A0:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+; OLD-NEXT: %[[b_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gt, i64 4)
+; OLD-NEXT: #dbg_value(i32 %[[b_reg]], ![[y0:[0-9]+]], !DIExpression(),
+; OLD-NEXT: #dbg_value(i32 %[[b_reg]], ![[A0]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
+
+; NEW-NEXT: %[[a_reg:.*]] = load i32, ptr @gt
+; NEW-NEXT: %[[b_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gt, i64 4)
+; NEW-NEXT: #dbg_value(i32 %[[b_reg]], ![[y0:[0-9]+]], !DIExpression(),
+; NEW-NEXT: #dbg_value(i32 %[[a_reg]], ![[A0:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+; NEW-NEXT: #dbg_value(i32 %[[b_reg]], ![[A0]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
+; NEW-NEXT: #dbg_value(i32 %[[a_reg]], ![[x0:[0-9]+]], !DIExpression(),
+define dso_local noundef i32 @_Z4fun1v() #0 !dbg !23 {
+entry:
+ %0 = alloca %struct.two, align 4
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !27, metadata !DIExpression()), !dbg !31
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !28, metadata !DIExpression(DW_OP_plus_uconst, 4)), !dbg !31
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !29, metadata !DIExpression()), !dbg !31
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gt, i64 8, i1 false), !dbg !31
+ %a = getelementptr inbounds %struct.two, ptr %0, i32 0, i32 0, !dbg !31
+ %1 = load i32, ptr %a, align 4, !dbg !31
+ %b = getelementptr inbounds %struct.two, ptr %0, i32 0, i32 1, !dbg !31
+ %2 = load i32, ptr %b, align 4, !dbg !31
+ %add = add nsw i32 %1, %2, !dbg !31
+ ret i32 %add, !dbg !31
+}
+
+; COMMON-LABEL: _Z4fun2v()
+; COMMON-NEXT: entry:
+;; 64 bit variable x (!50) bits [0, 32): value aa_reg.
+;; 64 bit variable x (!50) bits [32, 64): deref ab_ba_addr
+;;
+;; 64 bit variable y (!51) bits [0, 32): deref ab_ba_addr + 32
+;; 64 bit variable y (!51) bits [32, 64): value bb_reg.
+;;
+;; 128 bit variable A (!52) bits [0, 32): value aa_reg
+;; 128 bit variable A (!52) bits [32, 64): deref ab_ba_addr
+;; 128 bit variable A (!52) bits [96, 128): value bb_reg
+;;
+;; NOTE: This 8 byte alloca contains x.b (4 bytes) and y.a (4 bytes).
+; COMMON-NEXT: %[[ab_ba_addr:.*]] = alloca [8 x i8], align 4
+; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[A1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 64),
+; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[y1:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_LLVM_fragment, 0, 32),
+; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[x1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
+; OLD-NEXT: %[[aa_reg:.*]] = load i32, ptr @gf, align 4
+; OLD-NEXT: #dbg_value(i32 %[[aa_reg]], ![[x1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+; OLD-NEXT: #dbg_value(i32 %[[aa_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+; OLD-NEXT: call void @llvm.memcpy{{.*}}(ptr align 4 %[[ab_ba_addr]], ptr align 4 getelementptr inbounds (i8, ptr @gf, i64 4), i64 8, i1 false)
+; OLD-NEXT: %[[bb_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 12), align 4
+; OLD-NEXT: #dbg_value(i32 %[[bb_reg]], ![[y1]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
+; OLD-NEXT: #dbg_value(i32 %[[bb_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 96, 32),
+
+; NEW-NEXT: #dbg_assign(i1 undef, ![[x1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32), ![[#]], ptr %[[ab_ba_addr]], !DIExpression(),
+; NEW-NEXT: #dbg_assign(i1 undef, ![[A1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 64), ![[#]], ptr %[[ab_ba_addr]], !DIExpression(),
+; NEW-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[y1:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_LLVM_fragment, 0, 32),
+; NEW-NEXT: %[[aa_reg:.*]] = load i32, ptr @gf, align 4
+; NEW-NEXT: llvm.memcpy{{.*}}(ptr align 4 %[[ab_ba_addr]], ptr align 4 getelementptr inbounds (i8, ptr @gf, i64 4), i64 8, i1 false){{.*}}, !DIAssignID ![[ID:[0-9]+]]
+; NEW-NEXT: %[[bb_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 12), align 4
+; NEW-NEXT: #dbg_value(i32 %[[bb_reg]], ![[y1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
+; NEW-NEXT: #dbg_value(i32 %[[aa_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+; NEW-NEXT: #dbg_assign(i1 undef, ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 32, 64), ![[ID]], ptr %[[ab_ba_addr]], !DIExpression(),
+; NEW-NEXT: #dbg_value(i32 %[[bb_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 96, 32),
+; NEW-NEXT: #dbg_value(i32 %[[aa_reg]], ![[x1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
+define dso_local noundef i32 @_Z4fun2v() #0 !dbg !48 {
+entry:
+ %0 = alloca %struct.four, align 4
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !50, metadata !DIExpression()), !dbg !54
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !51, metadata !DIExpression(DW_OP_plus_uconst, 8)), !dbg !54
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !52, metadata !DIExpression()), !dbg !54
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gf, i64 16, i1 false), !dbg !54
+ %a = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 0, !dbg !54
+ %a1 = getelementptr inbounds %struct.two, ptr %a, i32 0, i32 0, !dbg !54
+ %1 = load i32, ptr %a1, align 4, !dbg !54
+ %b = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 1, !dbg !54
+ %b2 = getelementptr inbounds %struct.two, ptr %b, i32 0, i32 1, !dbg !54
+ %2 = load i32, ptr %b2, align 4, !dbg !54
+ %add = add nsw i32 %1, %2, !dbg !54
+ ret i32 %add, !dbg !54
+}
+
+;; Hand-written part to test what happens when variables are smaller than the
+;; new alloca slices (i.e., check offset rewriting works correctly). Note that
+;; mem2reg incorrectly preserves the offest in the DIExpression a variable
+;; stuffed into the upper bits of a value (that is a bug), e.g. alloca+offset
+;; becomes vreg+offest. It should either convert the offest to a shift, or
+;; encode the register-bit offest using DW_OP_bit_piece.
+; COMMON-LABEL: _Z4fun3v()
+; COMMON-NEXT: entry:
+;; 16 bit variable e (!61): value ve (upper bits)
+;;
+;; 16 bit variable f (!62): value vgf (lower bits)
+;; 16 bit variable g (!63): value vgf (upper bits)
+;;
+;; 16 bit variable h (!64): deref dead_64_128
+; COMMON-NEXT: %[[dead_64_128:.*]] = alloca %struct.two
+; COMMON-NEXT: #dbg_declare(ptr %[[dead_64_128]], ![[h:[0-9]+]], !DIExpression(),
+; COMMON-NEXT: %[[ve:.*]] = load i32, ptr @gf
+;; FIXME: mem2reg bug - offset is incorrect - see comment above.
+; COMMON-NEXT: #dbg_value(i32 %[[ve]], ![[e:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 2),
+; COMMON-NEXT: %[[vfg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 4)
+; COMMON-NEXT: #dbg_value(i32 %[[vfg]], ![[f:[0-9]+]], !DIExpression(),
+;; FIXME: mem2reg bug - offset is incorrect - see comment above.
+; COMMON-NEXT: #dbg_value(i32 %[[vfg]], ![[g:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 2),
+define dso_local noundef i32 @_Z4fun3v() #0 !dbg !55 {
+entry:
+ %0 = alloca %struct.four, align 4
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !61, metadata !DIExpression(DW_OP_plus_uconst, 2)), !dbg !58
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !62, metadata !DIExpression(DW_OP_plus_uconst, 4)), !dbg !58
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !63, metadata !DIExpression(DW_OP_plus_uconst, 6)), !dbg !58
+ call void @llvm.dbg.declare(metadata ptr %0, metadata !64, metadata !DIExpression(DW_OP_plus_uconst, 8)), !dbg !58
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gf, i64 16, i1 false), !dbg !58
+ %1 = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 0, !dbg !58
+ %2 = getelementptr inbounds %struct.two, ptr %1, i32 0, i32 1, !dbg !58
+ %3 = load i32, ptr %2, align 4, !dbg !58
+ ret i32 %3, !dbg !58
+}
+
+;; splitAlloca in SROA.cpp only understands expressions with an optional offset
+;; and optional fragment. Check a dbg.declare with an extra op is dropped. If
+;; this test fails it indicates the debug info updating code in SROA.cpp
+;; splitAlloca may need to be update to account for more complex input
+;; expressions. Search for this file name in SROA.cpp.
+; COMMON-LABEL: fun4
+; COMMON-NOT: llvm.dbg
+; COMMON: #dbg_value(ptr %0, ![[p:[0-9]+]], !DIExpression(DW_OP_deref),
+; COMMON: #dbg_value(ptr %0, ![[q:[0-9]+]], !DIExpression(),
+; COMMON-NOT: llvm.dbg
+; COMMON: ret
+define dso_local noundef i32 @fun4(ptr %0) #0 !dbg !65 {
+entry:
+ %p = alloca [2 x ptr]
+ store ptr %0, ptr %p
+ call void @llvm.dbg.declare(metadata ptr %p, metadata !67, metadata !DIExpression(DW_OP_deref)), !dbg !66
+ call void @llvm.dbg.declare(metadata ptr %p, metadata !68, metadata !DIExpression()), !dbg !66
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gf, i64 16, i1 false), !dbg !66
+ %deref = load ptr, ptr %p
+ %1 = getelementptr inbounds %struct.four, ptr %deref, i32 0, i32 0, !dbg !66
+ %2 = load i32, ptr %1, align 4, !dbg !66
+ ret i32 %2, !dbg !66
+}
+
+; COMMON-DAG: ![[x0]] = !DILocalVariable(name: "x",
+; COMMON-DAG: ![[y0]] = !DILocalVariable(name: "y",
+; COMMON-DAG: ![[A0]] = !DILocalVariable(scope:
+
+; COMMON-DAG: ![[x1]] = !DILocalVariable(name: "x",
+; COMMON-DAG: ![[y1]] = !DILocalVariable(name: "y",
+; COMMON-DAG: ![[A1]] = !DILocalVariable(scope:
+
+; COMMON-DAG: ![[e]] = !DILocalVariable(name: "e",
+; COMMON-DAG: ![[f]] = !DILocalVariable(name: "f",
+; COMMON-DAG: ![[g]] = !DILocalVariable(name: "g",
+; COMMON-DAG: ![[h]] = !DILocalVariable(name: "h",
+
+; COMMON-DAG: ![[q]] = !DILocalVariable(name: "q"
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!16, !17}
+!llvm.ident = !{!22}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "gt", scope: !2, file: !3, line: 1, type: !10, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 17.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0, !5}
+!5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())
+!6 = distinct !DIGlobalVariable(name: "gf", scope: !2, file: !3, line: 7, type: !7, isLocal: false, isDefinition: true)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "four", file: !3, line: 7, size: 128, flags: DIFlagTypePassByValue, elements: !8, identifier: "_ZTS4four")
+!8 = !{!9, !15}
+!9 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !7, file: !3, line: 7, baseType: !10, size: 64)
+!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "two", file: !3, line: 1, size: 64, flags: DIFlagTypePassByValue, elements: !11, identifier: "_ZTS3two")
+!11 = !{!12, !14}
+!12 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !10, file: !3, line: 1, baseType: !13, size: 32)
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !10, file: !3, line: 1, baseType: !13, size: 32, offset: 32)
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !7, file: !3, line: 7, baseType: !10, size: 64, offset: 64)
+!16 = !{i32 7, !"Dwarf Version", i32 5}
+!17 = !{i32 2, !"Debug Info Version", i32 3}
+!22 = !{!"clang version 17.0.0"}
+!23 = distinct !DISubprogram(name: "fun1", linkageName: "_Z4fun1v", scope: !3, file: !3, line: 2, type: !24, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !26)
+!24 = !DISubroutineType(types: !25)
+!25 = !{!13}
+!26 = !{!27, !28, !29}
+!27 = !DILocalVariable(name: "x", scope: !23, file: !3, line: 3, type: !13)
+!28 = !DILocalVariable(name: "y", scope: !23, file: !3, line: 3, type: !13)
+!29 = !DILocalVariable(scope: !23, file: !3, line: 3, type: !10)
+!31 = !DILocation(line: 3, column: 9, scope: !23)
+!48 = distinct !DISubprogram(name: "fun2", linkageName: "_Z4fun2v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !49)
+!49 = !{!50, !51, !52}
+!50 = !DILocalVariable(name: "x", scope: !48, file: !3, line: 9, type: !10)
+!51 = !DILocalVariable(name: "y", scope: !48, file: !3, line: 9, type: !10)
+!52 = !DILocalVariable(scope: !48, file: !3, line: 9, type: !7)
+!54 = !DILocation(line: 9, column: 9, scope: !48)
+!55 = distinct !DISubprogram(name: "fun3", linkageName: "_Z4fun3v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !56)
+!56 = !{}
+!58 = !DILocation(line: 9, column: 9, scope: !55)
+!60 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
+!61 = !DILocalVariable(name: "e", scope: !55, file: !3, line: 9, type: !60)
+!62 = !DILocalVariable(name: "f", scope: !55, file: !3, line: 9, type: !60)
+!63 = !DILocalVariable(name: "g", scope: !55, file: !3, line: 9, type: !60)
+!64 = !DILocalVariable(name: "h", scope: !55, file: !3, line: 9, type: !60)
+!65 = distinct !DISubprogram(name: "fun4", linkageName: "_Z4fun4v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !56)
+!66 = !DILocation(line: 9, column: 9, scope: !65)
+!67 = !DILocalVariable(name: "p", scope: !65, file: !3, line: 9, type: !13)
+!68 = !DILocalVariable(name: "q", scope: !65, file: !3, line: 9, type: !13)
More information about the llvm-commits
mailing list