[llvm-branch-commits] [lldb] [lldb][Fortran] Added support for functions to DWARFASTParserFortran (PR #234312)
Iasonas Karaprodromidis via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Nov 3 16:58:14 PST 2026
https://github.com/Iasonaskrpr updated https://github.com/llvm/llvm-project/pull/234312
>From 39592b8f829ecf6db39b68799d97a07a51839ed0 Mon Sep 17 00:00:00 2001
From: Iasonaskrpr <iaskarapro at gmail.com>
Date: Tue, 20 Oct 2026 20:39:31 +0300
Subject: [PATCH 1/4] [lldb][Fortran] Added support for functions to
DWARFASTParserFortran plus tests
---
.../DWARF/DWARFASTParserFortran.cpp | 136 ++++++++-
.../SymbolFile/DWARF/DWARFASTParserFortran.h | 5 +
.../DWARF/DWARFASTParserFortranTests.cpp | 266 ++++++++++++++++++
3 files changed, 404 insertions(+), 3 deletions(-)
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
index d9caa194291183..07b58d4a86939c 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
@@ -63,6 +63,37 @@ TypeSP DWARFASTParserFortran::UpdateSymbolContextScopeForType(
return type_sp;
}
+void DWARFASTParserFortran::ParseChildParameters(
+ const DWARFDIE &parent_die,
+ llvm::SmallVectorImpl<CompilerType> &function_param_types,
+ llvm::SmallVectorImpl<llvm::StringRef> &function_param_names) {
+ if (!parent_die)
+ return;
+
+ for (DWARFDIE die : parent_die.children()) {
+ const dw_tag_t tag = die.Tag();
+ switch (tag) {
+ case DW_TAG_formal_parameter: {
+ if (die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
+ continue;
+
+ DWARFDIE param_type_die = die.GetAttributeValueAsReferenceDIE(DW_AT_type);
+
+ Type *type = die.ResolveTypeUID(param_type_die);
+ if (!type)
+ break;
+
+ function_param_names.emplace_back(die.GetName());
+ function_param_types.push_back(type->GetForwardCompilerType());
+ } break;
+ default:
+ break;
+ }
+ }
+
+ assert(function_param_names.size() == function_param_types.size());
+}
+
lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
const lldb_private::SymbolContext &sc,
const lldb_private::plugin::dwarf::DWARFDIE &die, bool *type_is_new_ptr) {
@@ -146,13 +177,61 @@ lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
compiler_type, Type::ResolveState::Full);
break;
}
+ case DW_TAG_subprogram:
+ case DW_TAG_subroutine_type: {
+ CompilerType return_type;
+ dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+ attributes = die.GetAttributes();
+ size_t num_attr = attributes.Size();
+
+ for (size_t i = 0; i < num_attr; ++i) {
+ if (attributes.ExtractFormValueAtIndex(i, form_value)) {
+ switch (attributes.AttributeAtIndex(i)) {
+ case DW_AT_name:
+ type_name_cstr = form_value.AsCString();
+ if (type_name_cstr &&
+ type_name_cstr[0]) { // Check for null AND empty string
+ type_name.SetString(llvm::StringRef(type_name_cstr));
+ } else {
+ type_name.SetCString("UNKNOWN_FORTRAN_FUNCTION");
+ }
+ break;
+
+ case DW_AT_type: {
+ DWARFDIE type_die = form_value.Reference();
+ if (!type_die)
+ break;
+
+ if (Type *resolved_type = die.GetDWARF()->ResolveType(type_die))
+ return_type = resolved_type->GetForwardCompilerType();
+
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+ }
+
+ llvm::SmallVector<CompilerType, 4> function_params_types;
+ llvm::SmallVector<llvm::StringRef, 4> function_params_names;
+ ParseChildParameters(die, function_params_types, function_params_names);
+
+ compiler_type = m_ast.CreateFortranFunction(
+ type_name, function_params_types, function_params_names, return_type);
+
+ type_sp = dwarf->MakeType(die.GetID(), type_name, 0, nullptr,
+ LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
+ compiler_type, Type::ResolveState::Full);
+ break;
+ }
default:
- if (log) {
+ if (log)
dwarf->GetObjectFile()->GetModule()->LogMessage(
log, "[{0:x16}]: unhandled type tag {1:x4} ({2})", die.GetOffset(),
tag, DW_TAG_value_to_name(tag));
- }
break;
}
@@ -168,7 +247,58 @@ lldb_private::Function *DWARFASTParserFortran::ParseFunctionFromDWARF(
lldb_private::CompileUnit &comp_unit,
const lldb_private::plugin::dwarf::DWARFDIE &die,
lldb_private::AddressRanges ranges) {
- return nullptr;
+ if (die.Tag() != DW_TAG_subprogram && die.Tag() != DW_TAG_subroutine_type)
+ return nullptr;
+
+ llvm::DWARFAddressRangesVector unused_func_ranges;
+ const char *name = nullptr;
+ const char *mangled = nullptr;
+ std::optional<int> decl_file = 0;
+ std::optional<int> decl_line = 0;
+ std::optional<int> decl_column = 0;
+ std::optional<int> call_file = 0;
+ std::optional<int> call_line = 0;
+ std::optional<int> call_column = 0;
+ DWARFExpressionList frame_base;
+ if (!die.GetDIENamesAndRanges(name, mangled, unused_func_ranges, decl_file,
+ decl_line, decl_column, call_file, call_line,
+ call_column, &frame_base))
+ return nullptr;
+
+ Mangled func_name;
+ // Mangled doesn't know how to demangle fortran names
+ if (mangled)
+ func_name.SetMangledName(ConstString(mangled));
+
+ if (name)
+ func_name.SetDemangledName(ConstString(name));
+
+ FunctionSP func_sp;
+
+ SymbolFileDWARF *dwarf = die.GetDWARF();
+
+ // Supply the type only if it has already been parsed
+ Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
+
+ assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
+
+ const user_id_t func_user_id = die.GetID();
+
+ Address func_addr = ranges[0].GetBaseAddress();
+
+ func_sp = std::make_shared<Function>(&comp_unit,
+ func_user_id, // UserID is the DIE offset
+ func_user_id, func_name, func_type,
+ std::move(func_addr), std::move(ranges));
+
+ if (func_sp.get() == nullptr)
+ return nullptr;
+
+ if (frame_base.IsValid())
+ func_sp->GetFrameBaseExpression() = frame_base;
+
+ comp_unit.AddFunction(func_sp);
+ return func_sp.get();
}
bool DWARFASTParserFortran::CompleteTypeFromDWARF(
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
index 2afa12ae232edd..96988be8591d53 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
@@ -43,6 +43,11 @@ class DWARFASTParserFortran
const lldb_private::SymbolContext &sc,
const lldb_private::plugin::dwarf::DWARFDIE &die, lldb::TypeSP type_sp);
+ void ParseChildParameters(
+ const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
+ llvm::SmallVectorImpl<lldb_private::CompilerType> &function_param_types,
+ llvm::SmallVectorImpl<llvm::StringRef> &function_param_names);
+
lldb::TypeSP
ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
const lldb_private::plugin::dwarf::DWARFDIE &die,
diff --git a/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp b/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
index a8d37709d14770..e7333c77eb6ace 100644
--- a/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
+++ b/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
@@ -209,3 +209,269 @@ TEST_F(DWARFASTParserFortranTests, EnsureBaseTypeParsingWorks) {
// Ensure all expected DIEs were iterated
EXPECT_EQ(type_idx, expected_types.size());
}
+
+TEST_F(DWARFASTParserFortranTests, EnsureFunctionParsingWorks) {
+ const char *yamldata = R"(
+--- !ELF
+FileHeader:
+ Class: ELFCLASS64
+ Data: ELFDATA2LSB
+ Type: ET_EXEC
+ Machine: EM_X86_64
+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_yes
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_type
+ Form: DW_FORM_ref4
+ - Code: 0x3
+ Tag: DW_TAG_formal_parameter
+ Children: DW_CHILDREN_no
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_type
+ Form: DW_FORM_ref4
+ - Code: 0x4
+ Tag: DW_TAG_base_type
+ Children: DW_CHILDREN_no
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_encoding
+ Form: DW_FORM_data1
+ - Attribute: DW_AT_byte_size
+ Form: DW_FORM_data1
+ debug_info:
+ - Version: 4
+ Entries:
+ - AbbrCode: 0x1 # DW_TAG_compile_unit
+ Values:
+ - Value: 0x22 # DW_LANG_Fortran95
+
+ - AbbrCode: 0x4 # DW_TAG_base_type
+ Values:
+ - CStr: 'integer'
+ - Value: 0x5 # DW_ATE_signed
+ - Value: 0x4 # 4 bytes
+
+ - AbbrCode: 0x2 # DW_TAG_subprogram
+ Values:
+ - CStr: 'multiply_and_add'
+ - Value: 0x0E # Return type points to 0x0E (integer)
+
+ # Child 1: Parameter 'a'
+ - AbbrCode: 0x3 # DW_TAG_formal_parameter
+ Values:
+ - CStr: 'a'
+ - Value: 0x0E # Type points to 0x0E (integer)
+
+ # Child 2: Parameter 'b'
+ - AbbrCode: 0x3 # DW_TAG_formal_parameter
+ Values:
+ - CStr: 'b'
+ - Value: 0x0E # Type points to 0x0E (integer)
+
+ - AbbrCode: 0x0 # End of subprogram children
+ - AbbrCode: 0x0 # End of compile_unit children
+)";
+
+ DWARFASTParserFortranYAMLTester tester(yamldata);
+ DWARFDIE cu_die = tester.GetCUDIE();
+ DWARFDIE subprogram_die;
+ SymbolContext sc;
+ bool is_new_type;
+ std::string expected_name = "INTEGER multiply_and_add(INTEGER a, INTEGER b)";
+ for (DWARFDIE child_die : cu_die.children()) {
+ if (child_die.Tag() == DW_TAG_subprogram) {
+ subprogram_die = child_die;
+ break;
+ }
+ }
+ EXPECT_TRUE(subprogram_die.IsValid());
+ lldb::TypeSP func_type_sp =
+ tester.GetParser().ParseTypeFromDWARF(sc, subprogram_die, &is_new_type);
+ EXPECT_TRUE(is_new_type);
+ EXPECT_TRUE(func_type_sp->IsValidType());
+ CompilerType function_type = func_type_sp->GetForwardCompilerType();
+ EXPECT_TRUE(function_type.IsFunctionType());
+ EXPECT_EQ(function_type.GetTypeName().GetString(), expected_name);
+ EXPECT_EQ(function_type.GetFunctionArgumentCount(), 2);
+ CompilerType arg_1 = function_type.GetFunctionArgumentAtIndex(0);
+ EXPECT_TRUE(arg_1.IsValid());
+ CompilerType arg_2 = function_type.GetFunctionArgumentAtIndex(1);
+ EXPECT_TRUE(arg_2.IsValid());
+ CompilerType return_type = function_type.GetFunctionReturnType();
+ EXPECT_TRUE(return_type.IsValid());
+ EXPECT_EQ(arg_1.GetBasicTypeEnumeration(), eBasicTypeInt);
+ EXPECT_EQ(arg_2.GetBasicTypeEnumeration(), eBasicTypeInt);
+ EXPECT_EQ(return_type.GetBasicTypeEnumeration(), eBasicTypeInt);
+}
+
+TEST_F(DWARFASTParserFortranTests,
+ EnsureFunctionParsingWithNoParametersOrArgumentsWorks) {
+ const char *yamldata = R"(
+--- !ELF
+FileHeader:
+ Class: ELFCLASS64
+ Data: ELFDATA2LSB
+ Type: ET_EXEC
+ Machine: EM_X86_64
+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_base_type
+ Children: DW_CHILDREN_no
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_encoding
+ Form: DW_FORM_data1
+ - Attribute: DW_AT_byte_size
+ Form: DW_FORM_data1
+ - Code: 0x3
+ Tag: DW_TAG_subprogram
+ Children: DW_CHILDREN_yes
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_type
+ Form: DW_FORM_ref4
+ - Code: 0x4
+ Tag: DW_TAG_subprogram
+ Children: DW_CHILDREN_yes
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Code: 0x5
+ Tag: DW_TAG_formal_parameter
+ Children: DW_CHILDREN_no
+ Attributes:
+ - Attribute: DW_AT_name
+ Form: DW_FORM_string
+ - Attribute: DW_AT_type
+ Form: DW_FORM_ref4
+ debug_info:
+ - Version: 4
+ Entries:
+ - AbbrCode: 0x1 # DW_TAG_compile_unit
+ Values:
+ - Value: 0x22 # DW_LANG_Fortran95
+
+ - AbbrCode: 0x2 # DW_TAG_base_type
+ Values:
+ - CStr: 'integer'
+ - Value: 0x5 # DW_ATE_signed
+ - Value: 0x4 # 4 bytes
+
+ - AbbrCode: 0x4 # DW_TAG_subprogram (No DW_AT_type)
+ Values:
+ - CStr: 'my_subroutine'
+ - AbbrCode: 0x5 # DW_TAG_formal_parameter
+ Values:
+ - CStr: 'a'
+ - Value: 0x0E
+ - AbbrCode: 0x5 # DW_TAG_formal_parameter
+ Values:
+ - CStr: 'b'
+ - Value: 0x0E
+ - AbbrCode: 0x0 # End of my_subroutine
+
+ - AbbrCode: 0x3 # DW_TAG_subprogram (Has DW_AT_type)
+ Values:
+ - CStr: 'no_args_func'
+ - Value: 0x0E
+ - AbbrCode: 0x0 # End of no_args_func (0 parameters)
+
+ - AbbrCode: 0x4 # DW_TAG_subprogram (No DW_AT_type)
+ Values:
+ - CStr: 'empty_sub'
+ - AbbrCode: 0x0 # End of empty_sub
+
+ - AbbrCode: 0x0 # End of compile_unit
+)";
+
+ DWARFASTParserFortranYAMLTester tester(yamldata);
+ DWARFDIE cu_die = tester.GetCUDIE();
+ SymbolContext sc;
+
+ int subprograms_found = 0;
+
+ for (DWARFDIE child_die : cu_die.children()) {
+ if (child_die.Tag() != DW_TAG_subprogram)
+ continue;
+ subprograms_found++;
+
+ bool is_new_type;
+ lldb::TypeSP func_type_sp =
+ tester.GetParser().ParseTypeFromDWARF(sc, child_die, &is_new_type);
+
+ EXPECT_TRUE(is_new_type);
+ EXPECT_TRUE(func_type_sp->IsValidType());
+
+ CompilerType function_type = func_type_sp->GetForwardCompilerType();
+ EXPECT_TRUE(function_type.IsFunctionType());
+
+ llvm::StringRef name = child_die.GetName();
+
+ if (name == "my_subroutine") {
+ // Subroutine: No return type, 2 arguments
+ EXPECT_EQ(function_type.GetTypeName().GetString(),
+ "my_subroutine(INTEGER a, INTEGER b)");
+ EXPECT_EQ(function_type.GetFunctionArgumentCount(), 2);
+
+ CompilerType arg_1 = function_type.GetFunctionArgumentAtIndex(0);
+ CompilerType arg_2 = function_type.GetFunctionArgumentAtIndex(1);
+ EXPECT_TRUE(arg_1.IsValid());
+ EXPECT_TRUE(arg_2.IsValid());
+ EXPECT_EQ(arg_1.GetBasicTypeEnumeration(), eBasicTypeInt);
+ EXPECT_EQ(arg_2.GetBasicTypeEnumeration(), eBasicTypeInt);
+
+ CompilerType return_type = function_type.GetFunctionReturnType();
+ EXPECT_FALSE(
+ return_type
+ .IsValid()); // Subroutines shouldn't have a valid return type
+
+ } else if (name == "no_args_func") {
+ // Function: Has return type, 0 arguments
+ EXPECT_EQ(function_type.GetTypeName().GetString(),
+ "INTEGER no_args_func()");
+ EXPECT_EQ(function_type.GetFunctionArgumentCount(), 0);
+
+ CompilerType return_type = function_type.GetFunctionReturnType();
+ EXPECT_TRUE(return_type.IsValid());
+ EXPECT_EQ(return_type.GetBasicTypeEnumeration(), eBasicTypeInt);
+
+ } else if (name == "empty_sub") {
+ // Subroutine: No return type, 0 arguments
+ EXPECT_EQ(function_type.GetTypeName().GetString(), "empty_sub()");
+ EXPECT_EQ(function_type.GetFunctionArgumentCount(), 0);
+
+ CompilerType return_type = function_type.GetFunctionReturnType();
+ EXPECT_FALSE(return_type.IsValid());
+ }
+ }
+
+ // Make sure we actually found and tested all 3!
+ EXPECT_EQ(subprograms_found, 3);
+}
>From e61ff553f4e969b5b21dcecac326e2dc11134759 Mon Sep 17 00:00:00 2001
From: Iasonaskrpr <iaskarapro at gmail.com>
Date: Fri, 23 Oct 2026 20:05:53 +0300
Subject: [PATCH 2/4] [lldb][Fortran] Addressed feedback about code styling and
changed one of the tests to contain different types in arguments and return
type, not just integers
---
.../DWARF/DWARFASTParserFortran.cpp | 44 ++++++++-----------
.../DWARF/DWARFASTParserFortranTests.cpp | 24 +++++++---
2 files changed, 36 insertions(+), 32 deletions(-)
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
index 07b58d4a86939c..cf8a6f0904568c 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
@@ -185,32 +185,29 @@ lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
size_t num_attr = attributes.Size();
for (size_t i = 0; i < num_attr; ++i) {
- if (attributes.ExtractFormValueAtIndex(i, form_value)) {
- switch (attributes.AttributeAtIndex(i)) {
- case DW_AT_name:
- type_name_cstr = form_value.AsCString();
- if (type_name_cstr &&
- type_name_cstr[0]) { // Check for null AND empty string
- type_name.SetString(llvm::StringRef(type_name_cstr));
- } else {
- type_name.SetCString("UNKNOWN_FORTRAN_FUNCTION");
- }
- break;
-
- case DW_AT_type: {
- DWARFDIE type_die = form_value.Reference();
- if (!type_die)
- break;
+ if (!attributes.ExtractFormValueAtIndex(i, form_value))
+ continue;
+ switch (attributes.AttributeAtIndex(i)) {
+ case DW_AT_name:
+ type_name_cstr = form_value.AsCString();
+ if (type_name_cstr &&
+ type_name_cstr[0]) { // Check for null AND empty string
+ type_name.SetString(type_name_cstr);
+ } else {
+ type_name.SetCString("UNKNOWN_FORTRAN_FUNCTION");
+ }
+ break;
+ case DW_AT_type: {
+ if (DWARFDIE type_die = form_value.Reference())
if (Type *resolved_type = die.GetDWARF()->ResolveType(type_die))
return_type = resolved_type->GetForwardCompilerType();
- break;
- }
+ break;
+ }
- default:
- break;
- }
+ default:
+ break;
}
}
@@ -274,16 +271,11 @@ lldb_private::Function *DWARFASTParserFortran::ParseFunctionFromDWARF(
func_name.SetDemangledName(ConstString(name));
FunctionSP func_sp;
-
SymbolFileDWARF *dwarf = die.GetDWARF();
-
// Supply the type only if it has already been parsed
Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
-
assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
-
const user_id_t func_user_id = die.GetID();
-
Address func_addr = ranges[0].GetBaseAddress();
func_sp = std::make_shared<Function>(&comp_unit,
diff --git a/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp b/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
index e7333c77eb6ace..ad6ab337506284 100644
--- a/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
+++ b/lldb/unittests/SymbolFile/DWARF/DWARFASTParserFortranTests.cpp
@@ -261,16 +261,28 @@ TEST_F(DWARFASTParserFortranTests, EnsureFunctionParsingWorks) {
Values:
- Value: 0x22 # DW_LANG_Fortran95
- - AbbrCode: 0x4 # DW_TAG_base_type
+ - AbbrCode: 0x4 # DW_TAG_base_type (Offset: 0x0E)
Values:
- CStr: 'integer'
- Value: 0x5 # DW_ATE_signed
- Value: 0x4 # 4 bytes
+ - AbbrCode: 0x4 # DW_TAG_base_type (Offset: 0x19)
+ Values:
+ - CStr: 'real'
+ - Value: 0x4 # DW_ATE_float
+ - Value: 0x4 # 4 bytes
+
+ - AbbrCode: 0x4 # DW_TAG_base_type (Offset: 0x21)
+ Values:
+ - CStr: 'logical'
+ - Value: 0x2 # DW_ATE_boolean
+ - Value: 0x4 # 4 bytes
+
- AbbrCode: 0x2 # DW_TAG_subprogram
Values:
- CStr: 'multiply_and_add'
- - Value: 0x0E # Return type points to 0x0E (integer)
+ - Value: 0x21 # Return type points to 0x21 (logical)
# Child 1: Parameter 'a'
- AbbrCode: 0x3 # DW_TAG_formal_parameter
@@ -282,7 +294,7 @@ TEST_F(DWARFASTParserFortranTests, EnsureFunctionParsingWorks) {
- AbbrCode: 0x3 # DW_TAG_formal_parameter
Values:
- CStr: 'b'
- - Value: 0x0E # Type points to 0x0E (integer)
+ - Value: 0x19 # Type points to 0x19 (real)
- AbbrCode: 0x0 # End of subprogram children
- AbbrCode: 0x0 # End of compile_unit children
@@ -293,7 +305,7 @@ TEST_F(DWARFASTParserFortranTests, EnsureFunctionParsingWorks) {
DWARFDIE subprogram_die;
SymbolContext sc;
bool is_new_type;
- std::string expected_name = "INTEGER multiply_and_add(INTEGER a, INTEGER b)";
+ std::string expected_name = "LOGICAL multiply_and_add(INTEGER a, REAL b)";
for (DWARFDIE child_die : cu_die.children()) {
if (child_die.Tag() == DW_TAG_subprogram) {
subprogram_die = child_die;
@@ -316,8 +328,8 @@ TEST_F(DWARFASTParserFortranTests, EnsureFunctionParsingWorks) {
CompilerType return_type = function_type.GetFunctionReturnType();
EXPECT_TRUE(return_type.IsValid());
EXPECT_EQ(arg_1.GetBasicTypeEnumeration(), eBasicTypeInt);
- EXPECT_EQ(arg_2.GetBasicTypeEnumeration(), eBasicTypeInt);
- EXPECT_EQ(return_type.GetBasicTypeEnumeration(), eBasicTypeInt);
+ EXPECT_EQ(arg_2.GetBasicTypeEnumeration(), eBasicTypeFloat);
+ EXPECT_EQ(return_type.GetBasicTypeEnumeration(), eBasicTypeBool);
}
TEST_F(DWARFASTParserFortranTests,
>From 9f251f9d0142e4d1b37baa3c925b2b0280734e33 Mon Sep 17 00:00:00 2001
From: Iasonaskrpr <iaskarapro at gmail.com>
Date: Tue, 3 Nov 2026 20:45:54 +0200
Subject: [PATCH 3/4] Clarified Mangled comment, got rid of unnecessary switch,
removed redundant comment and shortened variable names for parameter name and
type vector
---
.../DWARF/DWARFASTParserFortran.cpp | 50 ++++++++-----------
1 file changed, 21 insertions(+), 29 deletions(-)
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
index cf8a6f0904568c..1c63c126ec3488 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
@@ -71,26 +71,18 @@ void DWARFASTParserFortran::ParseChildParameters(
return;
for (DWARFDIE die : parent_die.children()) {
- const dw_tag_t tag = die.Tag();
- switch (tag) {
- case DW_TAG_formal_parameter: {
- if (die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
- continue;
-
- DWARFDIE param_type_die = die.GetAttributeValueAsReferenceDIE(DW_AT_type);
+ if (die.Tag() != DW_TAG_formal_parameter ||
+ die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
+ continue;
- Type *type = die.ResolveTypeUID(param_type_die);
- if (!type)
- break;
-
- function_param_names.emplace_back(die.GetName());
- function_param_types.push_back(type->GetForwardCompilerType());
- } break;
- default:
+ DWARFDIE param_type_die = die.GetAttributeValueAsReferenceDIE(DW_AT_type);
+ Type *type = die.ResolveTypeUID(param_type_die);
+ if (!type)
break;
- }
- }
+ function_param_names.emplace_back(die.GetName());
+ function_param_types.push_back(type->GetForwardCompilerType());
+ }
assert(function_param_names.size() == function_param_types.size());
}
@@ -188,21 +180,19 @@ lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
if (!attributes.ExtractFormValueAtIndex(i, form_value))
continue;
switch (attributes.AttributeAtIndex(i)) {
- case DW_AT_name:
- type_name_cstr = form_value.AsCString();
- if (type_name_cstr &&
- type_name_cstr[0]) { // Check for null AND empty string
+ case DW_AT_name: {
+ const char *type_name_cstr = form_value.AsCString();
+ if (type_name_cstr && type_name_cstr[0] != '\0') {
type_name.SetString(type_name_cstr);
} else {
type_name.SetCString("UNKNOWN_FORTRAN_FUNCTION");
}
break;
-
+ }
case DW_AT_type: {
if (DWARFDIE type_die = form_value.Reference())
if (Type *resolved_type = die.GetDWARF()->ResolveType(type_die))
return_type = resolved_type->GetForwardCompilerType();
-
break;
}
@@ -211,12 +201,12 @@ lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
}
}
- llvm::SmallVector<CompilerType, 4> function_params_types;
- llvm::SmallVector<llvm::StringRef, 4> function_params_names;
- ParseChildParameters(die, function_params_types, function_params_names);
+ llvm::SmallVector<CompilerType, 4> param_types;
+ llvm::SmallVector<llvm::StringRef, 4> param_names;
+ ParseChildParameters(die, param_types, param_names);
- compiler_type = m_ast.CreateFortranFunction(
- type_name, function_params_types, function_params_names, return_type);
+ compiler_type = m_ast.CreateFortranFunction(type_name, param_types,
+ param_names, return_type);
type_sp = dwarf->MakeType(die.GetID(), type_name, 0, nullptr,
LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
@@ -263,7 +253,9 @@ lldb_private::Function *DWARFASTParserFortran::ParseFunctionFromDWARF(
return nullptr;
Mangled func_name;
- // Mangled doesn't know how to demangle fortran names
+ // TODO: Once the Mangled class supports Fortran demangling, we should
+ // synthesize a demangled name here if GetDIENamesAndRanges fails to provide
+ // one.
if (mangled)
func_name.SetMangledName(ConstString(mangled));
>From 2b7b98b226848aed452de81a693e828a0bcf8928 Mon Sep 17 00:00:00 2001
From: Iasonas Karaprodromidis <iaskarapro at gmail.com>
Date: Wed, 4 Nov 2026 02:58:01 +0200
Subject: [PATCH 4/4] Removed single line if brackets and changed function
parsing parameters name as well as argument names.
---
.../DWARF/DWARFASTParserFortran.cpp | 24 +++++++++----------
.../SymbolFile/DWARF/DWARFASTParserFortran.h | 8 +++----
2 files changed, 16 insertions(+), 16 deletions(-)
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
index 1c63c126ec3488..f1a6d8dd6ac3b7 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp
@@ -63,14 +63,14 @@ TypeSP DWARFASTParserFortran::UpdateSymbolContextScopeForType(
return type_sp;
}
-void DWARFASTParserFortran::ParseChildParameters(
- const DWARFDIE &parent_die,
- llvm::SmallVectorImpl<CompilerType> &function_param_types,
- llvm::SmallVectorImpl<llvm::StringRef> &function_param_names) {
- if (!parent_die)
+void DWARFASTParserFortran::ParseFunctionParameters(
+ const DWARFDIE &function_die,
+ llvm::SmallVectorImpl<CompilerType> ¶m_types,
+ llvm::SmallVectorImpl<llvm::StringRef> ¶m_names) {
+ if (!function_die)
return;
- for (DWARFDIE die : parent_die.children()) {
+ for (DWARFDIE die : function_die.children()) {
if (die.Tag() != DW_TAG_formal_parameter ||
die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
continue;
@@ -80,10 +80,10 @@ void DWARFASTParserFortran::ParseChildParameters(
if (!type)
break;
- function_param_names.emplace_back(die.GetName());
- function_param_types.push_back(type->GetForwardCompilerType());
+ param_names.emplace_back(die.GetName());
+ param_types.push_back(type->GetForwardCompilerType());
}
- assert(function_param_names.size() == function_param_types.size());
+ assert(param_names.size() == param_types.size());
}
lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
@@ -182,11 +182,11 @@ lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF(
switch (attributes.AttributeAtIndex(i)) {
case DW_AT_name: {
const char *type_name_cstr = form_value.AsCString();
- if (type_name_cstr && type_name_cstr[0] != '\0') {
+ if (type_name_cstr && type_name_cstr[0] != '\0')
type_name.SetString(type_name_cstr);
- } else {
+ else
type_name.SetCString("UNKNOWN_FORTRAN_FUNCTION");
- }
+
break;
}
case DW_AT_type: {
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
index 96988be8591d53..7466dec33510bf 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h
@@ -43,10 +43,10 @@ class DWARFASTParserFortran
const lldb_private::SymbolContext &sc,
const lldb_private::plugin::dwarf::DWARFDIE &die, lldb::TypeSP type_sp);
- void ParseChildParameters(
- const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
- llvm::SmallVectorImpl<lldb_private::CompilerType> &function_param_types,
- llvm::SmallVectorImpl<llvm::StringRef> &function_param_names);
+ void ParseFunctionParameters(
+ const lldb_private::plugin::dwarf::DWARFDIE &function_die,
+ llvm::SmallVectorImpl<lldb_private::CompilerType> ¶m_types,
+ llvm::SmallVectorImpl<llvm::StringRef> ¶m_names);
lldb::TypeSP
ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
More information about the llvm-branch-commits
mailing list