[llvm] [llvm-debuginfo-analyzer] Remove `LVScope::Children` container (PR #144750)
Javier Lopez-Gomez via llvm-commits
llvm-commits at lists.llvm.org
Wed Sep 17 07:39:30 PDT 2025
https://github.com/jalopezg-git updated https://github.com/llvm/llvm-project/pull/144750
>From be464c5c648ae48b7686ec9a52bfafcf7398c1fd Mon Sep 17 00:00:00 2001
From: Javier Lopez-Gomez <javier.lopez.gomez at proton.me>
Date: Wed, 17 Sep 2025 16:39:14 +0200
Subject: [PATCH 1/3] [ADT] Simplify `llvm::concat_iterator` implementation
Simplify `llvm::concat_iterator::increment()` and `llvm::concat_iterator::get()`.
This makes it possible to also get rid of `handle_type`, which was causing
some additional complications.
---
llvm/include/llvm/ADT/STLExtras.h | 64 ++++++++++---------------------
1 file changed, 20 insertions(+), 44 deletions(-)
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
index 02705fbc8f2c4..411520cd228e5 100644
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -1000,10 +1000,6 @@ class concat_iterator
using reference_type =
typename std::conditional_t<ReturnsByValue, ValueT, ValueT &>;
- using handle_type =
- typename std::conditional_t<ReturnsByValue, std::optional<ValueT>,
- ValueT *>;
-
/// We store both the current and end iterators for each concatenated
/// sequence in a tuple of pairs.
///
@@ -1013,49 +1009,38 @@ class concat_iterator
std::tuple<IterTs...> Begins;
std::tuple<IterTs...> Ends;
- /// Attempts to increment a specific iterator.
- ///
- /// Returns true if it was able to increment the iterator. Returns false if
- /// the iterator is already at the end iterator.
- template <size_t Index> bool incrementHelper() {
+ /// Attempts to increment the `Index`-th iterator. If the iterator is already
+ /// at end, recurse over iterators in `Others...`.
+ template <size_t Index, size_t... Others> void incrementImpl() {
auto &Begin = std::get<Index>(Begins);
auto &End = std::get<Index>(Ends);
- if (Begin == End)
- return false;
-
+ if (Begin == End) {
+ if constexpr (sizeof...(Others) != 0)
+ return incrementImpl<Others...>();
+ llvm_unreachable("Attempted to increment an end concat iterator!");
+ }
++Begin;
- return true;
}
/// Increments the first non-end iterator.
///
/// It is an error to call this with all iterators at the end.
template <size_t... Ns> void increment(std::index_sequence<Ns...>) {
- // Build a sequence of functions to increment each iterator if possible.
- bool (concat_iterator::*IncrementHelperFns[])() = {
- &concat_iterator::incrementHelper<Ns>...};
-
- // Loop over them, and stop as soon as we succeed at incrementing one.
- for (auto &IncrementHelperFn : IncrementHelperFns)
- if ((this->*IncrementHelperFn)())
- return;
-
- llvm_unreachable("Attempted to increment an end concat iterator!");
+ incrementImpl<Ns...>();
}
- /// Returns null if the specified iterator is at the end. Otherwise,
- /// dereferences the iterator and returns the address of the resulting
- /// reference.
- template <size_t Index> handle_type getHelper() const {
+ /// Dereferences the `Index`-th iterator and returns the resulting reference.
+ /// If `Index` is at end, recurse over iterators in `Others...`.
+ template <size_t Index, size_t... Others> handle_type getImpl() const {
auto &Begin = std::get<Index>(Begins);
auto &End = std::get<Index>(Ends);
- if (Begin == End)
- return {};
-
- if constexpr (ReturnsByValue)
- return *Begin;
- else
- return &*Begin;
+ if (Begin == End) {
+ if constexpr (sizeof...(Others) != 0)
+ return getImpl<Others...>();
+ llvm_unreachable(
+ "Attempted to get a pointer from an end concat iterator!");
+ }
+ return *Begin;
}
/// Finds the first non-end iterator, dereferences, and returns the resulting
@@ -1063,16 +1048,7 @@ class concat_iterator
///
/// It is an error to call this with all iterators at the end.
template <size_t... Ns> reference_type get(std::index_sequence<Ns...>) const {
- // Build a sequence of functions to get from iterator if possible.
- handle_type (concat_iterator::*GetHelperFns[])()
- const = {&concat_iterator::getHelper<Ns>...};
-
- // Loop over them, and return the first result we find.
- for (auto &GetHelperFn : GetHelperFns)
- if (auto P = (this->*GetHelperFn)())
- return *P;
-
- llvm_unreachable("Attempted to get a pointer from an end concat iterator!");
+ return getImpl<Ns...>();
}
public:
>From 59312b76171c574e501cac8f4709e73baf99a3f8 Mon Sep 17 00:00:00 2001
From: Javier Lopez-Gomez <javier.lopez.gomez at proton.me>
Date: Wed, 17 Sep 2025 16:39:14 +0200
Subject: [PATCH 2/3] [ADT] Fix llvm::concat_iterator for `ValueT ==
common_base_class *`
Fix llvm::concat_iterator for the case of `ValueT` being a pointer
to a common base class to which the result of dereferencing any
iterator in `ItersT` can be casted to.
---
llvm/include/llvm/ADT/STLExtras.h | 21 ++++++++++--
llvm/unittests/ADT/STLExtrasTest.cpp | 48 ++++++++++++++++++++++++++++
2 files changed, 66 insertions(+), 3 deletions(-)
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
index 411520cd228e5..04e7717bc0b6b 100644
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -114,6 +114,13 @@ using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
template <typename T, typename... Ts>
using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
+/// traits class for checking whether type `T` is same as all other types in
+/// `Ts`.
+template <typename T = void, typename... Ts>
+using all_types_equal = std::conjunction<std::is_same<T, Ts>...>;
+template <typename T = void, typename... Ts>
+constexpr bool all_types_equal_v = all_types_equal<T, Ts...>::value;
+
/// Determine if all types in Ts are distinct.
///
/// Useful to statically assert when Ts is intended to describe a non-multi set
@@ -996,9 +1003,17 @@ class concat_iterator
static constexpr bool ReturnsByValue =
!(std::is_reference_v<decltype(*std::declval<IterTs>())> && ...);
-
+ static constexpr bool ReturnsConvertibleType =
+ !all_types_equal_v<std::remove_cv_t<ValueT>,
+ std::remove_cv_t<std::remove_reference_t<
+ decltype(*std::declval<IterTs>())>>...> &&
+ (std::is_convertible_v<decltype(*std::declval<IterTs>()), ValueT> && ...);
+
+ // Cannot return a reference type if a conversion takes place, provided that
+ // the result of dereferencing all `IterTs...` is convertible to `ValueT`.
using reference_type =
- typename std::conditional_t<ReturnsByValue, ValueT, ValueT &>;
+ typename std::conditional_t<ReturnsByValue || ReturnsConvertibleType,
+ ValueT, ValueT &>;
/// We store both the current and end iterators for each concatenated
/// sequence in a tuple of pairs.
@@ -1031,7 +1046,7 @@ class concat_iterator
/// Dereferences the `Index`-th iterator and returns the resulting reference.
/// If `Index` is at end, recurse over iterators in `Others...`.
- template <size_t Index, size_t... Others> handle_type getImpl() const {
+ template <size_t Index, size_t... Others> reference_type getImpl() const {
auto &Begin = std::get<Index>(Begins);
auto &End = std::get<Index>(Ends);
if (Begin == End) {
diff --git a/llvm/unittests/ADT/STLExtrasTest.cpp b/llvm/unittests/ADT/STLExtrasTest.cpp
index d355a59973f9a..d15c19d1b11dc 100644
--- a/llvm/unittests/ADT/STLExtrasTest.cpp
+++ b/llvm/unittests/ADT/STLExtrasTest.cpp
@@ -398,6 +398,8 @@ struct some_struct {
std::string swap_val;
};
+struct derives_from_some_struct : some_struct {};
+
std::vector<int>::const_iterator begin(const some_struct &s) {
return s.data.begin();
}
@@ -500,6 +502,15 @@ TEST(STLExtrasTest, ToVector) {
}
}
+TEST(STLExtrasTest, AllTypesSameAs) {
+ static_assert(all_types_equal_v<>);
+ static_assert(all_types_equal_v<int>);
+ static_assert(all_types_equal_v<int, int, int>);
+
+ static_assert(!all_types_equal_v<int, int, unsigned int>);
+ static_assert(!all_types_equal_v<int, int, float>);
+}
+
TEST(STLExtrasTest, ConcatRange) {
std::vector<int> Expected = {1, 2, 3, 4, 5, 6, 7, 8};
std::vector<int> Test;
@@ -532,6 +543,43 @@ TEST(STLExtrasTest, ConcatRangeADL) {
EXPECT_THAT(concat<const int>(S0, S1), ElementsAre(1, 2, 3, 4));
}
+TEST(STLExtrasTest, ConcatRangePtrToSameClass) {
+ some_namespace::some_struct S0{};
+ some_namespace::some_struct S1{};
+ SmallVector<some_namespace::some_struct *> V0{&S0};
+ SmallVector<some_namespace::some_struct *> V1{&S1, &S1};
+
+ // Dereferencing all iterators yields `some_namespace::some_struct *&`; no
+ // conversion takes place, `reference_type` is
+ // `some_namespace::some_struct *&`.
+ auto C = concat<some_namespace::some_struct *>(V0, V1);
+ static_assert(
+ std::is_same_v<decltype(*C.begin()), some_namespace::some_struct *&>);
+ EXPECT_THAT(C, ElementsAre(&S0, &S1, &S1));
+ // `reference_type` should still allow container modification.
+ for (auto &i : C)
+ if (i == &S0)
+ i = nullptr;
+ EXPECT_THAT(C, ElementsAre(nullptr, &S1, &S1));
+}
+
+TEST(STLExtrasTest, ConcatRangePtrToDerivedClass) {
+ some_namespace::some_struct S0{};
+ some_namespace::derives_from_some_struct S1{};
+ SmallVector<some_namespace::some_struct *> V0{&S0};
+ SmallVector<some_namespace::derives_from_some_struct *> V1{&S1, &S1};
+
+ // Dereferencing all iterators yields different (but convertible types);
+ // conversion takes place, `reference_type` is
+ // `some_namespace::some_struct *`.
+ auto C = concat<some_namespace::some_struct *>(V0, V1);
+ static_assert(
+ std::is_same_v<decltype(*C.begin()), some_namespace::some_struct *>);
+ EXPECT_THAT(C,
+ ElementsAre(&S0, static_cast<some_namespace::some_struct *>(&S1),
+ static_cast<some_namespace::some_struct *>(&S1)));
+}
+
TEST(STLExtrasTest, MakeFirstSecondRangeADL) {
// Make sure that we use the `begin`/`end` functions from `some_namespace`,
// using ADL.
>From 13ed6799691e4b9980ccf35f210b02794333d631 Mon Sep 17 00:00:00 2001
From: Javier Lopez-Gomez <javier.lopez.gomez at proton.me>
Date: Wed, 17 Sep 2025 16:39:14 +0200
Subject: [PATCH 3/3] [llvm-debuginfo-analyzer] Remove `LVScope::Children`
container
Remove the `LVScope::Children` container and use `llvm::concat()`
instead to return a view over the types, symbols, and sub-scopes
contained in a given `LVScope`.
---
.../llvm/DebugInfo/LogicalView/Core/LVScope.h | 24 +++---
.../DebugInfo/LogicalView/Core/LVScope.cpp | 76 +++++++++----------
.../01-dwarf-compare-logical-elements.test | 2 +-
.../pr-57040-incorrect-function-compare.test | 2 +-
.../01-wasm-compare-logical-elements.test | 2 +-
.../DebugInfo/LogicalView/DWARFReaderTest.cpp | 12 ++-
6 files changed, 57 insertions(+), 61 deletions(-)
diff --git a/llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h b/llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h
index a453923d032e4..f73ea5e2aa445 100644
--- a/llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h
+++ b/llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h
@@ -14,6 +14,7 @@
#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
+#include "llvm/ADT/STLExtras.h"
#include "llvm/DebugInfo/LogicalView/Core/LVElement.h"
#include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
#include "llvm/DebugInfo/LogicalView/Core/LVSort.h"
@@ -94,6 +95,11 @@ class LLVM_ABI LVScope : public LVElement {
LVProperties<LVScopeKind> Kinds;
LVProperties<Property> Properties;
static LVScopeDispatch Dispatch;
+ // Empty containers used in `getChildren()` in case there is no Types,
+ // Symbols, or Scopes.
+ static const LVTypes EmptyTypes;
+ static const LVSymbols EmptySymbols;
+ static const LVScopes EmptyScopes;
// Size in bits if this scope represents also a compound type.
uint32_t BitSize = 0;
@@ -128,14 +134,6 @@ class LLVM_ABI LVScope : public LVElement {
std::unique_ptr<LVLines> Lines;
std::unique_ptr<LVLocations> Ranges;
- // Vector of elements (types, scopes and symbols).
- // It is the union of (*Types, *Symbols and *Scopes) to be used for
- // the following reasons:
- // - Preserve the order the logical elements are read in.
- // - To have a single container with all the logical elements, when
- // the traversal does not require any specific element kind.
- std::unique_ptr<LVElements> Children;
-
// Resolve the template parameters/arguments relationship.
void resolveTemplate();
void printEncodedArgs(raw_ostream &OS, bool Full) const;
@@ -213,7 +211,14 @@ class LLVM_ABI LVScope : public LVElement {
const LVScopes *getScopes() const { return Scopes.get(); }
const LVSymbols *getSymbols() const { return Symbols.get(); }
const LVTypes *getTypes() const { return Types.get(); }
- const LVElements *getChildren() const { return Children.get(); }
+ // Return view over union of child Types, Symbols, and Scopes.
+ auto getChildren() const {
+ return llvm::concat<LVElement *const>(Scopes ? *Scopes : EmptyScopes,
+ Types ? *Types : EmptyTypes,
+ Symbols ? *Symbols : EmptySymbols);
+ }
+ // Return sorted children (see `LVOptions::setSortMode()`).
+ LVElements getSortedChildren() const;
void addElement(LVElement *Element);
void addElement(LVLine *Line);
@@ -222,7 +227,6 @@ class LLVM_ABI LVScope : public LVElement {
void addElement(LVType *Type);
void addObject(LVLocation *Location);
void addObject(LVAddress LowerAddress, LVAddress UpperAddress);
- void addToChildren(LVElement *Element);
// Add the missing elements from the given 'Reference', which is the
// scope associated with any DW_AT_specification, DW_AT_abstract_origin.
diff --git a/llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp b/llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp
index 64f1bfc015380..95b38a844da62 100644
--- a/llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp
+++ b/llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp
@@ -107,10 +107,16 @@ LVScopeDispatch LVScope::Dispatch = {
{LVScopeKind::IsTryBlock, &LVScope::getIsTryBlock},
{LVScopeKind::IsUnion, &LVScope::getIsUnion}};
-void LVScope::addToChildren(LVElement *Element) {
- if (!Children)
- Children = std::make_unique<LVElements>();
- Children->push_back(Element);
+const LVTypes LVScope::EmptyTypes{};
+const LVSymbols LVScope::EmptySymbols{};
+const LVScopes LVScope::EmptyScopes{};
+
+LVElements LVScope::getSortedChildren() const {
+ const auto UnsortedChildren = getChildren();
+ LVElements Elements{UnsortedChildren.begin(), UnsortedChildren.end()};
+ if (LVSortFunction SortFunction = getSortFunction())
+ llvm::stable_sort(Elements, SortFunction);
+ return Elements;
}
void LVScope::addElement(LVElement *Element) {
@@ -175,7 +181,6 @@ void LVScope::addElement(LVScope *Scope) {
// Add it to parent.
Scopes->push_back(Scope);
- addToChildren(Scope);
Scope->setParent(this);
// Notify the reader about the new element being added.
@@ -202,7 +207,6 @@ void LVScope::addElement(LVSymbol *Symbol) {
// Add it to parent.
Symbols->push_back(Symbol);
- addToChildren(Symbol);
Symbol->setParent(this);
// Notify the reader about the new element being added.
@@ -229,7 +233,6 @@ void LVScope::addElement(LVType *Type) {
// Add it to parent.
Types->push_back(Type);
- addToChildren(Type);
Type->setParent(this);
// Notify the reader about the new element being added.
@@ -277,15 +280,12 @@ bool LVScope::removeElement(LVElement *Element) {
if (Element->getIsLine())
return RemoveElement(Lines);
- if (RemoveElement(Children)) {
- if (Element->getIsSymbol())
- return RemoveElement(Symbols);
- if (Element->getIsType())
- return RemoveElement(Types);
- if (Element->getIsScope())
- return RemoveElement(Scopes);
- llvm_unreachable("Invalid element.");
- }
+ if (Element->getIsSymbol())
+ return RemoveElement(Symbols);
+ if (Element->getIsType())
+ return RemoveElement(Types);
+ if (Element->getIsScope())
+ return RemoveElement(Scopes);
return false;
}
@@ -356,9 +356,8 @@ void LVScope::updateLevel(LVScope *Parent, bool Moved) {
setLevel(Parent->getLevel() + 1);
// Update the children.
- if (Children)
- for (LVElement *Element : *Children)
- Element->updateLevel(this, Moved);
+ for (LVElement *Element : getChildren())
+ Element->updateLevel(this, Moved);
// Update any lines.
if (Lines)
@@ -374,13 +373,12 @@ void LVScope::resolve() {
LVElement::resolve();
// Resolve the children.
- if (Children)
- for (LVElement *Element : *Children) {
- if (getIsGlobalReference())
- // If the scope is a global reference, mark all its children as well.
- Element->setIsGlobalReference();
- Element->resolve();
- }
+ for (LVElement *Element : getChildren()) {
+ if (getIsGlobalReference())
+ // If the scope is a global reference, mark all its children as well.
+ Element->setIsGlobalReference();
+ Element->resolve();
+ }
}
void LVScope::resolveName() {
@@ -633,14 +631,13 @@ Error LVScope::doPrint(bool Split, bool Match, bool Print, raw_ostream &OS,
options().getPrintFormatting() &&
getLevel() < options().getOutputLevel()) {
// Print the children.
- if (Children)
- for (const LVElement *Element : *Children) {
- if (Match && !Element->getHasPattern())
- continue;
- if (Error Err =
- Element->doPrint(Split, Match, Print, *StreamSplit, Full))
- return Err;
- }
+ for (const LVElement *Element : getSortedChildren()) {
+ if (Match && !Element->getHasPattern())
+ continue;
+ if (Error Err =
+ Element->doPrint(Split, Match, Print, *StreamSplit, Full))
+ return Err;
+ }
// Print the line records.
if (Lines)
@@ -692,7 +689,6 @@ void LVScope::sort() {
Traverse(Parent->Symbols, SortFunction);
Traverse(Parent->Scopes, SortFunction);
Traverse(Parent->Ranges, compareRange);
- Traverse(Parent->Children, SortFunction);
if (Parent->Scopes)
for (LVScope *Scope : *Parent->Scopes)
@@ -978,9 +974,8 @@ bool LVScope::equals(const LVScopes *References, const LVScopes *Targets) {
void LVScope::report(LVComparePass Pass) {
getComparator().printItem(this, Pass);
getComparator().push(this);
- if (Children)
- for (LVElement *Element : *Children)
- Element->report(Pass);
+ for (LVElement *Element : getSortedChildren())
+ Element->report(Pass);
if (Lines)
for (LVLine *Line : *Lines)
@@ -1656,9 +1651,8 @@ void LVScopeCompileUnit::printMatchedElements(raw_ostream &OS,
// Print the view for the matched scopes.
for (const LVScope *Scope : MatchedScopes) {
Scope->print(OS);
- if (const LVElements *Elements = Scope->getChildren())
- for (LVElement *Element : *Elements)
- Element->print(OS);
+ for (LVElement *Element : Scope->getSortedChildren())
+ Element->print(OS);
}
}
diff --git a/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-compare-logical-elements.test b/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-compare-logical-elements.test
index a076887140c28..1b790eeb3b691 100644
--- a/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-compare-logical-elements.test
+++ b/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-compare-logical-elements.test
@@ -35,8 +35,8 @@
; ONE-NEXT: [002] 1 {TypeAlias} 'INTPTR' -> '* const int'
; ONE-NEXT: [002] 2 {Function} extern not_inlined 'foo' -> 'int'
; ONE-NEXT: [003] {Block}
-; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: +[004] 4 {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: [003] 2 {Parameter} 'ParamBool' -> 'bool'
; ONE-NEXT: [003] 2 {Parameter} 'ParamPtr' -> 'INTPTR'
; ONE-NEXT: [003] 2 {Parameter} 'ParamUnsigned' -> 'unsigned int'
diff --git a/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-incorrect-function-compare.test b/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-incorrect-function-compare.test
index 278d4f4850f5f..78604d9164c0f 100644
--- a/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-incorrect-function-compare.test
+++ b/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-incorrect-function-compare.test
@@ -55,8 +55,8 @@
; ONE-NEXT: [002] 1 {TypeAlias} 'INTPTR' -> '* const int'
; ONE-NEXT: [002] 2 {Function} extern not_inlined 'foo' -> 'int'
; ONE-NEXT: [003] {Block}
-; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: +[004] 4 {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: [003] 2 {Parameter} 'ParamBool' -> 'bool'
; ONE-NEXT: [003] 2 {Parameter} 'ParamPtr' -> 'INTPTR'
; ONE-NEXT: [003] 2 {Parameter} 'ParamUnsigned' -> 'unsigned int'
diff --git a/llvm/test/tools/llvm-debuginfo-analyzer/WebAssembly/01-wasm-compare-logical-elements.test b/llvm/test/tools/llvm-debuginfo-analyzer/WebAssembly/01-wasm-compare-logical-elements.test
index f52c9c7cc7164..98fc47e3d3c80 100644
--- a/llvm/test/tools/llvm-debuginfo-analyzer/WebAssembly/01-wasm-compare-logical-elements.test
+++ b/llvm/test/tools/llvm-debuginfo-analyzer/WebAssembly/01-wasm-compare-logical-elements.test
@@ -38,8 +38,8 @@
; ONE-NEXT: [002] 1 {TypeAlias} 'INTPTR' -> '* const int'
; ONE-NEXT: [002] 2 {Function} extern not_inlined 'foo' -> 'int'
; ONE-NEXT: [003] {Block}
-; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: +[004] 4 {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT: [004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
; ONE-NEXT: [003] 2 {Parameter} 'ParamBool' -> 'bool'
; ONE-NEXT: [003] 2 {Parameter} 'ParamPtr' -> 'INTPTR'
; ONE-NEXT: [003] 2 {Parameter} 'ParamUnsigned' -> 'unsigned int'
diff --git a/llvm/unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp b/llvm/unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp
index 78dc8502e9676..003d454b12a38 100644
--- a/llvm/unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp
+++ b/llvm/unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp
@@ -163,13 +163,12 @@ void checkUnspecifiedParameters(LVReader *Reader) {
LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
LVScope *Function = (*IterNames).first;
EXPECT_EQ(Function->getName(), "foo_printf");
- const LVElements *Elements = Function->getChildren();
- ASSERT_NE(Elements, nullptr);
+ const auto Elements = Function->getChildren();
// foo_printf is a variadic function whose prototype is
// `int foo_printf(const char *, ...)`, where the '...' is represented by a
// DW_TAG_unspecified_parameters, i.e. we expect to find at least one child
// for which getIsUnspecified() returns true.
- EXPECT_TRUE(llvm::any_of(*Elements, [](const LVElement *elt) {
+ EXPECT_TRUE(llvm::any_of(Elements, [](const LVElement *elt) {
return elt->getIsSymbol() &&
static_cast<const LVSymbol *>(elt)->getIsUnspecified();
}));
@@ -183,10 +182,9 @@ void checkScopeModule(LVReader *Reader) {
EXPECT_EQ(Root->getFileFormatName(), "Mach-O 64-bit x86-64");
EXPECT_EQ(Root->getName(), DwarfClangModule);
- ASSERT_NE(CompileUnit->getChildren(), nullptr);
- LVElement *FirstChild = *(CompileUnit->getChildren()->begin());
- EXPECT_EQ(FirstChild->getIsScope(), 1);
- LVScopeModule *Module = static_cast<LVScopeModule *>(FirstChild);
+ ASSERT_NE(CompileUnit->getScopes(), nullptr);
+ LVElement *FirstScope = *(CompileUnit->getScopes()->begin());
+ LVScopeModule *Module = static_cast<LVScopeModule *>(FirstScope);
EXPECT_EQ(Module->getIsModule(), 1);
EXPECT_EQ(Module->getName(), "DebugModule");
}
More information about the llvm-commits
mailing list