https://github.com/Iasonaskrpr updated https://github.com/llvm/llvm-project/pull/218016
>From 1c8e2fd2630c01ca016a79b320c23e5ac0c4d43f Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Fri, 4 Sep 2026 20:28:12 +0300 Subject: [PATCH 1/4] [lldb][Fortran] Added Fortran language plugin and tests from dependent PR --- lldb/include/lldb/Target/Language.h | 2 + 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/Target/Language.cpp | 14 +++++ lldb/unittests/Language/CMakeLists.txt | 1 + .../unittests/Language/Fortran/CMakeLists.txt | 6 ++ .../Language/Fortran/FortranLanguageTest.cpp | 40 ++++++++++++ 9 files changed, 194 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/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/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..b3958c2e8906e --- /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/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 b352235ebed72221580c99c4038ecd44bb21b55e Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Fri, 4 Sep 2026 20:34:06 +0300 Subject: [PATCH 2/4] [lldb][Fortran] Added TypeSystemFortran stubs --- lldb/include/lldb/lldb-forward.h | 1 + lldb/source/Plugins/TypeSystem/CMakeLists.txt | 1 + .../Plugins/TypeSystem/Fortran/CMakeLists.txt | 12 + .../TypeSystem/Fortran/TypeSystemFortran.cpp | 81 +++ .../TypeSystem/Fortran/TypeSystemFortran.h | 494 ++++++++++++++++++ 5 files changed, 589 insertions(+) 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 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/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 >From d086ff864a3c37324db7ce79a1d0cbaa6f0c0d6a Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Mon, 7 Sep 2026 17:31:14 +0300 Subject: [PATCH 3/4] [lldb][Fortran] Made suggested changes from reviews --- .../Language/Fortran/FortranLanguage.cpp | 14 ++------ .../Language/Fortran/FortranLanguage.h | 7 ---- .../TypeSystem/Fortran/TypeSystemFortran.cpp | 32 ++++--------------- .../TypeSystem/Fortran/TypeSystemFortran.h | 12 ++----- .../Language/Fortran/FortranLanguageTest.cpp | 31 +++++++----------- 5 files changed, 24 insertions(+), 72 deletions(-) diff --git a/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp b/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp index 5df2f36f92eb7..7543e8dded042 100644 --- a/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp +++ b/lldb/source/Plugins/Language/Fortran/FortranLanguage.cpp @@ -5,11 +5,6 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// -/// -/// \file -/// This file implements the Fortran language plugin. -/// -//===----------------------------------------------------------------------===// #include "llvm/ADT/StringRef.h" @@ -38,23 +33,20 @@ StringRef FortranLanguage::GetPluginNameStatic() { 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)) { + 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"}; + ".f18", ".for", ".ftn", ".fpp", ".f77"}; for (auto suffix : suffixes) { if (file_path.ends_with_insensitive(suffix)) return true; diff --git a/lldb/source/Plugins/Language/Fortran/FortranLanguage.h b/lldb/source/Plugins/Language/Fortran/FortranLanguage.h index b3958c2e8906e..fdb7df922aa88 100644 --- a/lldb/source/Plugins/Language/Fortran/FortranLanguage.h +++ b/lldb/source/Plugins/Language/Fortran/FortranLanguage.h @@ -5,11 +5,6 @@ // 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 @@ -33,7 +28,6 @@ class FortranLanguage : public Language { return lldb::eLanguageTypeFortran90; } - // Static Functions static void Initialize(); static void Terminate(); @@ -42,7 +36,6 @@ class FortranLanguage : public Language { static llvm::StringRef GetPluginNameStatic(); - // PluginInterface protocol llvm::StringRef GetPluginName() override; uint32_t GetPluginVersion(); diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp index f1466c4165c52..759401aae8f25 100644 --- a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.cpp @@ -5,15 +5,12 @@ // 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/Language.h" #include "lldb/Target/Target.h" using namespace lldb; @@ -23,20 +20,6 @@ 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; @@ -52,12 +35,11 @@ void TypeSystemFortran::Terminate() { PluginManager::UnregisterPlugin(CreateInstance); } -lldb::TypeSystemSP -TypeSystemFortran::CreateInstance(lldb::LanguageType language, Module *module, - Target *target) { - if (IsLanguageSupported(language)) { +TypeSystemSP TypeSystemFortran::CreateInstance(LanguageType language, + Module *module, Target *target) { + if (Language::LanguageIsFortran(language)) return std::make_shared<TypeSystemFortran>(); - } + return TypeSystemSP(); } @@ -77,5 +59,5 @@ LanguageSet TypeSystemFortran::GetSupportedLanguagesForExpressions() { } bool TypeSystemFortran::SupportsLanguage(lldb::LanguageType language) { - return IsLanguageSupported(language); + return Language::LanguageIsFortran(language); } diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h index 6291d4c8131dc..e5e26ac7eb097 100644 --- a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h @@ -5,11 +5,6 @@ // 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 @@ -356,8 +351,6 @@ class TypeSystemFortran : public TypeSystem { 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, @@ -412,12 +405,12 @@ class TypeSystemFortran : public TypeSystem { void Dump(llvm::raw_ostream &output, llvm::StringRef filter, bool show_color) override {} - /// This is used by swift. + /// 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. + // Pointer here means C-style pointers. bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override { @@ -491,4 +484,5 @@ class TypeSystemFortran : public TypeSystem { const TypeSystemFortran &operator=(const TypeSystemFortran &) = delete; }; } // namespace lldb_private + #endif // LLDB_SOURCE_PLUGINS_TYPESYSTEM_FORTRAN_TYPESYSTEMFORTRAN_H diff --git a/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp b/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp index d8d7287e0104c..c1fe22345d710 100644 --- a/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp +++ b/lldb/unittests/Language/Fortran/FortranLanguageTest.cpp @@ -5,11 +5,6 @@ // 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" @@ -20,21 +15,17 @@ 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 + const auto types = { + lldb::eLanguageTypeFortran77, lldb::eLanguageTypeFortran90, + lldb::eLanguageTypeFortran95, lldb::eLanguageTypeFortran03, + lldb::eLanguageTypeFortran08, lldb::eLanguageTypeFortran18}; + + for (lldb::LanguageType lang_type : types) { + Language *lang = Language::FindPlugin(lang_type); + ASSERT_NE(lang, nullptr); + EXPECT_EQ(lang->GetPluginName(), "fortran"); + } +} >From 9e0958882d898f749a78081b8fc5900549fe642a Mon Sep 17 00:00:00 2001 From: Iasonaskrpr <[email protected]> Date: Mon, 7 Sep 2026 17:54:17 +0300 Subject: [PATCH 4/4] [lldb][Fortran] Updated pointer comment --- lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h index e5e26ac7eb097..1db819bdbbad0 100644 --- a/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h +++ b/lldb/source/Plugins/TypeSystem/Fortran/TypeSystemFortran.h @@ -410,8 +410,7 @@ class TypeSystemFortran : public TypeSystem { return false; } - // Pointer here means C-style pointers. - + // Pointer here means C-style pointers, not Fortran-style. bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override { return false; _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
