https://github.com/Iasonaskrpr updated https://github.com/llvm/llvm-project/pull/218024
>From f902f7f8a20dbfe71db5a5f56172d83a5e0d74c1 Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Fri, 4 Sep 2026 21:01:23 +0300 Subject: [PATCH 1/2] [lldb][Fortran] Added TypeSystemFortran and Fortran language plugin --- lldb/include/lldb/Target/Language.h | 2 + lldb/include/lldb/lldb-forward.h | 1 + lldb/source/Plugins/Language/CMakeLists.txt | 1 + .../Plugins/Language/Fortran/CMakeLists.txt | 12 + .../Language/Fortran/FortranLanguage.cpp | 63 +++ .../Language/Fortran/FortranLanguage.h | 55 ++ lldb/source/Plugins/TypeSystem/CMakeLists.txt | 1 + .../Plugins/TypeSystem/Fortran/CMakeLists.txt | 12 + .../TypeSystem/Fortran/TypeSystemFortran.cpp | 81 +++ .../TypeSystem/Fortran/TypeSystemFortran.h | 494 ++++++++++++++++++ lldb/source/Target/Language.cpp | 14 + lldb/unittests/Language/CMakeLists.txt | 1 + .../unittests/Language/Fortran/CMakeLists.txt | 6 + .../Language/Fortran/FortranLanguageTest.cpp | 40 ++ 14 files changed, 783 insertions(+) create mode 100644 lldb/source/Plugins/Language/Fortran/CMakeLists.txt create mode 100644 lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp create mode 100644 lldb/source/Plugins/Language/Fortran/FortranLanguage.h create mode 100644 lldb/source/Plugins/TypeSystem/Fortran/CMakeLists.txt create mode 100644 lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp create mode 100644 lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h create mode 100644 lldb/unittests/Language/Fortran/CMakeLists.txt create mode 100644 lldb/unittests/Language/Fortran/FortranLanguageTest.cpp diff --git a/lldb/include/lldb/Target/Language.h b/lldb/include/lldb/Target/Language.h index 879a4f14783fa..c08994cc32e9f 100644 --- a/lldb/include/lldb/Target/Language.h +++ b/lldb/include/lldb/Target/Language.h @@ -443,6 +443,8 @@ class Language : public PluginInterface { /// Equivalent to \c LanguageIsC||LanguageIsObjC||LanguageIsCPlusPlus. static bool LanguageIsCFamily(lldb::LanguageType language); + static bool LanguageIsFortran(lldb::LanguageType language); + static bool LanguageIsPascal(lldb::LanguageType language); // return the primary language, so if LanguageIsC(l), return eLanguageTypeC, diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index f691b5a3a76e9..f48f077e9b5ee 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -289,6 +289,7 @@ class TypeSummaryImpl; class TypeSummaryOptions; class TypeSystem; class TypeSystemClang; +class TypeSystemFortran; class UUID; class UnixSignals; class Unwind; diff --git a/lldb/source/Plugins/Language/CMakeLists.txt b/lldb/source/Plugins/Language/CMakeLists.txt index 6367ab916c8fb..5377734af2f8d 100644 --- a/lldb/source/Plugins/Language/CMakeLists.txt +++ b/lldb/source/Plugins/Language/CMakeLists.txt @@ -7,3 +7,4 @@ set_property(DIRECTORY PROPERTY LLDB_TOLERATED_PLUGIN_DEPENDENCIES add_subdirectory(CPlusPlus) add_subdirectory(ObjC) add_subdirectory(ObjCPlusPlus) +add_subdirectory(Fortran) diff --git a/lldb/source/Plugins/Language/Fortran/CMakeLists.txt b/lldb/source/Plugins/Language/Fortran/CMakeLists.txt new file mode 100644 index 0000000000000..3ee934fa01f52 --- /dev/null +++ b/lldb/source/Plugins/Language/Fortran/CMakeLists.txt @@ -0,0 +1,12 @@ +add_lldb_library(lldbPluginFortranLanguage PLUGIN + FortranLanguage.cpp + + LINK_LIBS + lldbCore + lldbDataFormatters + lldbExpression + lldbHost + lldbSymbol + lldbTarget + lldbUtility +) diff --git a/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp b/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp new file mode 100644 index 0000000000000..5df2f36f92eb7 --- /dev/null +++ b/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file implements the Fortran language plugin. +/// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/StringRef.h" + +#include "FortranLanguage.h" + +#include "lldb/Core/PluginManager.h" + +using namespace llvm; +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::formatters; + +LLDB_PLUGIN_DEFINE(FortranLanguage) + +void FortranLanguage::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), "Fortran Language", + CreateInstance); +} + +void FortranLanguage::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +StringRef FortranLanguage::GetPluginNameStatic() { + static llvm::StringRef g_name("fortran"); + return g_name; +} + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +StringRef FortranLanguage::GetPluginName() { return GetPluginNameStatic(); } + +uint32_t FortranLanguage::GetPluginVersion() { return 1; } + +Language *FortranLanguage::CreateInstance(LanguageType language) { + if (Language::LanguageIsFortran(language)) { + return new FortranLanguage(); + } + return nullptr; +} + +bool FortranLanguage::IsSourceFile(StringRef file_path) const { + const auto suffixes = {".f90", ".f", ".f95", ".f03", ".f08", + ".f18", ".for", ".ftn", ".fpp", ",f77"}; + for (auto suffix : suffixes) { + if (file_path.ends_with_insensitive(suffix)) + return true; + } + return false; +} diff --git a/lldb/source/Plugins/Language/Fortran/FortranLanguage.h b/lldb/source/Plugins/Language/Fortran/FortranLanguage.h new file mode 100644 index 0000000000000..6d6a2d264089a --- /dev/null +++ b/lldb/source/Plugins/Language/Fortran/FortranLanguage.h @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file defines the Fortran language plugin. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_PLUGINS_LANGUAGE_FORTRAN_FORTRANLANGUAGE_H +#define LLDB_SOURCE_PLUGINS_LANGUAGE_FORTRAN_FORTRANLANGUAGE_H +#include "lldb/Target/Language.h" + +#include "llvm/ADT/StringRef.h" + +#include "lldb/Target/Language.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/lldb-private.h" + +namespace lldb_private { + +class FortranLanguage : public Language { +public: + FortranLanguage() = default; + + ~FortranLanguage() override = default; + + lldb::LanguageType GetLanguageType() const override { + return lldb::eLanguageTypeFortran90; + } + + // Static Functions + static void Initialize(); + + static void Terminate(); + + static lldb_private::Language *CreateInstance(lldb::LanguageType language); + + static llvm::StringRef GetPluginNameStatic(); + + // PluginInterface protocol + llvm::StringRef GetPluginName() override; + + uint32_t GetPluginVersion(); + + bool IsSourceFile(llvm::StringRef file_path) const override; +}; + +}; // namespace lldb_private + +#endif // LLDB_SOURCE_PLUGINS_LANGUAGE_FORTRAN_FORTRANLANGUAGE_H diff --git a/lldb/source/Plugins/TypeSystem/CMakeLists.txt b/lldb/source/Plugins/TypeSystem/CMakeLists.txt index 47e32ff176d8c..2761f4a9df277 100644 --- a/lldb/source/Plugins/TypeSystem/CMakeLists.txt +++ b/lldb/source/Plugins/TypeSystem/CMakeLists.txt @@ -3,3 +3,4 @@ set_property(DIRECTORY PROPERTY LLDB_PLUGIN_KIND TypeSystem) set_property(DIRECTORY PROPERTY LLDB_TOLERATED_PLUGIN_DEPENDENCIES SymbolFile) add_subdirectory(Clang) +add_subdirectory(Fortran) diff --git a/lldb/source/Plugins/TypeSystem/Fortran/CMakeLists.txt b/lldb/source/Plugins/TypeSystem/Fortran/CMakeLists.txt new file mode 100644 index 0000000000000..c78b70d48eb31 --- /dev/null +++ b/lldb/source/Plugins/TypeSystem/Fortran/CMakeLists.txt @@ -0,0 +1,12 @@ +add_lldb_library(lldbPluginTypeSystemFortran PLUGIN + TypeSystemFortran.cpp + + LINK_COMPONENTS + Support + LINK_LIBS + lldbCore + lldbSymbol + lldbTarget + lldbUtility + lldbPluginSymbolFileDWARF +) diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp new file mode 100644 index 0000000000000..f1466c4165c52 --- /dev/null +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file implements the Fortran type system. +/// +//===----------------------------------------------------------------------===// +#include "TypeSystemFortran.h" + +#include "lldb/Core/PluginManager.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Target/Target.h" + +using namespace lldb; +using namespace lldb_private; +using namespace llvm; +using namespace lldb_private::plugin::dwarf; + +LLDB_PLUGIN_DEFINE(TypeSystemFortran) + +/// Used to determine if TypeSystem supports the language passed in +/// CreateInstance +static bool IsLanguageSupported(lldb::LanguageType language) { + if (language == lldb::LanguageType::eLanguageTypeFortran77 || + language == lldb::LanguageType::eLanguageTypeFortran90 || + language == lldb::LanguageType::eLanguageTypeFortran95 || + language == lldb::LanguageType::eLanguageTypeFortran03 || + language == lldb::LanguageType::eLanguageTypeFortran08 || + language == lldb::LanguageType::eLanguageTypeFortran18) + return true; + + return false; +} + +char TypeSystemFortran::ID; + +TypeSystemFortran::~TypeSystemFortran() = default; +TypeSystemFortran::TypeSystemFortran() = default; + +void TypeSystemFortran::Initialize() { + PluginManager::RegisterPlugin( + GetPluginNameStatic(), "fortran AST context plug-in", CreateInstance, + GetSupportedLanguagesForTypes(), GetSupportedLanguagesForExpressions()); +} + +void TypeSystemFortran::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb::TypeSystemSP +TypeSystemFortran::CreateInstance(lldb::LanguageType language, Module *module, + Target *target) { + if (IsLanguageSupported(language)) { + return std::make_shared<TypeSystemFortran>(); + } + return TypeSystemSP(); +} + +LanguageSet TypeSystemFortran::GetSupportedLanguagesForTypes() { + LanguageSet languages; + languages.Insert(eLanguageTypeFortran77); + languages.Insert(eLanguageTypeFortran90); + languages.Insert(eLanguageTypeFortran95); + languages.Insert(eLanguageTypeFortran03); + languages.Insert(eLanguageTypeFortran08); + languages.Insert(eLanguageTypeFortran18); + return languages; +} + +LanguageSet TypeSystemFortran::GetSupportedLanguagesForExpressions() { + return GetSupportedLanguagesForTypes(); +} + +bool TypeSystemFortran::SupportsLanguage(lldb::LanguageType language) { + return IsLanguageSupported(language); +} diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h new file mode 100644 index 0000000000000..6291d4c8131dc --- /dev/null +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h @@ -0,0 +1,494 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file contains the definition of the Fortran Type System. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_PLUGINS_TYPESYSTEM_FORTRAN_TYPESYSTEMFORTRAN_H +#define LLDB_SOURCE_PLUGINS_TYPESYSTEM_FORTRAN_TYPESYSTEMFORTRAN_H + +#include "lldb/Symbol/TypeSystem.h" +#include "llvm/Support/ErrorHandling.h" + +namespace lldb_private { + +class TypeSystemFortran : public TypeSystem { + // LLVM RTTI support + static char ID; + +public: + // llvm casting support + bool isA(const void *ClassID) const override { return ClassID == &ID; } + static bool classof(const TypeSystem *ts) { return ts->isA(&ID); } + + TypeSystemFortran(); + + ~TypeSystemFortran(); + + static void Initialize(); + + static void Terminate(); + + static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, + Module *module, Target *target); + + static LanguageSet GetSupportedLanguagesForTypes(); + + static LanguageSet GetSupportedLanguagesForExpressions(); + + // CompilerDecl functions + ConstString DeclGetName(void *opaque_decl) override { return ConstString(); } + + CompilerType GetTypeForDecl(void *opaque_decl) override { + return CompilerType(); + } + + // CompilerDeclContext functions + + ConstString DeclContextGetName(void *opaque_decl_ctx) override { + return ConstString(); + } + + ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override { + return ConstString(); + } + + bool DeclContextIsClassMethod(void *opaque_decl_ctx) override { + return false; + } + + bool DeclContextIsContainedInLookup(void *opaque_decl_ctx, + void *other_opaque_decl_ctx) override { + return false; + } + + lldb::LanguageType DeclContextGetLanguage(void *opaque_decl_ctx) override { + return lldb::LanguageType::eLanguageTypeUnknown; + } + +// Tests +#ifndef NDEBUG + /// Verify the integrity of the type to catch CompilerTypes that mix + /// and match invalid TypeSystem/Opaque type pairs. + bool Verify(lldb::opaque_compiler_type_t type) override { return false; }; +#endif + + bool IsArrayType(lldb::opaque_compiler_type_t type, + CompilerType *element_type, uint64_t *size, + bool *is_incomplete) override { + return false; + }; + + bool IsAggregateType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsCharType(lldb::opaque_compiler_type_t type) override { return false; } + + bool IsCompleteType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsDefined(lldb::opaque_compiler_type_t type) override { return false; } + + bool IsFloatingPointType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsFunctionType(lldb::opaque_compiler_type_t type) override { + return false; + } + + size_t + GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override { + return 0; + } + + CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, + const size_t index) override { + return CompilerType(); + } + + bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsMemberDataPointerType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsBlockPointerType(lldb::opaque_compiler_type_t type, + CompilerType *function_pointer_type_ptr) override { + return false; + } + + bool IsIntegerType(lldb::opaque_compiler_type_t type, + bool &is_signed) override { + return false; + }; + + bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type, + CompilerType *target_type, // Can pass NULL + bool check_cplusplus, bool check_objc) override { + return false; + } + + bool IsPointerType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type) override { + return false; + } + + bool IsScalarType(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsVoidType(lldb::opaque_compiler_type_t type) override { return false; } + + bool CanPassInRegisters(const CompilerType &type) override { return false; } + + // TypeSystems can support more than one language + bool SupportsLanguage(lldb::LanguageType language) override; + + llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); } + + static llvm::StringRef GetPluginNameStatic() { return "fortran"; } + + // Type Completion + + bool GetCompleteType(lldb::opaque_compiler_type_t type) override { + return false; + } + + // AST related queries + + uint32_t GetPointerByteSize() override { return 0; } + + CompilerType GetPointerDiffType(bool is_signed) override { + return CompilerType(); + } + + CompilerType GetSizeType() override { return CompilerType(); } + + unsigned GetPtrAuthKey(lldb::opaque_compiler_type_t type) override { + return 0; + } + + unsigned GetPtrAuthDiscriminator(lldb::opaque_compiler_type_t type) override { + return 0; + } + + bool GetPtrAuthAddressDiversity(lldb::opaque_compiler_type_t type) override { + return false; + } + + // Accessors + + ConstString GetTypeName(lldb::opaque_compiler_type_t type, + bool BaseOnly) override { + return ConstString(); + } + + ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override { + return ConstString(); + } + + uint32_t + GetTypeInfo(lldb::opaque_compiler_type_t type, + CompilerType *pointee_or_element_compiler_type) override { + return 0; + } + + lldb::LanguageType + GetMinimumLanguage(lldb::opaque_compiler_type_t type) override { + return lldb::LanguageType::eLanguageTypeFortran90; + } + + lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override { + return lldb::TypeClass::eTypeClassInvalid; + } + + // Creating related types + + CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, + ExecutionContextScope *exe_scope) override { + return CompilerType(); + } + + CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + CompilerType + GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + // Returns -1 if this isn't a function of if the function doesn't have a + // prototype Returns a value >= 0 if there is a prototype. + int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override { + return -1; + } + + CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, + size_t idx) override { + return CompilerType(); + } + + CompilerType + GetFunctionReturnType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override { + return 0; + } + + TypeMemberFunctionImpl + GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, + size_t idx) override { + return TypeMemberFunctionImpl(); + } + + CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + // Exploring the type + + const llvm::fltSemantics & + GetFloatTypeSemantics(size_t byte_size, lldb::Format format) override { + return llvm::APFloatBase::Bogus(); + } + + llvm::Expected<uint64_t> + GetBitSize(lldb::opaque_compiler_type_t type, + ExecutionContextScope *exe_scope) override { + return 0; + } + + lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type) override { + return lldb::eEncodingInvalid; + } + + lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override { + return lldb::eFormatDefault; + } + + llvm::Expected<uint32_t> + GetNumChildren(lldb::opaque_compiler_type_t type, + bool omit_empty_base_classes, + const ExecutionContext *exe_ctx) override { + return 0; + } + + lldb::BasicType + GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override { + return lldb::eBasicTypeUnsignedInt; + } + + uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override { + return 0; + } + + CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, + std::string &name, uint64_t *bit_offset_ptr, + uint32_t *bitfield_bit_size_ptr, + bool *is_bitfield_ptr) override { + return CompilerType(); + } + + uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override { + return 0; + } + + uint32_t + GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override { + return 0; + } + + CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, + size_t idx, + uint32_t *bit_offset_ptr) override { + return CompilerType(); + } + + CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, + size_t idx, + uint32_t *bit_offset_ptr) override { + return CompilerType(); + } + + llvm::Expected<CompilerType> + GetDereferencedType(lldb::opaque_compiler_type_t type, + ExecutionContext *exe_ctx, std::string &deref_name, + uint32_t &deref_byte_size, int32_t &deref_byte_offset, + ValueObject *valobj, uint64_t &language_flags) override { + return CompilerType(); + } + + llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex( + lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, + bool transparent_pointers, bool omit_empty_base_classes, + bool ignore_array_bounds, std::string &child_name, + uint32_t &child_byte_size, int32_t &child_byte_offset, + uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, + bool &child_is_base_class, bool &child_is_deref_of_parent, + ValueObject *valobj, uint64_t &language_flags) override { + return CompilerType(); + } + + // Lookup a child given a name. This function will match base class names and + // member member names in "clang_type" only, not descendants. + llvm::Expected<uint32_t> + GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, + llvm::StringRef name, + bool omit_empty_base_classes) override { + return 0; + } + + size_t + GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, + llvm::StringRef name, + bool omit_empty_base_classes, + std::vector<uint32_t> &child_indexes) override { + return 0; + } + +#ifndef NDEBUG + /// Convenience LLVM-style dump method for use in the debugger only. + LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const override { + } +#endif + + bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream &s, + lldb::Format format, const DataExtractor &data, + lldb::offset_t data_offset, size_t data_byte_size, + uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, + ExecutionContextScope *exe_scope) override { + return false; + } + + /// Dump the type to stdout. + void DumpTypeDescription( + lldb::opaque_compiler_type_t type, + lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override {} + + /// Print a description of the type to a stream. The exact implementation + /// varies, but the expectation is that eDescriptionLevelFull returns a + /// source-like representation of the type, whereas eDescriptionLevelVerbose + /// does a dump of the underlying AST if applicable. + void DumpTypeDescription( + lldb::opaque_compiler_type_t type, Stream &s, + lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) override {} + + /// Dump a textual representation of the internal TypeSystem state to the + /// given stream. + /// + /// This should not modify the state of the TypeSystem if possible. + /// + /// \param[out] output Stream to dup the AST into. + /// \param[in] filter If empty, dump whole AST. If non-empty, will only + /// dump decls whose names contain \c filter. + /// \param[in] show_color If true, prints the AST color-highlighted. + void Dump(llvm::raw_ostream &output, llvm::StringRef filter, + bool show_color) override {} + + /// This is used by swift. + bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override { + return false; + } + + // TODO: Determine if these methods should move to TypeSystemClang. + + bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type) override { + return false; + } + + unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override { + return 0; + } + + std::optional<size_t> + GetTypeBitAlign(lldb::opaque_compiler_type_t type, + ExecutionContextScope *exe_scope) override { + return 0; + } + + CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override { + return CompilerType(); + } + + CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, + size_t bit_size) override { + return CompilerType(); + } + + bool IsBeingDefined(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsConst(lldb::opaque_compiler_type_t type) override { return false; } + + uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, + CompilerType *base_type_ptr) override { + return 0; + } + + bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override { + return false; + } + + bool IsTypedefType(lldb::opaque_compiler_type_t type) override { + return false; + } + + // If the current object represents a typedef type, get the underlying type + CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + bool IsVectorType(lldb::opaque_compiler_type_t type, + CompilerType *element_type, uint64_t *size) override { + return false; + } + + CompilerType + GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override { + return CompilerType(); + } + + bool IsReferenceType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type, bool *is_rvalue) override { + return false; + } + +private: + TypeSystemFortran(const TypeSystemFortran &) = delete; + const TypeSystemFortran &operator=(const TypeSystemFortran &) = delete; +}; +} // namespace lldb_private +#endif // LLDB_SOURCE_PLUGINS_TYPESYSTEM_FORTRAN_TYPESYSTEMFORTRAN_H diff --git a/lldb/source/Target/Language.cpp b/lldb/source/Target/Language.cpp index 077c403f4ea58..a4d6031b4b27d 100644 --- a/lldb/source/Target/Language.cpp +++ b/lldb/source/Target/Language.cpp @@ -396,6 +396,20 @@ bool Language::LanguageIsCFamily(LanguageType language) { } } +bool Language::LanguageIsFortran(LanguageType language) { + switch (language) { + case eLanguageTypeFortran77: + case eLanguageTypeFortran90: + case eLanguageTypeFortran95: + case eLanguageTypeFortran03: + case eLanguageTypeFortran08: + case eLanguageTypeFortran18: + return true; + default: + return false; + } +} + bool Language::LanguageIsPascal(LanguageType language) { switch (language) { case eLanguageTypePascal83: diff --git a/lldb/unittests/Language/CMakeLists.txt b/lldb/unittests/Language/CMakeLists.txt index a0bdc62af98c6..26710ff8896e2 100644 --- a/lldb/unittests/Language/CMakeLists.txt +++ b/lldb/unittests/Language/CMakeLists.txt @@ -1,3 +1,4 @@ add_subdirectory(CPlusPlus) add_subdirectory(CLanguages) add_subdirectory(ObjC) +add_subdirectory(Fortran) diff --git a/lldb/unittests/Language/Fortran/CMakeLists.txt b/lldb/unittests/Language/Fortran/CMakeLists.txt new file mode 100644 index 0000000000000..661b12ebf8950 --- /dev/null +++ b/lldb/unittests/Language/Fortran/CMakeLists.txt @@ -0,0 +1,6 @@ +add_lldb_unittest(LanguageFortranLanguageTests + FortranLanguageTest.cpp + + LINK_LIBS + lldbPluginFortranLanguage +) diff --git a/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp b/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp new file mode 100644 index 0000000000000..d8d7287e0104c --- /dev/null +++ b/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file tests the Fortran plugin features. +/// +//===----------------------------------------------------------------------===// + +#include "Plugins/Language/Fortran/FortranLanguage.h" +#include "TestingSupport/SubsystemRAII.h" +#include "lldb/lldb-enumerations.h" + +#include "gmock/gmock.h" +#include "gtest/gtest.h" + +using namespace lldb_private; + +/// Returns the name of the LLDB plugin for the given language or an empty +/// string if there is no fitting plugin. +static llvm::StringRef GetPluginName(lldb::LanguageType language) { + if (Language *language_plugin = Language::FindPlugin(language)) + return language_plugin->GetPluginName(); + return ""; +} + +TEST(FortranLanguage, LookupFortranLanguageByLanguageType) { + SubsystemRAII<FortranLanguage> langs; + + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran77), "fortran"); + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran90), "fortran"); + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran95), "fortran"); + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran03), "fortran"); + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran08), "fortran"); + EXPECT_EQ(GetPluginName(lldb::eLanguageTypeFortran18), "fortran"); +} \ No newline at end of file >From 7aa958564b46b8ac3cff05af00922696b6c28504 Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Fri, 4 Sep 2026 21:07:44 +0300 Subject: [PATCH 2/2] [lldb][Fortran] Added DWARFASTParserFortran class and added function to get the DWARFASTParserFortran from TypeSystemFortran --- .../Plugins/SymbolFile/DWARF/CMakeLists.txt | 1 + .../Plugins/SymbolFile/DWARF/DWARFASTParser.h | 2 +- .../DWARF/DWARFASTParserFortran.cpp | 43 ++++++++++ .../SymbolFile/DWARF/DWARFASTParserFortran.h | 80 +++++++++++++++++++ .../TypeSystem/Fortran/TypeSystemFortran.cpp | 8 ++ .../TypeSystem/Fortran/TypeSystemFortran.h | 4 + 6 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp create mode 100644 lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h diff --git a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt index 3f7cf023ac21c..7aacc5019aa04 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt +++ b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt @@ -16,6 +16,7 @@ add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN DIERef.cpp DWARFASTParser.cpp DWARFASTParserClang.cpp + DWARFASTParserFortran.cpp DWARFAttribute.cpp DWARFBaseDIE.cpp DWARFCompileUnit.cpp diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h index 80f7becc1b24b..8f32874d788af 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h @@ -29,7 +29,7 @@ class SymbolFileDWARF; class DWARFASTParser { public: - enum class Kind { DWARFASTParserClang }; + enum class Kind { DWARFASTParserClang, DWARFASTParserFortran }; DWARFASTParser(Kind kind) : m_kind(kind) {} virtual ~DWARFASTParser() = default; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp new file mode 100644 index 0000000000000..734271bc67554 --- /dev/null +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file implements the DWARF AST parser for the Fortran language. +/// +//===----------------------------------------------------------------------===// + +#include "DWARFASTParserFortran.h" + +using namespace lldb; +using namespace lldb_private; + +DWARFASTParserFortran::DWARFASTParserFortran( + lldb_private::TypeSystemFortran &m_ast) + : lldb_private::plugin::dwarf::DWARFASTParser(Kind::DWARFASTParserFortran), + m_ast(m_ast) {} + +DWARFASTParserFortran::~DWARFASTParserFortran() {} + +lldb::TypeSP DWARFASTParserFortran::ParseTypeFromDWARF( + const lldb_private::SymbolContext &sc, + const lldb_private::plugin::dwarf::DWARFDIE &die, bool *type_is_new_ptr) { + return lldb::TypeSP(); +} + +lldb_private::Function *DWARFASTParserFortran::ParseFunctionFromDWARF( + lldb_private::CompileUnit &comp_unit, + const lldb_private::plugin::dwarf::DWARFDIE &die, + lldb_private::AddressRanges ranges) { + return nullptr; +} + +bool DWARFASTParserFortran::CompleteTypeFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::Type *type, + const lldb_private::CompilerType &compiler_type) { + return false; +} diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h new file mode 100644 index 0000000000000..827a2eb620aa8 --- /dev/null +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file defines the DWARF AST parser for the Fortran language. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERFORTRAN_H +#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERFORTRAN_H + +#include "DWARFASTParser.h" +#include "Plugins/SymbolFile/DWARF/DWARFDIE.h" +#include "Plugins/TypeSystem/Fortran/TypeSystemFortran.h" + +namespace lldb_private { +class CompileUnit; +class ExecutionContext; +} // namespace lldb_private + +class DWARFASTParserFortran + : public lldb_private::plugin::dwarf::DWARFASTParser { +public: + DWARFASTParserFortran(lldb_private::TypeSystemFortran &m_ast); + + ~DWARFASTParserFortran() override; + + lldb::TypeSP + ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, + const lldb_private::plugin::dwarf::DWARFDIE &die, + bool *type_is_new_ptr) override; + + lldb_private::Function * + ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit, + const lldb_private::plugin::dwarf::DWARFDIE &die, + lldb_private::AddressRanges ranges) override; + + bool CompleteTypeFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die, + lldb_private::Type *type, + const lldb_private::CompilerType &compiler_type) override; + + lldb_private::ConstString ConstructDemangledNameFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die) override { + return lldb_private::ConstString(); + } + + lldb_private::CompilerDecl GetDeclForUIDFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die) override { + return lldb_private::CompilerDecl(); + } + + lldb_private::CompilerDeclContext GetDeclContextForUIDFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die) override { + return lldb_private::CompilerDeclContext(); + } + + lldb_private::CompilerDeclContext GetDeclContextContainingUIDFromDWARF( + const lldb_private::plugin::dwarf::DWARFDIE &die) override { + return lldb_private::CompilerDeclContext(); + } + + void EnsureAllDIEsInDeclContextHaveBeenParsed( + lldb_private::CompilerDeclContext decl_context) override {} + + std::string GetDIEClassTemplateParams( + lldb_private::plugin::dwarf::DWARFDIE die) override { + return {}; + } + +private: + lldb_private::TypeSystemFortran &m_ast; +}; + +#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERFORTRAN_H diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp index f1466c4165c52..2e2af92d67ff6 100644 --- a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp @@ -16,6 +16,8 @@ #include "lldb/Symbol/SymbolFile.h" #include "lldb/Target/Target.h" +#include "Plugins/SymbolFile/DWARF/DWARFASTParserFortran.h" + using namespace lldb; using namespace lldb_private; using namespace llvm; @@ -52,6 +54,12 @@ void TypeSystemFortran::Terminate() { PluginManager::UnregisterPlugin(CreateInstance); } +plugin::dwarf::DWARFASTParser *TypeSystemFortran::GetDWARFParser() { + if (!m_dwarf_ast_parser_up) + m_dwarf_ast_parser_up = std::make_unique<DWARFASTParserFortran>(*this); + return m_dwarf_ast_parser_up.get(); +} + lldb::TypeSystemSP TypeSystemFortran::CreateInstance(lldb::LanguageType language, Module *module, Target *target) { diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h index 6291d4c8131dc..afe14e46aa7ce 100644 --- a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h @@ -36,6 +36,8 @@ class TypeSystemFortran : public TypeSystem { static void Terminate(); + plugin::dwarf::DWARFASTParser *GetDWARFParser() override; + static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language, Module *module, Target *target); @@ -487,6 +489,8 @@ class TypeSystemFortran : public TypeSystem { } private: + std::unique_ptr<plugin::dwarf::DWARFASTParser> m_dwarf_ast_parser_up; + TypeSystemFortran(const TypeSystemFortran &) = delete; const TypeSystemFortran &operator=(const TypeSystemFortran &) = delete; }; _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
