derek/TheRock
1
0 Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
main
TheRock/compiler/amd-llvm/lldb/unittests/SymbolFile/DWARF/DWARFDIETest.cpp
T
derek.holloway 7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
Details
CodeQL / Analyze (python) (push) Canceled after 0s
Details
pre-commit / pre-commit (push) Canceled after 0s
Details
Multi-Arch CI / setup (push) Canceled after 0s
Details
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Details
Setup (Multi-Arch) / setup (push) Canceled after 0s
Details
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Details
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
Details
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Details
Multi-Arch CI / CI Summary (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Details
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Details
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
Details
Flatten subprojects into a single base monorepo
2026-09-02 16:34:47 -07:00

1202 lines
38 KiB
C++
Raw Permalink Blame History

//===-- DWARFDIETest.cpp ----------------------------------------------=---===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
#include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
#include "TestingSupport/Symbol/YAMLModuleTester.h"
#include "TestingSupport/TestUtilities.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/dwarf.h"
#include "lldb/Expression/DWARFExpression.h"
#include "lldb/Expression/DWARFExpressionList.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/lldb-private-enumerations.h"
#include "llvm/ADT/STLExtras.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::plugin::dwarf;
using namespace llvm::dwarf;
TEST(DWARFDIETest, ChildIteration) {
// Tests DWARFDIE::child_iterator.
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_386
DWARF:
debug_abbrev:
- Table:
- Code: 0x00000001
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x00000002
Tag: DW_TAG_base_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_encoding
Form: DW_FORM_data1
- Attribute: DW_AT_byte_size
Form: DW_FORM_data1
debug_info:
- Version: 4
AddrSize: 8
Entries:
- AbbrCode: 0x00000001
Values:
- Value: 0x000000000000000C
- AbbrCode: 0x00000002
Values:
- Value: 0x0000000000000007 # DW_ATE_unsigned
- Value: 0x0000000000000004
- AbbrCode: 0x00000002
Values:
- Value: 0x0000000000000007 # DW_ATE_unsigned
- Value: 0x0000000000000008
- AbbrCode: 0x00000002
Values:
- Value: 0x0000000000000005 # DW_ATE_signed
- Value: 0x0000000000000008
- AbbrCode: 0x00000000
)";
YAMLModuleTester t(yamldata);
ASSERT_TRUE((bool)t.GetDwarfUnit());
DWARFUnit *unit = t.GetDwarfUnit();
const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
// Create a DWARFDIE that has three DW_TAG_base_type children.
DWARFDIE top_die(unit, die_first);
// Create the iterator range that has the three tags as elements.
llvm::iterator_range<DWARFDIE::child_iterator> children = top_die.children();
// Compare begin() to the first child DIE.
DWARFDIE::child_iterator child_iter = children.begin();
ASSERT_NE(child_iter, children.end());
const DWARFDebugInfoEntry *die_child0 = die_first->GetFirstChild();
EXPECT_EQ((*child_iter).GetDIE(), die_child0);
// Step to the second child DIE.
++child_iter;
ASSERT_NE(child_iter, children.end());
const DWARFDebugInfoEntry *die_child1 = die_child0->GetSibling();
EXPECT_EQ((*child_iter).GetDIE(), die_child1);
// Step to the third child DIE.
++child_iter;
ASSERT_NE(child_iter, children.end());
const DWARFDebugInfoEntry *die_child2 = die_child1->GetSibling();
EXPECT_EQ((*child_iter).GetDIE(), die_child2);
// Step to the end of the range.
++child_iter;
EXPECT_EQ(child_iter, children.end());
// Take one of the DW_TAG_base_type DIEs (which has no children) and make
// sure the children range is now empty.
DWARFDIE no_children_die(unit, die_child0);
EXPECT_TRUE(no_children_die.children().empty());
}
TEST(DWARFDIETest, PeekName) {
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_386
DWARF:
debug_str:
- 'NameType1'
- 'NameType2'
debug_abbrev:
- Table:
- Code: 0x00000001
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x00000002
Tag: DW_TAG_base_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_strp
- Code: 0x00000003
Tag: DW_TAG_base_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_abstract_origin
Form: DW_FORM_ref1
- Code: 0x00000004
Tag: DW_TAG_base_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_specification
Form: DW_FORM_ref1
debug_info:
- Version: 4
AddrSize: 8
Entries:
- AbbrCode: 0x00000001
Values:
- Value: 0x000000000000000C
- AbbrCode: 0x00000002
Values:
- Value: 0x0000000000000000 # Name = NameType1
- AbbrCode: 0x00000002
Values:
- Value: 0x000000000000000a # Name = NameType2
- AbbrCode: 0x00000003
Values:
- Value: 0x000000000000000e # Ref abstract origin to NameType1 DIE.
- AbbrCode: 0x00000004
Values:
- Value: 0x0000000000000013 # Ref specification to NameType2 DIE.
- AbbrCode: 0x00000000
)";
YAMLModuleTester t(yamldata);
auto *symbol_file =
llvm::cast<SymbolFileDWARF>(t.GetModule()->GetSymbolFile());
DWARFUnit *unit = symbol_file->DebugInfo().GetUnitAtIndex(0);
dw_offset_t first_die_offset = 11;
EXPECT_EQ(unit->PeekDIEName(first_die_offset), "");
dw_offset_t second_die_offset = 14;
EXPECT_EQ(unit->PeekDIEName(second_die_offset), "NameType1");
dw_offset_t third_die_offset = 19;
EXPECT_EQ(unit->PeekDIEName(third_die_offset), "NameType2");
dw_offset_t fourth_die_offset = 24;
EXPECT_EQ(unit->PeekDIEName(fourth_die_offset), "NameType1");
dw_offset_t fifth_die_offset = 26;
EXPECT_EQ(unit->PeekDIEName(fifth_die_offset), "NameType2");
}
TEST(DWARFDIETest, GetContext) {
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_386
DWARF:
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_namespace
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Code: 0x3
Tag: DW_TAG_structure_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Code: 0x4
Tag: DW_TAG_namespace
Children: DW_CHILDREN_yes
debug_info:
- Version: 4
AddrSize: 8
Entries:
- AbbrCode: 0x1
Values:
- Value: 0x000000000000000C
- AbbrCode: 0x2
Values:
- CStr: NAMESPACE
- AbbrCode: 0x3
Values:
- CStr: STRUCT
- AbbrCode: 0x4
- AbbrCode: 0x3
Values:
- CStr: STRUCT
- AbbrCode: 0x0
- AbbrCode: 0x0
- AbbrCode: 0x0
)";
YAMLModuleTester t(yamldata);
auto *symbol_file =
llvm::cast<SymbolFileDWARF>(t.GetModule()->GetSymbolFile());
DWARFUnit *unit = symbol_file->DebugInfo().GetUnitAtIndex(0);
ASSERT_TRUE(unit);
auto make_namespace = [](const char *name) {
return CompilerContext(CompilerContextKind::Namespace, ConstString(name));
};
auto make_struct = [](const char *name) {
return CompilerContext(CompilerContextKind::ClassOrStruct,
ConstString(name));
};
DWARFDIE struct_die = unit->DIE().GetFirstChild().GetFirstChild();
ASSERT_TRUE(struct_die);
DWARFDIE anon_struct_die = struct_die.GetSibling().GetFirstChild();
ASSERT_TRUE(anon_struct_die);
EXPECT_THAT(
struct_die.GetDeclContext(),
testing::ElementsAre(make_namespace("NAMESPACE"), make_struct("STRUCT")));
EXPECT_THAT(
struct_die.GetTypeLookupContext(),
testing::ElementsAre(make_namespace("NAMESPACE"), make_struct("STRUCT")));
EXPECT_THAT(struct_die.GetDWARFDeclContext(),
DWARFDeclContext({{DW_TAG_structure_type, "STRUCT"},
{DW_TAG_namespace, "NAMESPACE"}}));
EXPECT_THAT(anon_struct_die.GetDeclContext(),
testing::ElementsAre(make_namespace("NAMESPACE"),
make_namespace(nullptr),
make_struct("STRUCT")));
EXPECT_THAT(anon_struct_die.GetTypeLookupContext(),
testing::ElementsAre(make_namespace("NAMESPACE"),
make_namespace(nullptr),
make_struct("STRUCT")));
EXPECT_THAT(anon_struct_die.GetDWARFDeclContext(),
DWARFDeclContext({{DW_TAG_structure_type, "STRUCT"},
{DW_TAG_namespace, nullptr},
{DW_TAG_namespace, "NAMESPACE"}}));
}
TEST(DWARFDIETest, GetContextInFunction) {
// Make sure we get the right context fo each "struct_t" type. The first
// should be "a::struct_t" and the one defined in the "foo" function should be
// "struct_t". Previous DWARFDIE::GetTypeLookupContext() function calls would
// have the "struct_t" in "foo" be "a::struct_t" because it would traverse the
// entire die parent tree and ignore DW_TAG_subprogram and keep traversing the
// parents.
//
// 0x0000000b: DW_TAG_compile_unit
// 0x0000000c: DW_TAG_namespace
// DW_AT_name("a")
// 0x0000000f: DW_TAG_structure_type
// DW_AT_name("struct_t")
// 0x00000019: DW_TAG_subprogram
// DW_AT_name("foo")
// 0x0000001e: DW_TAG_structure_type
// DW_AT_name("struct_t")
// 0x00000028: NULL
// 0x00000029: NULL
// 0x0000002a: NULL
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_386
DWARF:
debug_str:
- ''
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
- Code: 0x2
Tag: DW_TAG_namespace
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Code: 0x3
Tag: DW_TAG_structure_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Code: 0x4
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
debug_info:
- Length: 0x27
Version: 4
AbbrevTableID: 0
AbbrOffset: 0x0
AddrSize: 8
Entries:
- AbbrCode: 0x1
- AbbrCode: 0x2
Values:
- Value: 0xDEADBEEFDEADBEEF
CStr: a
- AbbrCode: 0x3
Values:
- Value: 0xDEADBEEFDEADBEEF
CStr: struct_t
- AbbrCode: 0x4
Values:
- Value: 0xDEADBEEFDEADBEEF
CStr: foo
- AbbrCode: 0x3
Values:
- Value: 0xDEADBEEFDEADBEEF
CStr: struct_t
- AbbrCode: 0x0
- AbbrCode: 0x0
- AbbrCode: 0x0)";
YAMLModuleTester t(yamldata);
auto *symbol_file =
llvm::cast<SymbolFileDWARF>(t.GetModule()->GetSymbolFile());
DWARFUnit *unit = symbol_file->DebugInfo().GetUnitAtIndex(0);
ASSERT_TRUE(unit);
auto make_namespace = [](llvm::StringRef name) {
return CompilerContext(CompilerContextKind::Namespace, ConstString(name));
};
auto make_struct = [](llvm::StringRef name) {
return CompilerContext(CompilerContextKind::ClassOrStruct,
ConstString(name));
};
// Grab the "a::struct_t" type from the "a" namespace
DWARFDIE a_struct_die = unit->DIE().GetFirstChild().GetFirstChild();
ASSERT_TRUE(a_struct_die);
EXPECT_THAT(
a_struct_die.GetDeclContext(),
testing::ElementsAre(make_namespace("a"), make_struct("struct_t")));
// Grab the "struct_t" defined in the "foo" function.
DWARFDIE foo_struct_die =
unit->DIE().GetFirstChild().GetFirstChild().GetSibling().GetFirstChild();
EXPECT_THAT(foo_struct_die.GetTypeLookupContext(),
testing::ElementsAre(make_struct("struct_t")));
}
TEST(DWARFDIETest, GetAttributeValue_ImplicitConst) {
// Make sure we can correctly retrieve the value of an attribute
// that has a DW_FORM_implicit_const form.
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_386
DWARF:
debug_str:
- ''
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Attribute: DW_AT_object_pointer
Form: DW_FORM_implicit_const
Value: 5
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
- AbbrCode: 0x1
- AbbrCode: 0x2
Values:
- Value: 0xDEADBEEFDEADBEEF
CStr: func
- AbbrCode: 0x0)";
YAMLModuleTester t(yamldata);
auto *symbol_file =
llvm::cast<SymbolFileDWARF>(t.GetModule()->GetSymbolFile());
DWARFUnit *unit = symbol_file->DebugInfo().GetUnitAtIndex(0);
ASSERT_TRUE(unit);
DWARFDIE subprogram = unit->DIE().GetFirstChild();
ASSERT_TRUE(subprogram);
dw_offset_t end_attr_offset;
DWARFFormValue form_value;
dw_offset_t offset = subprogram.GetDIE()->GetAttributeValue(
unit, DW_AT_object_pointer, form_value, &end_attr_offset);
EXPECT_EQ(form_value.Unsigned(), 5U);
EXPECT_GT(offset, 0U);
EXPECT_GT(end_attr_offset, 0U);
}
struct GetAttributesTestFixture : public testing::TestWithParam<dw_attr_t> {};
TEST_P(GetAttributesTestFixture, TestGetAttributes_IterationOrder) {
// Tests that we accumulate all current DIE's attributes first
// before checking the attributes of the specification.
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_str:
- func
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_high_pc
Form: DW_FORM_data4
- Attribute: DW_AT_name
Form: DW_FORM_strp
- Attribute: DW_AT_declaration
Form: DW_FORM_flag_present
- Attribute: DW_AT_external
Form: DW_FORM_flag_present
- Attribute: DW_AT_low_pc
Form: DW_FORM_data4
- Code: 0x3
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_high_pc
Form: DW_FORM_data4
- Attribute: {0}
Form: DW_FORM_ref4
- Attribute: DW_AT_low_pc
Form: DW_FORM_data4
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
# DW_TAG_compile_unit
# DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
- AbbrCode: 0x1
Values:
- Value: 0x04
# DW_TAG_subprogram
# DW_AT_high_pc [DW_FORM_data4]
# DW_AT_name [DW_FORM_strp] ("func")
# DW_AT_low_pc [DW_FORM_data4]
- AbbrCode: 0x2
Values:
- Value: 0xdeadbeef
- Value: 0x0
- Value: 0x1
- Value: 0x1
- Value: 0xdeadbeef
# DW_TAG_subprogram
# DW_AT_high_pc [DW_FORM_data4]
# DW_AT_specification [DW_FORM_ref4] ("func")
# DW_AT_low_pc [DW_FORM_data4]
- AbbrCode: 0x3
Values:
- Value: 0xf00dcafe
- Value: 0xf
- Value: 0xf00dcafe
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(llvm::formatv(yamldata, GetParam()).str());
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto declaration = cu_die.GetFirstChild();
ASSERT_TRUE(declaration.IsValid());
ASSERT_EQ(declaration.Tag(), DW_TAG_subprogram);
auto definition = declaration.GetSibling();
ASSERT_TRUE(definition.IsValid());
ASSERT_EQ(definition.Tag(), DW_TAG_subprogram);
ASSERT_FALSE(definition.GetAttributeValueAsOptionalUnsigned(DW_AT_external));
auto attrs = definition.GetAttributes(DWARFDebugInfoEntry::Recurse::yes);
EXPECT_EQ(attrs.Size(), 7U);
// Check that the attributes on the definition (that are also present
// on the declaration) take precedence.
for (auto attr : {DW_AT_low_pc, DW_AT_high_pc}) {
auto idx = attrs.FindAttributeIndex(attr);
EXPECT_NE(idx, UINT32_MAX);
DWARFFormValue form_value;
auto success = attrs.ExtractFormValueAtIndex(idx, form_value);
EXPECT_TRUE(success);
EXPECT_EQ(form_value.Unsigned(), 0xf00dcafe);
}
}
TEST_P(GetAttributesTestFixture, TestGetAttributes_Cycle) {
// Tests that GetAttributes can deal with cycles in
// specifications/abstract origins.
//
// Contrived example:
//
// func1 -> func3
// ^ |
// | v
// +------func2
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: {0}
Form: DW_FORM_ref4
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
- AbbrCode: 0x1
Values:
- Value: 0x04
- AbbrCode: 0x2
Values:
- Value: 0x19
- AbbrCode: 0x2
Values:
- Value: 0xf
- AbbrCode: 0x2
Values:
- Value: 0x14
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(llvm::formatv(yamldata, GetParam()).str());
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto func1 = cu_die.GetFirstChild();
ASSERT_TRUE(func1.IsValid());
ASSERT_EQ(func1.Tag(), DW_TAG_subprogram);
auto func2 = func1.GetSibling();
ASSERT_TRUE(func2.IsValid());
ASSERT_EQ(func2.Tag(), DW_TAG_subprogram);
auto func3 = func2.GetSibling();
ASSERT_TRUE(func3.IsValid());
ASSERT_EQ(func3.Tag(), DW_TAG_subprogram);
auto attrs = func1.GetAttributes(DWARFDebugInfoEntry::Recurse::yes);
EXPECT_EQ(attrs.Size(), 3U);
// Confirm that the specifications do form a cycle.
{
DWARFFormValue form_value;
auto success = attrs.ExtractFormValueAtIndex(0, form_value);
ASSERT_TRUE(success);
EXPECT_EQ(form_value.Reference(), func3);
}
{
DWARFFormValue form_value;
auto success = attrs.ExtractFormValueAtIndex(1, form_value);
ASSERT_TRUE(success);
EXPECT_EQ(form_value.Reference(), func2);
}
{
DWARFFormValue form_value;
auto success = attrs.ExtractFormValueAtIndex(2, form_value);
ASSERT_TRUE(success);
EXPECT_EQ(form_value.Reference(), func1);
}
}
TEST_P(GetAttributesTestFixture,
TestGetAttributes_SkipNonApplicableAttributes) {
// Tests that GetAttributes will omit attributes found through
// specifications/abstract origins which are not applicable.
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_str:
- func
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_declaration
Form: DW_FORM_flag_present
- Attribute: DW_AT_name
Form: DW_FORM_strp
- Attribute: DW_AT_sibling
Form: DW_FORM_ref4
- Code: 0x3
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_declaration
Form: DW_FORM_flag_present
- Attribute: {0}
Form: DW_FORM_ref4
- Attribute: DW_AT_sibling
Form: DW_FORM_ref4
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
# DW_TAG_compile_unit
# DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
- AbbrCode: 0x1
Values:
- Value: 0x04
# DW_TAG_subprogram
# DW_AT_declaration
# DW_AT_name [DW_FORM_strp] ("func")
# DW_AT_sibling
- AbbrCode: 0x2
Values:
- Value: 0x1
- Value: 0x0
- Value: 0x18
# DW_TAG_subprogram
# DW_AT_declaration
# DW_AT_specification [DW_FORM_ref4] ("func")
# DW_AT_sibling
- AbbrCode: 0x3
Values:
- Value: 0x1
- Value: 0xf
- Value: 0xdeadbeef
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(llvm::formatv(yamldata, GetParam()).str());
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto declaration = cu_die.GetFirstChild();
ASSERT_TRUE(declaration.IsValid());
ASSERT_EQ(declaration.Tag(), DW_TAG_subprogram);
auto definition = declaration.GetSibling();
ASSERT_TRUE(definition.IsValid());
ASSERT_EQ(definition.Tag(), DW_TAG_subprogram);
auto attrs = definition.GetAttributes(DWARFDebugInfoEntry::Recurse::yes);
EXPECT_EQ(attrs.Size(), 4U);
EXPECT_NE(attrs.FindAttributeIndex(DW_AT_name), UINT32_MAX);
EXPECT_NE(attrs.FindAttributeIndex(GetParam()), UINT32_MAX);
auto sibling_idx = attrs.FindAttributeIndex(DW_AT_sibling);
EXPECT_NE(sibling_idx, UINT32_MAX);
DWARFFormValue form_value;
auto success = attrs.ExtractFormValueAtIndex(sibling_idx, form_value);
ASSERT_TRUE(success);
EXPECT_EQ(form_value.Unsigned(), 0xdeadbeef);
}
TEST_P(GetAttributesTestFixture, TestGetAttributes_NoRecurse) {
// Tests that GetAttributes will not recurse if Recurse::No is passed to it.
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_str:
- func
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_strp
- Code: 0x3
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_low_pc
Form: DW_FORM_data4
- Attribute: {0}
Form: DW_FORM_ref4
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
# DW_TAG_compile_unit
# DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
- AbbrCode: 0x1
Values:
- Value: 0x04
# DW_TAG_subprogram
# DW_AT_name [DW_FORM_strp] ("func")
- AbbrCode: 0x2
Values:
- Value: 0x0
# DW_TAG_subprogram
# DW_AT_low_pc [DW_FORM_data4]
# DW_AT_specification [DW_FORM_ref4]
- AbbrCode: 0x3
Values:
- Value: 0xdeadbeef
- Value: 0xf
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(llvm::formatv(yamldata, GetParam()).str());
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto declaration = cu_die.GetFirstChild();
ASSERT_TRUE(declaration.IsValid());
ASSERT_EQ(declaration.Tag(), DW_TAG_subprogram);
auto definition = declaration.GetSibling();
ASSERT_TRUE(definition.IsValid());
ASSERT_EQ(definition.Tag(), DW_TAG_subprogram);
auto attrs = definition.GetAttributes(DWARFDebugInfoEntry::Recurse::no);
EXPECT_EQ(attrs.Size(), 2U);
EXPECT_EQ(attrs.FindAttributeIndex(DW_AT_name), UINT32_MAX);
EXPECT_NE(attrs.FindAttributeIndex(GetParam()), UINT32_MAX);
EXPECT_NE(attrs.FindAttributeIndex(DW_AT_low_pc), UINT32_MAX);
}
TEST_P(GetAttributesTestFixture, TestGetAttributes_InvalidSpec) {
// Test that GetAttributes doesn't try following invalid
// specifications (but still add it to the list of attributes).
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_str:
- func
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_strp
- Code: 0x3
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: {0}
Form: DW_FORM_ref4
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
# DW_TAG_compile_unit
# DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
- AbbrCode: 0x1
Values:
- Value: 0x04
# DW_TAG_subprogram
# DW_AT_name [DW_FORM_strp] ("func")
- AbbrCode: 0x2
Values:
- Value: 0x0
# DW_TAG_subprogram
# DW_AT_specification [DW_FORM_ref4]
- AbbrCode: 0x3
Values:
- Value: 0xdeadbeef
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(llvm::formatv(yamldata, GetParam()).str());
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto declaration = cu_die.GetFirstChild();
ASSERT_TRUE(declaration.IsValid());
ASSERT_EQ(declaration.Tag(), DW_TAG_subprogram);
auto definition = declaration.GetSibling();
ASSERT_TRUE(definition.IsValid());
ASSERT_EQ(definition.Tag(), DW_TAG_subprogram);
auto attrs = definition.GetAttributes(DWARFDebugInfoEntry::Recurse::yes);
EXPECT_EQ(attrs.Size(), 1U);
EXPECT_EQ(attrs.FindAttributeIndex(DW_AT_name), UINT32_MAX);
EXPECT_NE(attrs.FindAttributeIndex(GetParam()), UINT32_MAX);
}
TEST(DWARFDIETest, TestGetAttributes_Worklist) {
// Test that GetAttributes will follow both the abstract origin
// and specification on a single DIE correctly (omitting non-applicable
// attributes in the process).
// Contrived example where
// f1---> f2 --> f4
// `-> f3 `-> f5
//
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_AARCH64
DWARF:
debug_str:
- foo
- bar
debug_abbrev:
- ID: 0
Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_specification
Form: DW_FORM_ref4
- Attribute: DW_AT_abstract_origin
Form: DW_FORM_ref4
- Code: 0x3
Tag: DW_TAG_subprogram
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_declaration
Form: DW_FORM_flag_present
- Attribute: DW_AT_artificial
Form: DW_FORM_flag_present
debug_info:
- Version: 5
UnitType: DW_UT_compile
AddrSize: 8
Entries:
- AbbrCode: 0x1
Values:
- Value: 0x04
# DW_TAG_subprogram ("f1")
# DW_AT_specification [DW_FORM_ref4] ("f2")
# DW_AT_abstract_origin [DW_FORM_ref4] ("f3")
- AbbrCode: 0x2
Values:
- Value: 0x18
- Value: 0x21
# DW_TAG_subprogram ("f2")
# DW_AT_specification [DW_FORM_ref4] ("f4")
# DW_AT_abstract_origin [DW_FORM_ref4] ("f5")
- AbbrCode: 0x2
Values:
- Value: 0x22
- Value: 0x23
# DW_TAG_subprogram ("f3")
# DW_AT_declaration [DW_FORM_flag_present]
# DW_AT_artificial [DW_FORM_flag_present]
- AbbrCode: 0x3
Values:
- Value: 0x1
- Value: 0x1
# DW_TAG_subprogram ("f4")
# DW_AT_declaration [DW_FORM_flag_present]
# DW_AT_artificial [DW_FORM_flag_present]
- AbbrCode: 0x3
Values:
- Value: 0x1
- Value: 0x1
# DW_TAG_subprogram ("f5")
# DW_AT_declaration [DW_FORM_flag_present]
# DW_AT_artificial [DW_FORM_flag_present]
- AbbrCode: 0x3
Values:
- Value: 0x1
- Value: 0x1
- AbbrCode: 0x0
...
)";
YAMLModuleTester t(yamldata);
DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
ASSERT_EQ(unit->GetDWARFLanguageType(), DW_LANG_C_plus_plus);
DWARFDIE cu_die(unit, cu_entry);
auto f1 = cu_die.GetFirstChild();
ASSERT_TRUE(f1.IsValid());
ASSERT_EQ(f1.Tag(), DW_TAG_subprogram);
auto attrs = f1.GetAttributes(DWARFDebugInfoEntry::Recurse::yes);
EXPECT_EQ(attrs.Size(), 7U);
EXPECT_EQ(attrs.FindAttributeIndex(DW_AT_declaration), UINT32_MAX);
}
INSTANTIATE_TEST_SUITE_P(GetAttributeTests, GetAttributesTestFixture,
testing::Values(DW_AT_specification,
DW_AT_abstract_origin));
// Exercises fallback in SymbolFileDWARF::ParseVariableDIE (added for
// Swift) that walks the type chain for DW_AT_byte_size when the
// TypeSystem cannot determine the size of a variable's storage. The
// test uses a Fortran DW_TAG_string_type, which TypeSystemClang
// doesn't know about. Type::GetByteSize() will fails but since
// DW_AT_string_type has a DW_AT_byte_size, so we should still be able
// to extract the constant value.
TEST(DWARFDIETest, ParseVariableDIE_ConstValueByteSizeFromTypeChain) {
const char *yamldata = R"(
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
DWARF:
debug_abbrev:
- Table:
- Code: 0x1
Tag: DW_TAG_compile_unit
Children: DW_CHILDREN_yes
Attributes:
- Attribute: DW_AT_language
Form: DW_FORM_data2
- Code: 0x2
Tag: DW_TAG_string_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_byte_size
Form: DW_FORM_data1
- Code: 0x3
Tag: DW_TAG_const_type
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_type
Form: DW_FORM_ref4
- Code: 0x4
Tag: DW_TAG_variable
Children: DW_CHILDREN_no
Attributes:
- Attribute: DW_AT_name
Form: DW_FORM_string
- Attribute: DW_AT_type
Form: DW_FORM_ref4
- Attribute: DW_AT_const_value
Form: DW_FORM_data8
debug_info:
- Version: 4
AddrSize: 8
Entries:
- AbbrCode: 0x1
Values:
- Value: 0xC # DW_LANG_C99
- AbbrCode: 0x2
Values:
- Value: 0x8 # DW_AT_byte_size
- AbbrCode: 0x3
Values:
- Value: 0xE # -> string_type
- AbbrCode: 0x4
Values:
- CStr: g
- Value: 0x10 # -> const_type
- Value: 0x1122334455667788 # DW_AT_const_value
- AbbrCode: 0x0
)";
YAMLModuleTester t(yamldata);
ModuleSP module_sp = t.GetModule();
ASSERT_TRUE(module_sp);
// FindGlobalVariables uses the ManualDWARFIndex which needs the
// Debugger's thread pool.
std::call_once(TestUtilities::g_debugger_initialize_flag,
[]() { Debugger::Initialize(nullptr); });
VariableList vars;
module_sp->GetSymbolFile()->FindGlobalVariables(
ConstString("g"), CompilerDeclContext(), /*max_matches=*/1, vars);
ASSERT_EQ(vars.GetSize(), 1u);
VariableSP var_sp = vars.GetVariableAtIndex(0);
ASSERT_TRUE(var_sp);
EXPECT_TRUE(var_sp->GetLocationIsConstantValueData());
// The fallback should have laid out the const-value bytes using
// DW_AT_byte_size from the DW_TAG_string_type at the end of the
// type chain.
const DWARFExpression *expr =
var_sp->LocationExpressionList().GetExpressionAtAddress(
LLDB_INVALID_ADDRESS, 0);
ASSERT_NE(expr, nullptr);
EXPECT_TRUE(expr->IsValid());
DataExtractor data;
ASSERT_TRUE(expr->GetExpressionData(data));
EXPECT_EQ(data.GetByteSize(), 8u);
lldb::offset_t off = 0;
EXPECT_EQ(data.GetU64(&off), 0x1122334455667788u);
}
Reference in new issue View Git Blame Copy Permalink