llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-lldb Author: Iasonas Karaprodromidis (Iasonaskrpr) <details> <summary>Changes</summary> This patch adds support for case-insensitive lookups. Whether the lookups should be case-sensitive or case-insensitive is determined by DW_AT_identifier_case. If this attribute is not present, then the compile unit is considered case-sensitive. Changes: - Added an identifier case field to the compile unit. - DIL now looks at casing when looking up identifiers and handles them appropriately. - DWARFUnit now parses DW_AT_identifier_case when asked. - NameToDIE now looks at casing and searches for identifiers appropriately. Part of the "Add Fortran support to LLDB" GSoC 2026 project. --- Patch is 24.93 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/213323.diff 14 Files Affected: - (modified) lldb/include/lldb/Symbol/CompileUnit.h (+10) - (modified) lldb/include/lldb/lldb-enumerations.h (+15) - (modified) lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp (+32) - (modified) lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h (+3) - (modified) lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp (+9) - (modified) lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h (+22) - (modified) lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp (+10) - (modified) lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h (+9) - (modified) lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp (+6-3) - (modified) lldb/source/ValueObject/DILEval.cpp (+35-7) - (added) lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/Makefile (+3) - (added) lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/TestFrameVarDILCaseSensitiveLookup.py (+59) - (added) lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/main.cpp (+6) - (modified) lldb/unittests/SymbolFile/DWARF/DWARFDebugNamesIndexTest.cpp (+198-3) ``````````diff diff --git a/lldb/include/lldb/Symbol/CompileUnit.h b/lldb/include/lldb/Symbol/CompileUnit.h index bb9594699df33..7d99bd16ae02d 100644 --- a/lldb/include/lldb/Symbol/CompileUnit.h +++ b/lldb/include/lldb/Symbol/CompileUnit.h @@ -152,6 +152,14 @@ class CompileUnit : public std::enable_shared_from_this<CompileUnit>, m_language = language; } + lldb::IdentifierCaseType GetCasing() { + return m_identifier_case; + } + + void SetCasing(lldb::IdentifierCaseType identifier_case){ + m_identifier_case = identifier_case; + } + void GetDescription(Stream *s, lldb::DescriptionLevel level) const; /// Apply a lambda to each function in this compile unit. @@ -422,6 +430,8 @@ class CompileUnit : public std::enable_shared_from_this<CompileUnit>, void *m_user_data; /// The programming language enumeration value. lldb::LanguageType m_language; + /// Used to determine if lookups should be case-insensitive + lldb::IdentifierCaseType m_identifier_case = lldb::eCaseSensitive; /// Compile unit flags that help with partial parsing. Flags m_flags; /// Maps UIDs to functions. diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index 32a341b354d9f..4c0d2c27a8745 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -631,6 +631,21 @@ enum LanguageType { eNumLanguageTypes }; +//---------------------------------------------------------------------- +/// Identifier Case type +/// +/// this enumeration indetifies the treatment of identifiers within +/// compilation unit. the default is case sensitive in case it is absent +/// in compilation unit. +//---------------------------------------------------------------------- +enum IdentifierCaseType { + eCaseSensitive = 0, + eUpperCase = 1, + eLowerCase = 2, + eCaseInsensitive = 3, + eCaseUnknown = 4, +}; + enum InstrumentationRuntimeType { eInstrumentationRuntimeTypeAddressSanitizer = 0x0000, eInstrumentationRuntimeTypeThreadSanitizer = 0x0001, diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp index 4b02124e987e8..7fbef4a831ff1 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp @@ -888,6 +888,38 @@ llvm::VersionTuple DWARFUnit::GetProducerVersion() { return m_producer_version; } +lldb::IdentifierCaseType DWARFUnit::GetIdentifierCase() { + if(m_identifier_case != eCaseUnknown) + return m_identifier_case; + + const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); + + if(!die) + m_identifier_case = eCaseSensitive; + + else { + uint64_t identifier_case = die->GetAttributeValueAsUnsigned(this, DW_AT_identifier_case, llvm::dwarf::DW_ID_case_sensitive); + + switch (identifier_case) { + case llvm::dwarf::DW_ID_up_case: + m_identifier_case = eUpperCase; + break; + case llvm::dwarf::DW_ID_down_case: + m_identifier_case = eLowerCase; + break; + case llvm::dwarf::DW_ID_case_insensitive: + m_identifier_case = eCaseInsensitive; + break; + case llvm::dwarf::DW_ID_case_sensitive: + default: + m_identifier_case = eCaseSensitive; + break; + } + } + + return m_identifier_case; +} + uint64_t DWARFUnit::GetDWARFLanguageType() { if (m_language_type) return *m_language_type; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h index 6fde9af57fa8b..51bafa75ca1cf 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h @@ -204,6 +204,8 @@ class DWARFUnit : public DWARFExpression::Delegate, public UserID { llvm::VersionTuple GetProducerVersion(); + lldb::IdentifierCaseType GetIdentifierCase(); + uint64_t GetDWARFLanguageType(); bool GetIsOptimized(); @@ -352,6 +354,7 @@ class DWARFUnit : public DWARFExpression::Delegate, public UserID { DWARFProducer m_producer = eProducerInvalid; llvm::VersionTuple m_producer_version; std::optional<uint64_t> m_language_type; + lldb::IdentifierCaseType m_identifier_case = lldb::eCaseUnknown; LazyBool m_is_optimized = eLazyBoolCalculate; std::optional<FileSpec> m_comp_dir; std::optional<FileSpec> m_file_spec; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp b/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp index 0971e66df86ae..43f53ea34163b 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp @@ -158,6 +158,15 @@ void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp, const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit); + lldb::IdentifierCaseType cu_identifier_case = unit.GetIdentifierCase(); + + // If at least one of the Compile Units is case sensitive, then all compile + // units will be case sensitive + if(cu_identifier_case != eCaseSensitive) + SetNameCaseInsensitive(); + else + SetStrictlyCaseSensitive(); + // First check if the unit has a DWO ID. If it does then we only want to index // the .dwo file or nothing at all. If we have a compile unit where we can't // locate the .dwo/.dwp file we don't want to index anything from the skeleton diff --git a/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h b/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h index 41e0e620a4896..5e137c0f930d8 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h @@ -169,6 +169,28 @@ class ManualDWARFIndex : public DWARFIndex { /// True if this index is a partial index, false otherwise. bool IsPartial() const; + void SetNameCaseInsensitive() { + m_set.function_basenames.SetNameCaseInsensitive(); + m_set.function_fullnames.SetNameCaseInsensitive(); + m_set.function_methods.SetNameCaseInsensitive(); + m_set.function_selectors.SetNameCaseInsensitive(); + m_set.objc_class_selectors.SetNameCaseInsensitive(); + m_set.globals.SetNameCaseInsensitive(); + m_set.types.SetNameCaseInsensitive(); + m_set.namespaces.SetNameCaseInsensitive(); + } + + void SetStrictlyCaseSensitive() { + m_set.function_basenames.SetStrictlyCaseSensitive(); + m_set.function_fullnames.SetStrictlyCaseSensitive(); + m_set.function_methods.SetStrictlyCaseSensitive(); + m_set.function_selectors.SetStrictlyCaseSensitive(); + m_set.objc_class_selectors.SetStrictlyCaseSensitive(); + m_set.globals.SetStrictlyCaseSensitive(); + m_set.types.SetStrictlyCaseSensitive(); + m_set.namespaces.SetStrictlyCaseSensitive(); + } + /// The DWARF file which we are indexing. SymbolFileDWARF *m_dwarf; /// Which dwarf units should we skip while building the index. diff --git a/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp b/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp index b34fda5740924..c370eaa2a6471 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp @@ -38,6 +38,16 @@ bool NameToDIE::Find( for (const auto &entry : m_map.equal_range(name)) if (callback(entry.value) == IterationAction::Stop) return false; + + if (!NameCaseInsensitive) + return true; + + for (const auto &entry : m_map){ + if(ConstString::Equals(ConstString(entry.cstring.GetCString()), name, false)) + if (callback(entry.value) == IterationAction::Stop) + return false; + } + return true; } diff --git a/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h b/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h index 9f9b631f178ee..a85c6a2cda846 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h @@ -86,8 +86,17 @@ class NameToDIE { void Clear() { m_map.Clear(); } + void SetNameCaseInsensitive() { if(!StrictlyCaseSensitive) NameCaseInsensitive = true; } + + void SetStrictlyCaseSensitive() { + NameCaseInsensitive = false; + StrictlyCaseSensitive = true; + } + protected: UniqueCStringMap<DIERef> m_map; + bool NameCaseInsensitive = false; + bool StrictlyCaseSensitive = false; }; } // namespace dwarf } // namespace lldb_private::plugin diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index 56fbf3fd771b5..881a009553df2 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -792,6 +792,7 @@ lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) { if (module_sp) { auto initialize_cu = [&](SupportFileNSP support_file_nsp, LanguageType cu_language, + IdentifierCaseType cu_casing, SupportFileList &&support_files = {}) { BuildCuTranslationTable(); cu_sp = std::make_shared<CompileUnit>( @@ -799,8 +800,10 @@ lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) { *GetDWARFUnitIndex(dwarf_cu.GetID()), cu_language, eLazyBoolCalculate, std::move(support_files)); - dwarf_cu.SetLLDBCompUnit(cu_sp.get()); + cu_sp->SetCasing(cu_casing); + dwarf_cu.SetLLDBCompUnit(cu_sp.get()); + SetCompileUnitAtIndex(dwarf_cu.GetID(), cu_sp); }; @@ -829,7 +832,7 @@ lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) { if (support_files.GetSize() == 0) return false; initialize_cu(support_files.GetSupportFileAtIndex(0), - eLanguageTypeUnknown, std::move(support_files)); + eLanguageTypeUnknown, dwarf_cu.GetIdentifierCase(), std::move(support_files)); return true; }; @@ -848,7 +851,7 @@ lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) { MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp); initialize_cu(std::make_shared<SupportFile>(cu_file_spec), - cu_language); + cu_language, dwarf_cu.GetIdentifierCase()); } } } diff --git a/lldb/source/ValueObject/DILEval.cpp b/lldb/source/ValueObject/DILEval.cpp index 5fc2376be0e75..b358948bee093 100644 --- a/lldb/source/ValueObject/DILEval.cpp +++ b/lldb/source/ValueObject/DILEval.cpp @@ -289,14 +289,28 @@ lldb::ValueObjectSP LookupGlobalIdentifier(llvm::StringRef name_ref, SymbolContext symbol_context = stack_frame.GetSymbolContext(lldb::eSymbolContextCompUnit); lldb::VariableListSP variable_list; - if (symbol_context.comp_unit) + lldb::IdentifierCaseType identifier_case = lldb::eCaseSensitive; + + if (symbol_context.comp_unit){ variable_list = symbol_context.comp_unit->GetVariableList(true); + identifier_case = symbol_context.comp_unit->GetCasing(); + } + name_ref.consume_front("::"); + + std::string search_string; + if(identifier_case == lldb::eLowerCase) + search_string = name_ref.lower(); + else if(identifier_case == lldb::eUpperCase) + search_string = name_ref.upper(); + else + search_string = name_ref.str(); + lldb::ValueObjectSP value_sp; if (variable_list) { lldb::VariableSP var_sp = - DILFindVariable(ConstString(name_ref), *variable_list); + DILFindVariable(ConstString(search_string), *variable_list); if (var_sp) value_sp = stack_frame.GetValueObjectForFrameVariable(var_sp, use_dynamic); @@ -308,12 +322,12 @@ lldb::ValueObjectSP LookupGlobalIdentifier(llvm::StringRef name_ref, // Check for match in modules global variables. VariableList modules_var_list; target_sp->GetImages().FindGlobalVariables( - ConstString(name_ref), std::numeric_limits<uint32_t>::max(), + ConstString(search_string), std::numeric_limits<uint32_t>::max(), modules_var_list); if (!modules_var_list.Empty()) { lldb::VariableSP var_sp = - DILFindVariable(ConstString(name_ref), modules_var_list); + DILFindVariable(ConstString(search_string), modules_var_list); if (var_sp) value_sp = ValueObjectVariable::Create(&stack_frame, var_sp); @@ -345,10 +359,24 @@ lldb::ValueObjectSP LookupIdentifier(llvm::StringRef name_ref, lldb::VariableListSP variable_list( stack_frame.GetInScopeVariableList(false)); + SymbolContext sc = stack_frame.GetSymbolContext(lldb::eSymbolContextCompUnit); + + lldb::IdentifierCaseType identifier_case = lldb::eCaseSensitive; + if(sc.comp_unit) + identifier_case = sc.comp_unit->GetCasing(); + + std::string search_string; + if(identifier_case == lldb::eLowerCase) + search_string = name_ref.lower(); + else if(identifier_case == lldb::eUpperCase) + search_string = name_ref.upper(); + else + search_string = name_ref.str(); + lldb::ValueObjectSP value_sp; if (variable_list) { lldb::VariableSP var_sp = - variable_list->FindVariable(ConstString(name_ref)); + variable_list->FindVariable(ConstString(search_string)); if (var_sp) value_sp = stack_frame.GetValueObjectForFrameVariable(var_sp, use_dynamic); @@ -358,12 +386,12 @@ lldb::ValueObjectSP LookupIdentifier(llvm::StringRef name_ref, return value_sp; // Try looking for an instance variable (class member). - SymbolContext sc = stack_frame.GetSymbolContext( + sc = stack_frame.GetSymbolContext( lldb::eSymbolContextFunction | lldb::eSymbolContextBlock); llvm::StringRef instance_name = sc.GetInstanceName(); value_sp = stack_frame.FindVariable(ConstString(instance_name)); if (value_sp) - value_sp = value_sp->GetChildMemberWithName(name_ref); + value_sp = value_sp->GetChildMemberWithName(search_string); if (value_sp) return value_sp; diff --git a/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/Makefile b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/Makefile new file mode 100644 index 0000000000000..2bb9ce046a907 --- /dev/null +++ b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules \ No newline at end of file diff --git a/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/TestFrameVarDILCaseSensitiveLookup.py b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/TestFrameVarDILCaseSensitiveLookup.py new file mode 100644 index 0000000000000..876107f1e4017 --- /dev/null +++ b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/TestFrameVarDILCaseSensitiveLookup.py @@ -0,0 +1,59 @@ +""" +Test that DIL matches variables correctly for case-sensitive languages. +""" + +import lldb +from lldbsuite.test.lldbtest import * +from lldbsuite.test.decorators import * +from lldbsuite.test import lldbutil + + +class TestFrameVarDILCaseSensitiveLookup(TestBase): + # If your test case doesn't stress debug info, then + # set this to true. That way it won't be run once for + # each debug info format. + NO_DEBUG_INFO_TESTCASE = True + + def test_frame_var(self): + self.build() + lldbutil.run_to_source_breakpoint( + self, "Set a breakpoint here", lldb.SBFileSpec("main.cpp") + ) + + self.runCmd("settings set target.experimental.use-DIL true") + + self.expect_var_path("globalVar", type="int", value="-559038737") # 0xDEADBEEF + + self.expect( + "frame var GlobaLVaR", + error=True, + substrs=["use of undeclared identifier 'GlobaLVaR'"], + ) + self.expect( + "frame var GLOBALVAR", + error=True, + substrs=["use of undeclared identifier 'GLOBALVAR'"], + ) + self.expect( + "frame var globalvar", + error=True, + substrs=["use of undeclared identifier 'globalvar'"], + ) + + self.expect_var_path("testVariable", type="int", value="3") + + self.expect( + "frame var TestVaRiable", + error=True, + substrs=["use of undeclared identifier 'TestVaRiable'"], + ) + self.expect( + "frame var testvariable", + error=True, + substrs=["use of undeclared identifier 'testvariable'"], + ) + self.expect( + "frame var TESTVARIABLE", + error=True, + substrs=["use of undeclared identifier 'TESTVARIABLE'"], + ) diff --git a/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/main.cpp b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/main.cpp new file mode 100644 index 0000000000000..c604dc67e73bc --- /dev/null +++ b/lldb/test/API/commands/frame/var-dil/basics/CaseSensitiveLookup/main.cpp @@ -0,0 +1,6 @@ +int globalVar = 0xDEADBEEF; +int main(int argc, char **argv) { + int testVariable; + testVariable = 3; + return 0; // Set a breakpoint here +} \ No newline at end of file diff --git a/lldb/unittests/SymbolFile/DWARF/DWARFDebugNamesIndexTest.cpp b/lldb/unittests/SymbolFile/DWARF/DWARFDebugNamesIndexTest.cpp index dd8a0742f6b70..854e6e1f49898 100644 --- a/lldb/unittests/SymbolFile/DWARF/DWARFDebugNamesIndexTest.cpp +++ b/lldb/unittests/SymbolFile/DWARF/DWARFDebugNamesIndexTest.cpp @@ -1,4 +1,5 @@ -//===-- DWARFDIETest.cpp ----------------------------------------------=---===// +//===-- DWARFDebugNamesIndexTest.cpp +//----------------------------------------------=---===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -10,7 +11,9 @@ #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h" #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h" #include "Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h" +#include "TestingSupport/SubsystemRAII.h" #include "TestingSupport/Symbol/YAMLModuleTester.h" +#include "lldb/Core/Debugger.h" #include "lldb/lldb-private-enumerations.h" #include "llvm/ADT/STLExtras.h" #include "gmock/gmock.h" @@ -21,6 +24,15 @@ using namespace lldb_private; using namespace lldb_private::plugin::dwarf; using StringRef = llvm::StringRef; +class DWARFDebugNamesIndexTest : public testing::Test { +public: + void SetUp() override { + Debugger::Initialize(nullptr); + } + + void TearDown() override { Debugger::Terminate(); } +}; + static void check_num_matches(DebugNamesDWARFIndex &index, int expected_num_matches, llvm::ArrayRef<DWARFDeclContext::Entry> ctx_entries) { @@ -38,7 +50,7 @@ static DWARFDeclContext::Entry make_entry(const char *c) { return DWARFDeclContext::Entry(llvm::dwarf::DW_TAG_class_type, c); } -TEST(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithIDXParent) { +TEST_F(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithIDXParent) { const char *yamldata = R"( --- !ELF FileHeader: @@ -130,7 +142,7 @@ TEST(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithIDXParent) { check_num_matches(*index, 1, {make_entry("3")}); } -TEST(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithoutIDXParent) { +TEST_F(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithoutIDXParent) { const char *yamldata = R"( --- !ELF FileHeader: @@ -207,3 +219,186 @@ TEST(DWARFDebugNamesIndexTest, FullyQualifiedQueryWithoutIDXParent) { check_num_matches(*index, 1, {make_entry("2"), make_entry("1")}); check_num_matches(*index, 1, {make_entry("2")}); } + +TEST_F(DWARFDebugNamesIndexTest, CaseInsesitiveQuery) { + const char *yamldata = R"( +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_EXEC + Machine: EM_X86_64 +DWARF: + debug_str: + - 'num_int' + debug_abbrev: + - Table: + - Code: 0x1 + Tag: DW_TAG_compile_unit + Children: DW_CHILDREN_yes + Attributes: + - Attribute: DW_AT_language + Form: DW_FORM_data2 + - Attribute: DW_AT_identifier_case + Form: DW_FORM_data1 + - Code: 0x2 + Tag: DW_TAG_variable + Children: D... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/213323 _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
