Skip to content

Commit bf2b2f0

Browse files
jmorsejmorse
committedJun 13, 2019
[DebugInfo] Honour variable fragments in LiveDebugValues
This patch makes the LiveDebugValues pass consider fragments when propagating DBG_VALUE insts between blocks, fixing PR41979. Fragment info for a variable location is added to the open-ranges key, which allows distinct fragments to be tracked separately. To handle overlapping fragments things become slightly funkier. To avoid excessive searching for overlaps in the data-flow part of LiveDebugValues, this patch: * Pre-computes pairings of fragments that overlap, for each DILocalVariable * During data-flow, whenever something happens that causes an open range to be terminated (via erase), any fragments pre-determined to overlap are also terminated. The effect of which is that when encountering a DBG_VALUE fragment that overlaps others, the overlapped fragments do not get propagated to other blocks. We still rely on later location-list building to correctly handle overlapping fragments within blocks. It's unclear whether a mixture of DBG_VALUEs with and without fragmented expressions are legitimate. To avoid suprises, this patch interprets a DBG_VALUE with no fragment as overlapping any DBG_VALUE _with_ a fragment. Differential Revision: https://reviews.llvm.org/D62904 llvm-svn: 363256
·
llvmorg-21-initllvmorg-9.0.0-rc1
1 parent 1fca3b1 commit bf2b2f0

File tree

4 files changed

+531
-72
lines changed

4 files changed

+531
-72
lines changed
 

‎llvm/include/llvm/IR/DebugInfoMetadata.h

+46-9
Original file line numberDiff line numberDiff line change
@@ -2523,17 +2523,14 @@ class DIExpression : public MDNode {
25232523
createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
25242524
unsigned SizeInBits);
25252525

2526-
/// Determine the relative position of the fragments described by this
2527-
/// DIExpression and \p Other.
2526+
/// Determine the relative position of the fragments passed in.
25282527
/// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
25292528
/// 1 if this is entirely after Other.
2530-
int fragmentCmp(const DIExpression *Other) const {
2531-
auto Fragment1 = *getFragmentInfo();
2532-
auto Fragment2 = *Other->getFragmentInfo();
2533-
unsigned l1 = Fragment1.OffsetInBits;
2534-
unsigned l2 = Fragment2.OffsetInBits;
2535-
unsigned r1 = l1 + Fragment1.SizeInBits;
2536-
unsigned r2 = l2 + Fragment2.SizeInBits;
2529+
static int fragmentCmp(const FragmentInfo &A, const FragmentInfo &B) {
2530+
uint64_t l1 = A.OffsetInBits;
2531+
uint64_t l2 = B.OffsetInBits;
2532+
uint64_t r1 = l1 + A.SizeInBits;
2533+
uint64_t r2 = l2 + B.SizeInBits;
25372534
if (r1 <= l2)
25382535
return -1;
25392536
else if (r2 <= l1)
@@ -2542,6 +2539,19 @@ class DIExpression : public MDNode {
25422539
return 0;
25432540
}
25442541

2542+
/// Check if fragments overlap between a pair of FragmentInfos.
2543+
static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) {
2544+
return fragmentCmp(A, B) == 0;
2545+
}
2546+
2547+
/// Determine the relative position of the fragments described by this
2548+
/// DIExpression and \p Other. Calls static fragmentCmp implementation.
2549+
int fragmentCmp(const DIExpression *Other) const {
2550+
auto Fragment1 = *getFragmentInfo();
2551+
auto Fragment2 = *Other->getFragmentInfo();
2552+
return fragmentCmp(Fragment1, Fragment2);
2553+
}
2554+
25452555
/// Check if fragments overlap between this DIExpression and \p Other.
25462556
bool fragmentsOverlap(const DIExpression *Other) const {
25472557
if (!isFragment() || !Other->isFragment())
@@ -2550,6 +2560,33 @@ class DIExpression : public MDNode {
25502560
}
25512561
};
25522562

2563+
inline bool operator==(const DIExpression::FragmentInfo &A,
2564+
const struct DIExpression::FragmentInfo &B) {
2565+
return std::tie(A.SizeInBits, A.OffsetInBits) ==
2566+
std::tie(B.SizeInBits, B.OffsetInBits);
2567+
}
2568+
2569+
inline bool operator<(const struct DIExpression::FragmentInfo &A,
2570+
const struct DIExpression::FragmentInfo &B) {
2571+
return std::tie(A.SizeInBits, A.OffsetInBits) <
2572+
std::tie(B.SizeInBits, B.OffsetInBits);
2573+
}
2574+
2575+
template <> struct DenseMapInfo<struct DIExpression::FragmentInfo> {
2576+
using FragInfo = struct DIExpression::FragmentInfo;
2577+
static const uint64_t MaxVal = std::numeric_limits<uint64_t>::max();
2578+
2579+
static inline FragInfo getEmptyKey() { return {MaxVal, MaxVal}; }
2580+
2581+
static inline FragInfo getTombstoneKey() { return {MaxVal - 1, MaxVal - 1}; }
2582+
2583+
static unsigned getHashValue(const FragInfo &Frag) {
2584+
return (Frag.SizeInBits & 0xffff) << 16 | (Frag.OffsetInBits & 0xffff);
2585+
}
2586+
2587+
static bool isEqual(const FragInfo &A, const FragInfo &B) { return A == B; }
2588+
};
2589+
25532590
/// Global variables.
25542591
///
25552592
/// TODO: Remove DisplayName. It's always equal to Name.

‎llvm/lib/CodeGen/LiveDebugValues.cpp

+227-39
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
#include "llvm/ADT/DenseMap.h"
2121
#include "llvm/ADT/PostOrderIterator.h"
2222
#include "llvm/ADT/SmallPtrSet.h"
23+
#include "llvm/ADT/SmallSet.h"
2324
#include "llvm/ADT/SmallVector.h"
2425
#include "llvm/ADT/SparseBitVector.h"
2526
#include "llvm/ADT/Statistic.h"
@@ -57,6 +58,7 @@
5758
#include <cstdint>
5859
#include <functional>
5960
#include <queue>
61+
#include <tuple>
6062
#include <utility>
6163
#include <vector>
6264

@@ -107,24 +109,63 @@ class LiveDebugValues : public MachineFunctionPass {
107109
}
108110
};
109111

110-
/// Based on std::pair so it can be used as an index into a DenseMap.
111-
using DebugVariableBase =
112-
std::pair<const DILocalVariable *, const DILocation *>;
113-
/// A potentially inlined instance of a variable.
114-
struct DebugVariable : public DebugVariableBase {
115-
DebugVariable(const DILocalVariable *Var, const DILocation *InlinedAt)
116-
: DebugVariableBase(Var, InlinedAt) {}
117-
118-
const DILocalVariable *getVar() const { return this->first; }
119-
const DILocation *getInlinedAt() const { return this->second; }
120-
121-
bool operator<(const DebugVariable &DV) const {
122-
if (getVar() == DV.getVar())
123-
return getInlinedAt() < DV.getInlinedAt();
124-
return getVar() < DV.getVar();
112+
using FragmentInfo = DIExpression::FragmentInfo;
113+
using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;
114+
115+
/// Storage for identifying a potentially inlined instance of a variable,
116+
/// or a fragment thereof.
117+
class DebugVariable {
118+
const DILocalVariable *Variable;
119+
OptFragmentInfo Fragment;
120+
const DILocation *InlinedAt;
121+
122+
/// Fragment that will overlap all other fragments. Used as default when
123+
/// caller demands a fragment.
124+
static const FragmentInfo DefaultFragment;
125+
126+
public:
127+
DebugVariable(const DILocalVariable *Var, OptFragmentInfo &&FragmentInfo,
128+
const DILocation *InlinedAt)
129+
: Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {}
130+
131+
DebugVariable(const DILocalVariable *Var, OptFragmentInfo &FragmentInfo,
132+
const DILocation *InlinedAt)
133+
: Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {}
134+
135+
DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr,
136+
const DILocation *InlinedAt)
137+
: DebugVariable(Var, DIExpr->getFragmentInfo(), InlinedAt) {}
138+
139+
DebugVariable(const MachineInstr &MI)
140+
: DebugVariable(MI.getDebugVariable(),
141+
MI.getDebugExpression()->getFragmentInfo(),
142+
MI.getDebugLoc()->getInlinedAt()) {}
143+
144+
const DILocalVariable *getVar() const { return Variable; }
145+
const OptFragmentInfo &getFragment() const { return Fragment; }
146+
const DILocation *getInlinedAt() const { return InlinedAt; }
147+
148+
const FragmentInfo getFragmentDefault() const {
149+
return Fragment.getValueOr(DefaultFragment);
150+
}
151+
152+
static bool isFragmentDefault(FragmentInfo &F) {
153+
return F == DefaultFragment;
154+
}
155+
156+
bool operator==(const DebugVariable &Other) const {
157+
return std::tie(Variable, Fragment, InlinedAt) ==
158+
std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
159+
}
160+
161+
bool operator<(const DebugVariable &Other) const {
162+
return std::tie(Variable, Fragment, InlinedAt) <
163+
std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
125164
}
126165
};
127166

167+
friend struct llvm::DenseMapInfo<DebugVariable>;
168+
128169
/// A pair of debug variable and value location.
129170
struct VarLoc {
130171
// The location at which a spilled variable resides. It consists of a
@@ -159,8 +200,7 @@ class LiveDebugValues : public MachineFunctionPass {
159200
} Loc;
160201

161202
VarLoc(const MachineInstr &MI, LexicalScopes &LS)
162-
: Var(MI.getDebugVariable(), MI.getDebugLoc()->getInlinedAt()), MI(MI),
163-
UVS(MI.getDebugLoc(), LS) {
203+
: Var(MI), MI(MI), UVS(MI.getDebugLoc(), LS) {
164204
static_assert((sizeof(Loc) == sizeof(uint64_t)),
165205
"hash does not cover all members of Loc");
166206
assert(MI.isDebugValue() && "not a DBG_VALUE");
@@ -183,8 +223,7 @@ class LiveDebugValues : public MachineFunctionPass {
183223
/// The constructor for spill locations.
184224
VarLoc(const MachineInstr &MI, unsigned SpillBase, int SpillOffset,
185225
LexicalScopes &LS)
186-
: Var(MI.getDebugVariable(), MI.getDebugLoc()->getInlinedAt()), MI(MI),
187-
UVS(MI.getDebugLoc(), LS) {
226+
: Var(MI), MI(MI), UVS(MI.getDebugLoc(), LS) {
188227
assert(MI.isDebugValue() && "not a DBG_VALUE");
189228
assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
190229
Kind = SpillLocKind;
@@ -232,26 +271,35 @@ class LiveDebugValues : public MachineFunctionPass {
232271
};
233272
using TransferMap = SmallVector<TransferDebugPair, 4>;
234273

274+
// Types for recording sets of variable fragments that overlap. For a given
275+
// local variable, we record all other fragments of that variable that could
276+
// overlap it, to reduce search time.
277+
using FragmentOfVar =
278+
std::pair<const DILocalVariable *, DIExpression::FragmentInfo>;
279+
using OverlapMap =
280+
DenseMap<FragmentOfVar, SmallVector<DIExpression::FragmentInfo, 1>>;
281+
282+
// Helper while building OverlapMap, a map of all fragments seen for a given
283+
// DILocalVariable.
284+
using VarToFragments =
285+
DenseMap<const DILocalVariable *, SmallSet<FragmentInfo, 4>>;
286+
235287
/// This holds the working set of currently open ranges. For fast
236288
/// access, this is done both as a set of VarLocIDs, and a map of
237289
/// DebugVariable to recent VarLocID. Note that a DBG_VALUE ends all
238290
/// previous open ranges for the same variable.
239291
class OpenRangesSet {
240292
VarLocSet VarLocs;
241-
SmallDenseMap<DebugVariableBase, unsigned, 8> Vars;
293+
SmallDenseMap<DebugVariable, unsigned, 8> Vars;
294+
OverlapMap &OverlappingFragments;
242295

243296
public:
297+
OpenRangesSet(OverlapMap &_OLapMap) : OverlappingFragments(_OLapMap) {}
298+
244299
const VarLocSet &getVarLocs() const { return VarLocs; }
245300

246301
/// Terminate all open ranges for Var by removing it from the set.
247-
void erase(DebugVariable Var) {
248-
auto It = Vars.find(Var);
249-
if (It != Vars.end()) {
250-
unsigned ID = It->second;
251-
VarLocs.reset(ID);
252-
Vars.erase(It);
253-
}
254-
}
302+
void erase(DebugVariable Var);
255303

256304
/// Terminate all open ranges listed in \c KillSet by removing
257305
/// them from the set.
@@ -262,7 +310,7 @@ class LiveDebugValues : public MachineFunctionPass {
262310
}
263311

264312
/// Insert a new range into the set.
265-
void insert(unsigned VarLocID, DebugVariableBase Var) {
313+
void insert(unsigned VarLocID, DebugVariable Var) {
266314
VarLocs.set(VarLocID);
267315
Vars.insert({Var, VarLocID});
268316
}
@@ -310,6 +358,9 @@ class LiveDebugValues : public MachineFunctionPass {
310358
VarLocInMBB &OutLocs, VarLocMap &VarLocIDs,
311359
TransferMap &Transfers, bool transferChanges);
312360

361+
void accumulateFragmentMap(MachineInstr &MI, VarToFragments &SeenFragments,
362+
OverlapMap &OLapMap);
363+
313364
bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
314365
const VarLocMap &VarLocIDs,
315366
SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
@@ -343,10 +394,46 @@ class LiveDebugValues : public MachineFunctionPass {
343394

344395
} // end anonymous namespace
345396

397+
namespace llvm {
398+
399+
template <> struct DenseMapInfo<LiveDebugValues::DebugVariable> {
400+
using DV = LiveDebugValues::DebugVariable;
401+
using OptFragmentInfo = LiveDebugValues::OptFragmentInfo;
402+
using FragmentInfo = LiveDebugValues::FragmentInfo;
403+
404+
// Empty key: no key should be generated that has no DILocalVariable.
405+
static inline DV getEmptyKey() {
406+
return DV(nullptr, OptFragmentInfo(), nullptr);
407+
}
408+
409+
// Difference in tombstone is that the Optional is meaningful
410+
static inline DV getTombstoneKey() {
411+
return DV(nullptr, OptFragmentInfo({0, 0}), nullptr);
412+
}
413+
414+
static unsigned getHashValue(const DV &D) {
415+
unsigned HV = 0;
416+
const OptFragmentInfo &Fragment = D.getFragment();
417+
if (Fragment)
418+
HV = DenseMapInfo<FragmentInfo>::getHashValue(*Fragment);
419+
420+
return hash_combine(D.getVar(), HV, D.getInlinedAt());
421+
}
422+
423+
static bool isEqual(const DV &A, const DV &B) { return A == B; }
424+
};
425+
426+
}; // namespace llvm
427+
346428
//===----------------------------------------------------------------------===//
347429
// Implementation
348430
//===----------------------------------------------------------------------===//
349431

432+
const DIExpression::FragmentInfo
433+
LiveDebugValues::DebugVariable::DefaultFragment = {
434+
std::numeric_limits<uint64_t>::max(),
435+
std::numeric_limits<uint64_t>::min()};
436+
350437
char LiveDebugValues::ID = 0;
351438

352439
char &llvm::LiveDebugValuesID = LiveDebugValues::ID;
@@ -366,6 +453,39 @@ void LiveDebugValues::getAnalysisUsage(AnalysisUsage &AU) const {
366453
MachineFunctionPass::getAnalysisUsage(AU);
367454
}
368455

456+
/// Erase a variable from the set of open ranges, and additionally erase any
457+
/// fragments that may overlap it.
458+
void LiveDebugValues::OpenRangesSet::erase(DebugVariable Var) {
459+
// Erasure helper.
460+
auto DoErase = [this](DebugVariable VarToErase) {
461+
auto It = Vars.find(VarToErase);
462+
if (It != Vars.end()) {
463+
unsigned ID = It->second;
464+
VarLocs.reset(ID);
465+
Vars.erase(It);
466+
}
467+
};
468+
469+
// Erase the variable/fragment that ends here.
470+
DoErase(Var);
471+
472+
// Extract the fragment. Interpret an empty fragment as one that covers all
473+
// possible bits.
474+
FragmentInfo ThisFragment = Var.getFragmentDefault();
475+
476+
// There may be fragments that overlap the designated fragment. Look them up
477+
// in the pre-computed overlap map, and erase them too.
478+
auto MapIt = OverlappingFragments.find({Var.getVar(), ThisFragment});
479+
if (MapIt != OverlappingFragments.end()) {
480+
for (auto Fragment : MapIt->second) {
481+
LiveDebugValues::OptFragmentInfo FragmentHolder;
482+
if (!DebugVariable::isFragmentDefault(Fragment))
483+
FragmentHolder = LiveDebugValues::OptFragmentInfo(Fragment);
484+
DoErase({Var.getVar(), FragmentHolder, Var.getInlinedAt()});
485+
}
486+
}
487+
}
488+
369489
//===----------------------------------------------------------------------===//
370490
// Debug Range Extension Implementation
371491
//===----------------------------------------------------------------------===//
@@ -416,13 +536,14 @@ void LiveDebugValues::transferDebugValue(const MachineInstr &MI,
416536
if (!MI.isDebugValue())
417537
return;
418538
const DILocalVariable *Var = MI.getDebugVariable();
539+
const DIExpression *Expr = MI.getDebugExpression();
419540
const DILocation *DebugLoc = MI.getDebugLoc();
420541
const DILocation *InlinedAt = DebugLoc->getInlinedAt();
421542
assert(Var->isValidLocationForIntrinsic(DebugLoc) &&
422543
"Expected inlined-at fields to agree");
423544

424545
// End all previous ranges of Var.
425-
DebugVariable V(Var, InlinedAt);
546+
DebugVariable V(Var, Expr, InlinedAt);
426547
OpenRanges.erase(V);
427548

428549
// Add the VarLoc to OpenRanges from this DBG_VALUE.
@@ -464,8 +585,7 @@ void LiveDebugValues::insertTransferDebugPair(
464585
unsigned LocId = VarLocIDs.insert(VL);
465586

466587
// Close this variable's previous location range.
467-
DebugVariable V(DebugInstr->getDebugVariable(),
468-
DebugInstr->getDebugLoc()->getInlinedAt());
588+
DebugVariable V(*DebugInstr);
469589
OpenRanges.erase(V);
470590

471591
OpenRanges.insert(LocId, VL.Var);
@@ -757,6 +877,66 @@ bool LiveDebugValues::transferTerminatorInst(MachineInstr &MI,
757877
return Changed;
758878
}
759879

880+
/// Accumulate a mapping between each DILocalVariable fragment and other
881+
/// fragments of that DILocalVariable which overlap. This reduces work during
882+
/// the data-flow stage from "Find any overlapping fragments" to "Check if the
883+
/// known-to-overlap fragments are present".
884+
/// \param MI A previously unprocessed DEBUG_VALUE instruction to analyze for
885+
/// fragment usage.
886+
/// \param SeenFragments Map from DILocalVariable to all fragments of that
887+
/// Variable which are known to exist.
888+
/// \param OverlappingFragments The overlap map being constructed, from one
889+
/// Var/Fragment pair to a vector of fragments known to overlap.
890+
void LiveDebugValues::accumulateFragmentMap(MachineInstr &MI,
891+
VarToFragments &SeenFragments,
892+
OverlapMap &OverlappingFragments) {
893+
DebugVariable MIVar(MI);
894+
FragmentInfo ThisFragment = MIVar.getFragmentDefault();
895+
896+
// If this is the first sighting of this variable, then we are guaranteed
897+
// there are currently no overlapping fragments either. Initialize the set
898+
// of seen fragments, record no overlaps for the current one, and return.
899+
auto SeenIt = SeenFragments.find(MIVar.getVar());
900+
if (SeenIt == SeenFragments.end()) {
901+
SmallSet<FragmentInfo, 4> OneFragment;
902+
OneFragment.insert(ThisFragment);
903+
SeenFragments.insert({MIVar.getVar(), OneFragment});
904+
905+
OverlappingFragments.insert({{MIVar.getVar(), ThisFragment}, {}});
906+
return;
907+
}
908+
909+
// If this particular Variable/Fragment pair already exists in the overlap
910+
// map, it has already been accounted for.
911+
auto IsInOLapMap =
912+
OverlappingFragments.insert({{MIVar.getVar(), ThisFragment}, {}});
913+
if (!IsInOLapMap.second)
914+
return;
915+
916+
auto &ThisFragmentsOverlaps = IsInOLapMap.first->second;
917+
auto &AllSeenFragments = SeenIt->second;
918+
919+
// Otherwise, examine all other seen fragments for this variable, with "this"
920+
// fragment being a previously unseen fragment. Record any pair of
921+
// overlapping fragments.
922+
for (auto &ASeenFragment : AllSeenFragments) {
923+
// Does this previously seen fragment overlap?
924+
if (DIExpression::fragmentsOverlap(ThisFragment, ASeenFragment)) {
925+
// Yes: Mark the current fragment as being overlapped.
926+
ThisFragmentsOverlaps.push_back(ASeenFragment);
927+
// Mark the previously seen fragment as being overlapped by the current
928+
// one.
929+
auto ASeenFragmentsOverlaps =
930+
OverlappingFragments.find({MIVar.getVar(), ASeenFragment});
931+
assert(ASeenFragmentsOverlaps != OverlappingFragments.end() &&
932+
"Previously seen var fragment has no vector of overlaps");
933+
ASeenFragmentsOverlaps->second.push_back(ThisFragment);
934+
}
935+
}
936+
937+
AllSeenFragments.insert(ThisFragment);
938+
}
939+
760940
/// This routine creates OpenRanges and OutLocs.
761941
bool LiveDebugValues::process(MachineInstr &MI, OpenRangesSet &OpenRanges,
762942
VarLocInMBB &OutLocs, VarLocMap &VarLocIDs,
@@ -888,11 +1068,15 @@ bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {
8881068
bool OLChanged = false;
8891069
bool MBBJoined = false;
8901070

891-
VarLocMap VarLocIDs; // Map VarLoc<>unique ID for use in bitvectors.
892-
OpenRangesSet OpenRanges; // Ranges that are open until end of bb.
893-
VarLocInMBB OutLocs; // Ranges that exist beyond bb.
894-
VarLocInMBB InLocs; // Ranges that are incoming after joining.
895-
TransferMap Transfers; // DBG_VALUEs associated with spills.
1071+
VarLocMap VarLocIDs; // Map VarLoc<>unique ID for use in bitvectors.
1072+
OverlapMap OverlapFragments; // Map of overlapping variable fragments
1073+
OpenRangesSet OpenRanges(OverlapFragments);
1074+
// Ranges that are open until end of bb.
1075+
VarLocInMBB OutLocs; // Ranges that exist beyond bb.
1076+
VarLocInMBB InLocs; // Ranges that are incoming after joining.
1077+
TransferMap Transfers; // DBG_VALUEs associated with spills.
1078+
1079+
VarToFragments SeenFragments;
8961080

8971081
// Blocks which are artificial, i.e. blocks which exclusively contain
8981082
// instructions without locations, or with line 0 locations.
@@ -914,10 +1098,14 @@ bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {
9141098
// over the BBs. The LiveDebugVariables pass has already created DBG_VALUE
9151099
// instructions for spills of registers that are known to be user variables
9161100
// within the BB in which the spill occurs.
917-
for (auto &MBB : MF)
918-
for (auto &MI : MBB)
1101+
for (auto &MBB : MF) {
1102+
for (auto &MI : MBB) {
9191103
process(MI, OpenRanges, OutLocs, VarLocIDs, Transfers,
9201104
dontTransferChanges);
1105+
if (MI.isDebugValue())
1106+
accumulateFragmentMap(MI, SeenFragments, OverlapFragments);
1107+
}
1108+
}
9211109

9221110
auto hasNonArtificialLocation = [](const MachineInstr &MI) -> bool {
9231111
if (const DebugLoc &DL = MI.getDebugLoc())

‎llvm/test/DebugInfo/ARM/partial-subreg.ll

-24
Original file line numberDiff line numberDiff line change
@@ -10,30 +10,6 @@
1010
; CHECK: DW_TAG_formal_parameter
1111
; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
1212
; CHECK-NEXT: [0x{{.*}}, 0x{{.*}}): DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4
13-
; CHECK-NEXT: [0x{{.*}}, 0x{{.*}}): DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4
14-
15-
; FIXME: The second location list entry should not be emitted.
16-
;
17-
; The input to LiveDebugValues is:
18-
;
19-
; bb.0.entry:
20-
; [...]
21-
; Bcc %bb.2, 1, killed $cpsr, debug-location !10; simd.swift:5900:12
22-
; bb.1:
23-
; [...]
24-
; DBG_VALUE $q8, $noreg, !"self", !DIExpression(DW_OP_LLVM_fragment, 0, 96)
25-
; B %bb.3
26-
; bb.2.select.false:
27-
; [...]
28-
; DBG_VALUE $q8, $noreg, !"self", !DIExpression(DW_OP_LLVM_fragment, 0, 96)
29-
; bb.3.select.end:
30-
; [...]
31-
;
32-
; The two DBG_VALUEs in the blocks describe different fragments of the
33-
; variable. However, LiveDebugValues is not aware of fragments, so it will
34-
; incorrectly insert a copy of the first DBG_VALUE in bb.3.select.end, since
35-
; the debug values in its predecessor blocks are described by the same
36-
; register.
3713

3814
source_filename = "simd.ll"
3915
target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"

‎llvm/test/DebugInfo/MIR/X86/live-debug-values-fragments.mir

+258
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,258 @@
1+
# RUN: llc %s -o - -run-pass=livedebugvalues | FileCheck %s
2+
#
3+
# The first func tests that, for two independent variable fragments defined in
4+
# blocks 1 and 2, _both_ their locations are propagated into the exit block.
5+
# LiveDebugValues previously ignored fragments and only propagated the last
6+
# variable location seen.
7+
#
8+
# The second func tests that overlapping variable fragments are handled
9+
# correctly -- that the redefinition of a particular fragment also clobbers
10+
# any overlaps. The dbg value of $cx in block one should not be propagated to
11+
# block two, because an overlapping dbg value inst has been encountered.
12+
#
13+
# The third function checks that DBG_VALUEs without fragments are seen as
14+
# overlapping any DBG_VALUE with a fragment.
15+
#
16+
# CHECK-LABEL: foo
17+
# CHECK-LABEL: bb.3.bb3:
18+
# CHECK: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
19+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 32, 32)
20+
# CHECK-NEXT: DBG_VALUE $eax, $noreg, !{{[0-9]+}},
21+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 32)
22+
# CHECK-NEXT: XOR32rr
23+
# CHECK-NEXT: RETQ
24+
#
25+
# CHECK-LABEL: bar
26+
# CHECK-LABEL: bb.0.entry:
27+
# CHECK: DBG_VALUE $cx, $noreg, !{{[0-9]+}},
28+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 16)
29+
30+
# CHECK-LABEL: bb.1.bb1:
31+
# CHECK: DBG_VALUE $cx, $noreg, !{{[0-9]+}},
32+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 16)
33+
# CHECK-NEXT: MOV32rr
34+
# CHECK-NEXT: DBG_VALUE $ax, $noreg, !{{[0-9]+}},
35+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 8, 16)
36+
# CHECK-NEXT: JMP_1
37+
38+
# CHECK-LABEL: bb.2.bb2:
39+
# CHECK-NOT: DBG_VALUE
40+
# CHECK: DBG_VALUE $ax, $noreg, !{{[0-9]+}},
41+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 8, 16)
42+
# CHECK-NEXT: MOV32rr
43+
# CHECK-NEXT: ADD32ri8
44+
# CHECK-NEXT: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
45+
# CHECK-SAME !DIExpression(DW_OP_LLVM_fragment, 32, 32)
46+
# CHECK-NEXT: JMP_1
47+
48+
# CHECK-LABEL: bb.3.bb3:
49+
# CHECK: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
50+
# CHECK-SAME !DIExpression(DW_OP_LLVM_fragment, 32, 32)
51+
# CHECK-NEXT: DBG_VALUE $ax, $noreg, !{{[0-9]+}},
52+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 8, 16)
53+
# CHECK-NEXT: XOR32rr
54+
# CHECK-NEXT: RETQ
55+
56+
# CHECK-LABEL: baz
57+
# CHECK-LABEL: bb.0.entry:
58+
# CHECK: DBG_VALUE $cx, $noreg, !{{[0-9]+}},
59+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 16)
60+
# CHECK-NEXT: JMP_1 %bb.1
61+
#
62+
# CHECK-LABEL: bb.1.bb1:
63+
# CHECK: DBG_VALUE $cx, $noreg, !{{[0-9]+}},
64+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 16)
65+
# CHECK-NEXT: MOV32rr
66+
# CHECK-NEXT: DBG_VALUE $rdi, $noreg, !{{[0-9]+}}, !DIExpression()
67+
# CHECK-NEXT: JMP_1 %bb.2
68+
#
69+
# CHECK-LABEL: bb.2.bb2:
70+
# CHECK-NOT: DBG_VALUE $cx
71+
# CHECK: DBG_VALUE $rdi, $noreg, !{{[0-9]+}}, !DIExpression()
72+
# CHECK-NEXT: MOV32rr
73+
# CHECK-NEXT: ADD32ri8
74+
# CHECK-NEXT: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
75+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 32, 32)
76+
# CHECK-NEXT: JMP_1 %bb.3
77+
#
78+
# CHECK-LABEL: bb.3.bb3:
79+
# CHECK-NOT: DBG_VALUE $rdi
80+
# CHECK-NOT: DBG_VALUE $cx
81+
# CHECK: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
82+
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 32, 32)
83+
# CHECK-NEXT: XOR32rr
84+
# CHECK-NEXT: RETQ
85+
86+
--- |
87+
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
88+
89+
define i32 @foo(i32* %bees, i32* %output) !dbg !4 {
90+
entry:
91+
br label %bb1
92+
bb1:
93+
br label %bb2
94+
bb2:
95+
br label %bb3
96+
bb3:
97+
ret i32 0
98+
}
99+
100+
define i32 @bar(i32* %bees, i32* %output) !dbg !40 {
101+
entry:
102+
br label %bb1
103+
bb1:
104+
br label %bb2
105+
bb2:
106+
br label %bb3
107+
bb3:
108+
ret i32 0
109+
}
110+
111+
define i32 @baz(i32* %bees, i32* %output) !dbg !80 {
112+
entry:
113+
br label %bb1
114+
bb1:
115+
br label %bb2
116+
bb2:
117+
br label %bb3
118+
bb3:
119+
ret i32 0
120+
}
121+
122+
!llvm.module.flags = !{!0, !100}
123+
!llvm.dbg.cu = !{!1}
124+
125+
!100 = !{i32 2, !"Dwarf Version", i32 4}
126+
!0 = !{i32 2, !"Debug Info Version", i32 3}
127+
!1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "beards", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
128+
!2 = !DIFile(filename: "bees.cpp", directory: ".")
129+
!3 = !DILocalVariable(name: "flannel", scope: !4, file: !2, line: 1, type: !16)
130+
!4 = distinct !DISubprogram(name: "nope", scope: !2, file: !2, line: 1, spFlags: DISPFlagDefinition, unit: !1, retainedNodes: !13, type: !14, isDefinition: true)
131+
!8 = !DILocation(line: 4, scope: !4)
132+
!13 = !{!3}
133+
!14 = !DISubroutineType(types: !15)
134+
!15 = !{!16}
135+
!16 = !DIBasicType(name: "looong", size: 64, align: 64, encoding: DW_ATE_signed)
136+
!40 = distinct !DISubprogram(name: "toast", scope: !2, file: !2, line: 1, spFlags: DISPFlagDefinition, unit: !1, retainedNodes: !53, type: !14, isDefinition: true)
137+
!43 = !DILocalVariable(name: "charm", scope: !40, file: !2, line: 1, type: !16)
138+
!48 = !DILocation(line: 4, scope: !40)
139+
!53 = !{!43}
140+
!80 = distinct !DISubprogram(name: "mort", scope: !2, file: !2, line: 1, spFlags: DISPFlagDefinition, unit: !1, retainedNodes: !93, type: !14, isDefinition: true)
141+
!83 = !DILocalVariable(name: "bodkin", scope: !80, file: !2, line: 1, type: !16)
142+
!88 = !DILocation(line: 4, scope: !80)
143+
!93 = !{!83}
144+
145+
...
146+
---
147+
name: foo
148+
tracksRegLiveness: true
149+
registers: []
150+
liveins:
151+
- { reg: '$rdi', virtual-reg: '' }
152+
body: |
153+
bb.0.entry:
154+
successors: %bb.1
155+
liveins: $rdi
156+
157+
$ecx = XOR32rr undef $ecx, undef $ecx, implicit-def $eflags
158+
JMP_1 %bb.1
159+
160+
bb.1.bb1 (align 4):
161+
successors: %bb.2
162+
liveins: $ecx, $rdi
163+
164+
$eax = MOV32rr killed $ecx, implicit-def $rax
165+
DBG_VALUE $eax, $noreg, !3, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !8
166+
JMP_1 %bb.2
167+
168+
bb.2.bb2:
169+
successors: %bb.3
170+
liveins: $eax
171+
172+
$ebx = MOV32rr $eax
173+
$ebx = ADD32ri8 $ebx, 3, implicit-def dead $eflags, implicit killed $rbx, implicit-def $rbx
174+
DBG_VALUE $ebx, $noreg, !3, !DIExpression(DW_OP_LLVM_fragment, 32, 32), debug-location !8
175+
JMP_1 %bb.3
176+
177+
bb.3.bb3:
178+
liveins: $eax, $ebx
179+
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
180+
RETQ $eax, debug-location !8
181+
182+
...
183+
---
184+
name: bar
185+
tracksRegLiveness: true
186+
registers: []
187+
liveins:
188+
- { reg: '$rdi', virtual-reg: '' }
189+
body: |
190+
bb.0.entry:
191+
successors: %bb.1
192+
liveins: $rdi
193+
194+
$ecx = XOR32rr undef $ecx, undef $ecx, implicit-def $eflags
195+
DBG_VALUE $cx, $noreg, !43, !DIExpression(DW_OP_LLVM_fragment, 0, 16), debug-location !48
196+
JMP_1 %bb.1
197+
198+
bb.1.bb1:
199+
successors: %bb.2
200+
liveins: $ecx, $rdi
201+
202+
$eax = MOV32rr killed $ecx, implicit-def $rax
203+
DBG_VALUE $ax, $noreg, !43, !DIExpression(DW_OP_LLVM_fragment, 8, 16), debug-location !48
204+
JMP_1 %bb.2
205+
206+
bb.2.bb2:
207+
successors: %bb.3
208+
liveins: $eax
209+
210+
$ebx = MOV32rr $eax
211+
$ebx = ADD32ri8 $ebx, 3, implicit-def dead $eflags, implicit killed $rbx, implicit-def $rbx
212+
DBG_VALUE $ebx, $noreg, !43, !DIExpression(DW_OP_LLVM_fragment, 32, 32), debug-location !48
213+
JMP_1 %bb.3
214+
215+
bb.3.bb3:
216+
liveins: $eax, $ebx
217+
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
218+
RETQ $eax, debug-location !48
219+
220+
...
221+
---
222+
name: baz
223+
tracksRegLiveness: true
224+
registers: []
225+
liveins:
226+
- { reg: '$rdi', virtual-reg: '' }
227+
body: |
228+
bb.0.entry:
229+
successors: %bb.1
230+
liveins: $rdi
231+
232+
$ecx = XOR32rr undef $ecx, undef $ecx, implicit-def $eflags
233+
DBG_VALUE $cx, $noreg, !83, !DIExpression(DW_OP_LLVM_fragment, 0, 16), debug-location !88
234+
JMP_1 %bb.1
235+
236+
bb.1.bb1:
237+
successors: %bb.2
238+
liveins: $ecx, $rdi
239+
240+
$eax = MOV32rr killed $ecx, implicit-def $rax
241+
DBG_VALUE $rdi, $noreg, !83, !DIExpression(), debug-location !88
242+
JMP_1 %bb.2
243+
244+
bb.2.bb2:
245+
successors: %bb.3
246+
liveins: $eax
247+
248+
$ebx = MOV32rr $eax
249+
$ebx = ADD32ri8 $ebx, 3, implicit-def dead $eflags, implicit killed $rbx, implicit-def $rbx
250+
DBG_VALUE $ebx, $noreg, !83, !DIExpression(DW_OP_LLVM_fragment, 32, 32), debug-location !88
251+
JMP_1 %bb.3
252+
253+
bb.3.bb3:
254+
liveins: $eax, $ebx
255+
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
256+
RETQ $eax, debug-location !88
257+
258+
...

0 commit comments

Comments
 (0)
Please sign in to comment.