[lldb][gnustep] Add minimal GNUstepObjCRuntime plugin for LanguageTypeObjC on non-Apple platforms

[sgraenitz]

Summary

This is the next patch after D146058. We can now parse expressions to print instance variables from ObjC classes. Until now the expression parser would bail out with an error like this:

error: expression failed to parse:
error: Error [IRForTarget]: Couldn't find Objective-C indirect ivar symbol OBJC_IVAR_$_TestObj._int

[theraven]

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

43

I'm not familiar with lldb internals, will this exclude ObjC++?

48

I never finished the v2 ABI support for Mach-O, but v1 works on Apple platforms and v2 will eventually. We definitely shouldn't be the default here, but it would be nice not to prevent it working on macOS.

132

I'm not sure how this is meant to work. I'd expect this to call one of the runtime's introspection functions. I believe the Apple version has variants of these that run without acquiring locks, which can be used in the debugger. We can add these quite easily if necessary.

lldb/test/Shell/Expr/objc-gnustep-print.m

84

It's not clear from this test if it's correctly computing the offsets. I suspect that it isn't, since I don't see any reference to the ivar offset variables.

[sgraenitz]

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

253

This was always declared in the header, but never implemented. Instead, AppleObjCRuntime had its own implementation -- I could make a follow-up patch to reuse it there as well:
https://github.com/llvm/llvm-project/blob/release/16.x/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp#L609-L622

lldb/test/Shell/Expr/objc-gnustep-print.m

72–78

This is missing the newly added members. I will fix it in the course of this review.

[sgraenitz]

Hi David, thanks for your notes. Please find responses inline.

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

43

Good question. There is also eLanguageTypeObjC_plus_plus, but the plugin scanner e.g. seems to use eLanguageTypeObjC for both. I'd like to keep it like that until I actually start testing ObjC++.

48

For the moment it would be nice to stay away from potential conflicts, since they won't make reviews easier. We can still add this later on if there is demand.

132

The Apple V2 runtime has two ways to do it: https://github.com/llvm/llvm-project/blob/release/16.x/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp#L1179 I experimented with the one that doesn't require void *gdb_class_getClass(void*) from the runtime library, but the JIT kept on crashing. So, for this first version I opted for a minimal implementation that doesn't do any selector checks. Let's look at it in another review.

lldb/test/Shell/Expr/objc-gnustep-print.m

84

What exactly would you expect to see in the output?

[aprantl]

In general I don't think I have a problem with adding this, especially since Clang also supports the runtime as a compilation target, and LLDB is tightly integrated with Clang.

[aprantl]

One thing I just realized — we need to make sure that we don't accidentally create a GNUstep ObjC runtime in a Swift process that was built without ObjC support on Linux. How can we ensure this works for both cases?

[aprantl]

I.e., can you detect based on the presence of a symbol or shared object that an GNUstep runtime is present?

[theraven]

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

132

Can you open bugs against the runtime for the gdb_* symbols that we need? I will add them.

The other method will crash on small objects because they don't have an isa pointer, their isa is in the low 1-3 bits of the object pointer, indexing into a table in the runtime.

lldb/test/Shell/Expr/objc-gnustep-print.m

84

If the offsets are all wrong, this will still work if it happens to land within zeroed memory, which is quite likely. It would be good to have a method that set all of the ivars to something and then check for those values explicitly. Or check for (char*)t->{ivar} - (char*)t and make sure that this is the right value (this will change between 32/64/128-bit platforms).

[sgraenitz]

In D146154#4197454, @aprantl wrote:

One thing I just realized — we need to make sure that we don't accidentally create a GNUstep ObjC runtime in a Swift process that was built without ObjC support on Linux.

Yes, thanks for bringing this up. The goal definitely is to avoid any accidental conflicts with existing use cases that don't need or expect a GNUstep runtime. I really want to get my focus to the Windows side and PDB parsing. It's useful to have Linux working as well, so that we have a testable feature set to match. Otherwise, we don't want to invest a lot of effort here yet.

How can we ensure this works for both cases?

Shouldn't the Swift processes report eLanguageTypeSwift? Then GNUstepObjCRuntime::CreateInstance() rejects it reliably.

I.e., can you detect based on the presence of a symbol or shared object that an GNUstep runtime is present?

Are there existing cases that follow such an approach? Looking at the order of events here, it appears that we have to wait for ModulesDidLoad() to report the shared library before we can inspect its symbols. How would we proceed if we want to create the language runtime first? I.e. here https://github.com/llvm/llvm-project/blob/release/16.x/lldb/source/Target/Process.cpp#L5727-L5732

The shared library has a GNUstep-specific EH personality for example, would that do?

> llvm-nm libobjc2/build/libobjc.so | grep gnustep_objc
00000000000264c0 T __gnustep_objc_personality_v0
0000000000026500 T __gnustep_objcxx_personality_v0

[sgraenitz]

Extend the test to check both, zero initialization and assigned ivars

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

132

Sure https://github.com/gnustep/libobjc2/issues/244

lldb/test/Shell/Expr/objc-gnustep-print.m

84

Ok, updated the test. I only checked on 64-bit, but it should support arbitrary pointer widths. Can we skip the test for ivar offset distance? I'd like to avoid testing the actual memory layout here.

[theraven]

The test looks fine to me, I'm quite surprised that it passes.

[aprantl]

In D146154#4198730, @sgraenitz wrote:

In D146154#4197454, @aprantl wrote:

One thing I just realized — we need to make sure that we don't accidentally create a GNUstep ObjC runtime in a Swift process that was built without ObjC support on Linux.

Yes, thanks for bringing this up. The goal definitely is to avoid any accidental conflicts with existing use cases that don't need or expect a GNUstep runtime. I really want to get my focus to the Windows side and PDB parsing. It's useful to have Linux working as well, so that we have a testable feature set to match. Otherwise, we don't want to invest a lot of effort here yet.

How can we ensure this works for both cases?

Shouldn't the Swift processes report eLanguageTypeSwift? Then GNUstepObjCRuntime::CreateInstance() rejects it reliably.

I'm not sure where eLanguageType being passed in here comes from. Generally for Swift processes with (Apple) Objective-C interoperability enabled, it is the expected case to have both a Swift and an Objective-C runtime in the same process.

I.e., can you detect based on the presence of a symbol or shared object that an GNUstep runtime is present?

Are there existing cases that follow such an approach? Looking at the order of events here, it appears that we have to wait for ModulesDidLoad() to report the shared library before we can inspect its symbols. How would we proceed if we want to create the language runtime first? I.e. here https://github.com/llvm/llvm-project/blob/release/16.x/lldb/source/Target/Process.cpp#L5727-L5732

The shared library has a GNUstep-specific EH personality for example, would that do?

> llvm-nm libobjc2/build/libobjc.so | grep gnustep_objc
00000000000264c0 T __gnustep_objc_personality_v0
0000000000026500 T __gnustep_objcxx_personality_v0

I think that would be a great way to guard against false positives!

[aprantl]

Here is an example of how the Swift Runtime plugin detects both itself and whether ObjC interop is enabled. Basically all I'm asking is to not accidentally break this mechanism.
https://github.com/apple/llvm-project/blob/7750ffa35111df6d38a5c73ab7e78ccebc9b43c3/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp#L124
If you want to make 100% sure, you could checkout the Swift compiler on Linux (or I suppose Windows) from github.com/apple/swift run swift/utils/update-checkout --clone apply your patch to llvm-project and run swift/utils/build-script --lldb --test -- --skip-build-benchmarks --skip-test-cmark --skip-test-swift and make sure the lldb tests still pass after applying you patch. But if you check for the symbol that would be sufficient for me.

[sgraenitz]

Check for GNUstep EH personality in ELF targets and __objc_load on native Windows

[sgraenitz]

In D146154#4203277, @aprantl wrote:

Here is an example of how the Swift Runtime plugin detects both itself and whether ObjC interop is enabled. Basically all I'm asking is to not accidentally break this mechanism.

Thanks for the link! I think Swift is doing the exact right thing here: it requests the Apple ObjC V2 runtime explicitly in https://github.com/apple/llvm-project/blob/fcf8f57c74defcc0c422331cb90a3b9dd8d7b476/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp#L102-L106

Anyway, I updated my patch to do the symbol lookup, because the pure presence of an ObjC runtime makes for some interesting regressions in the test suite. E.g. here we enable ObjC in C++ code if the runtime exists:

lang_opts.ObjC =
    process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC) != nullptr;

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

62

There is no EH personality on Windows so I am checking for a core ObjC runtime symbol. Hope that's ok?
I put a list with all DLL symbols here: https://gist.github.com/weliveindetail/0c57135741b314d2952236bcffae0ab1

[aprantl]

Thanks for adding the check!

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

185

Do you have access to the target triple here? Might want to only check for the strings based on the the OS?

[sgraenitz]

Make shared library name checks OS-dependent

[sgraenitz]

Thanks for reviewing! I will land this as soon as the previous review is ready.

[sgraenitz]

Rebase

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (clang_expr && clang_expr->DidImportCxxModules()) {
     lang_opts.GNUCVersion = 40201;
 
     SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
                            target_sp);
   }
 
   if (process_sp && lang_opts.ObjC) {
     if (auto *runtime = ObjCLanguageRuntime::Get(*process_sp)) {
-      if (runtime->GetRuntimeVersion() ==
-          ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2)
+      switch (runtime->GetRuntimeVersion()) {
+      case ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2:
         lang_opts.ObjCRuntime.set(ObjCRuntime::MacOSX, VersionTuple(10, 7));
-      else
+        break;
+      case ObjCLanguageRuntime::ObjCRuntimeVersions::eObjC_VersionUnknown:
+      case ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V1:
         lang_opts.ObjCRuntime.set(ObjCRuntime::FragileMacOSX,
                                   VersionTuple(10, 7));
+        break;
+      case ObjCLanguageRuntime::ObjCRuntimeVersions::eGNUstep_libobjc2:
+        lang_opts.ObjCRuntime.set(ObjCRuntime::GNUstep, VersionTuple(2, 0));
+        break;
+      }
 
       if (runtime->HasNewLiteralsAndIndexing())
         lang_opts.DebuggerObjCLiteral = true;
     }
   }
 
   lang_opts.ThreadsafeStatics = false;
   lang_opts.AccessControl = false; // Debuggers get universal access

lldb/source/Plugins/LanguageRuntime/ObjC/CMakeLists.txt

 add_lldb_library(lldbPluginObjCRuntime
   ObjCLanguageRuntime.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     lldbUtility
 )
+
 add_subdirectory(AppleObjCRuntime)
+add_subdirectory(GNUstepObjCRuntime)

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/CMakeLists.txt

+add_lldb_library(lldbPluginGNUstepObjCRuntime PLUGIN
+  GNUstepObjCRuntime.cpp
+
+  LINK_LIBS
+    lldbBreakpoint
+    lldbCore
+    lldbExpression
+    lldbHost
+    lldbInterpreter
+    lldbSymbol
+    lldbTarget
+    lldbUtility
+    lldbPluginExpressionParserClang
+    lldbPluginTypeSystemClang
+  CLANG_LIBS
+    clangAST
+  LINK_COMPONENTS
+    Support
+  )

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.h

+//===-- GNUstepObjCRuntime.h ------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_GNUSTEPOBJCRUNTIME_GNUSTEPOBJCRUNTIME_H
+#define LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_GNUSTEPOBJCRUNTIME_GNUSTEPOBJCRUNTIME_H
+
+#include "lldb/Target/LanguageRuntime.h"
+#include "lldb/lldb-private.h"
+
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+
+#include <optional>
+
+namespace lldb_private {
+
+class GNUstepObjCRuntime : public lldb_private::ObjCLanguageRuntime {
+public:
+  ~GNUstepObjCRuntime() override;
+
+  //
+  //  PluginManager, PluginInterface and LLVM RTTI implementation
+  //
+
+  static char ID;
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb_private::LanguageRuntime *
+  CreateInstance(Process *process, lldb::LanguageType language);
+
+  static llvm::StringRef GetPluginNameStatic() {
+    return "gnustep-objc-libobjc2";
+  }
+
+  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
+
+  void ModulesDidLoad(const ModuleList &module_list) override;
+
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || ObjCLanguageRuntime::isA(ClassID);
+  }
+
+  static bool classof(const LanguageRuntime *runtime) {
+    return runtime->isA(&ID);
+  }
+
+  //
+  // LanguageRuntime implementation
+  //
+  bool GetObjectDescription(Stream &str, Value &value,
+                            ExecutionContextScope *exe_scope) override;
+
+  bool GetObjectDescription(Stream &str, ValueObject &object) override;
+
+  bool CouldHaveDynamicValue(ValueObject &in_value) override;
+
+  bool GetDynamicTypeAndAddress(ValueObject &in_value,
+                                lldb::DynamicValueType use_dynamic,
+                                TypeAndOrName &class_type_or_name,
+                                Address &address,
+                                Value::ValueType &value_type) override;
+
+  TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
+                                 ValueObject &static_value) override;
+
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp,
+                          bool throw_bp) override;
+
+  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
+                                                  bool stop_others) override;
+
+  //
+  // ObjCLanguageRuntime implementation
+  //
+
+  bool IsModuleObjCLibrary(const lldb::ModuleSP &module_sp) override;
+
+  bool ReadObjCLibrary(const lldb::ModuleSP &module_sp) override;
+
+  bool HasReadObjCLibrary() override { return m_objc_module_sp != nullptr; }
+
+  llvm::Expected<std::unique_ptr<UtilityFunction>>
+  CreateObjectChecker(std::string name, ExecutionContext &exe_ctx) override;
+
+  ObjCRuntimeVersions GetRuntimeVersion() const override {
+    return ObjCRuntimeVersions::eGNUstep_libobjc2;
+  }
+
+  void UpdateISAToDescriptorMapIfNeeded() override;
+
+protected:
+  // Call CreateInstance instead.
+  GNUstepObjCRuntime(Process *process);
+
+  lldb::ModuleSP m_objc_module_sp;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_GNUSTEPOBJCRUNTIME_GNUSTEPOBJCRUNTIME_H

lldb/source/Plugins/LanguageRuntime/ObjC/GNUstepObjCRuntime/GNUstepObjCRuntime.cpp

+//===-- GNUstepObjCRuntime.cpp --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "GNUstepObjCRuntime.h"
+
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/ConstString.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+LLDB_PLUGIN_DEFINE(GNUstepObjCRuntime)
+
+char GNUstepObjCRuntime::ID = 0;
+
+void GNUstepObjCRuntime::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "GNUstep Objective-C Language Runtime - libobjc2",
+      CreateInstance);
+}
+
+void GNUstepObjCRuntime::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+LanguageRuntime *GNUstepObjCRuntime::CreateInstance(Process *process,
+                                                    LanguageType language) {
+  if (language != eLanguageTypeObjC)
+    return nullptr;
+  if (!process)
+    return nullptr;
+
+  Target &target = process->GetTarget();
+  const llvm::Triple &TT = target.GetArchitecture().GetTriple();
+  if (TT.getVendor() == llvm::Triple::VendorType::Apple)
+    return nullptr;
+
+  const ModuleList &images = target.GetImages();
+  if (TT.isOSBinFormatELF()) {
+    SymbolContextList eh_pers;
+    RegularExpression regex("__gnustep_objc[x]*_personality_v[0-9]+");
+    images.FindSymbolsMatchingRegExAndType(regex, eSymbolTypeCode, eh_pers);
+    if (eh_pers.GetSize() == 0)
+      return nullptr;
+  } else if (TT.isOSWindows()) {
+    SymbolContextList objc_mandatory;
+    images.FindSymbolsWithNameAndType(ConstString("__objc_load"),
+                                      eSymbolTypeCode, objc_mandatory);
+    if (objc_mandatory.GetSize() == 0)
+      return nullptr;
+  }
+
+  return new GNUstepObjCRuntime(process);
+}
+
+GNUstepObjCRuntime::~GNUstepObjCRuntime() = default;
+
+GNUstepObjCRuntime::GNUstepObjCRuntime(Process *process)
+    : ObjCLanguageRuntime(process), m_objc_module_sp(nullptr) {
+  ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
+}
+
+bool GNUstepObjCRuntime::GetObjectDescription(Stream &str,
+                                              ValueObject &valobj) {
+  // TODO: ObjC has a generic way to do this
+  return false;
+}
+bool GNUstepObjCRuntime::GetObjectDescription(
+    Stream &strm, Value &value, ExecutionContextScope *exe_scope) {
+  // TODO: ObjC has a generic way to do this
+  return false;
+}
+
+bool GNUstepObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
+  static constexpr bool check_cxx = false;
+  static constexpr bool check_objc = true;
+  return in_value.GetCompilerType().IsPossibleDynamicType(nullptr, check_cxx,
+                                                          check_objc);
+}
+
+bool GNUstepObjCRuntime::GetDynamicTypeAndAddress(
+    ValueObject &in_value, DynamicValueType use_dynamic,
+    TypeAndOrName &class_type_or_name, Address &address,
+    Value::ValueType &value_type) {
+  return false;
+}
+
+TypeAndOrName
+GNUstepObjCRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
+                                     ValueObject &static_value) {
+  CompilerType static_type(static_value.GetCompilerType());
+  Flags static_type_flags(static_type.GetTypeInfo());
+
+  TypeAndOrName ret(type_and_or_name);
+  if (type_and_or_name.HasType()) {
+    // The type will always be the type of the dynamic object.  If our parent's
+    // type was a pointer, then our type should be a pointer to the type of the
+    // dynamic object.  If a reference, then the original type should be
+    // okay...
+    CompilerType orig_type = type_and_or_name.GetCompilerType();
+    CompilerType corrected_type = orig_type;
+    if (static_type_flags.AllSet(eTypeIsPointer))
+      corrected_type = orig_type.GetPointerType();
+    ret.SetCompilerType(corrected_type);
+  } else {
+    // If we are here we need to adjust our dynamic type name to include the
+    // correct & or * symbol
+    std::string corrected_name(type_and_or_name.GetName().GetCString());
+    if (static_type_flags.AllSet(eTypeIsPointer))
+      corrected_name.append(" *");
+    // the parent type should be a correctly pointer'ed or referenc'ed type
+    ret.SetCompilerType(static_type);
+    ret.SetName(corrected_name.c_str());
+  }
+  return ret;
+}
+
+BreakpointResolverSP
+GNUstepObjCRuntime::CreateExceptionResolver(const BreakpointSP &bkpt,
+                                            bool catch_bp, bool throw_bp) {
+  BreakpointResolverSP resolver_sp;
+
+  if (throw_bp)
+    resolver_sp = std::make_shared<BreakpointResolverName>(
+        bkpt, "objc_exception_throw", eFunctionNameTypeBase,
+        eLanguageTypeUnknown, Breakpoint::Exact, 0, eLazyBoolNo);
+
+  return resolver_sp;
+}
+
+llvm::Expected<std::unique_ptr<UtilityFunction>>
+GNUstepObjCRuntime::CreateObjectChecker(std::string name,
+                                        ExecutionContext &exe_ctx) {
+  // TODO: This function is supposed to check whether an ObjC selector is
+  // present for an object. Might be implemented similar as in the Apple V2
+  // runtime.
+  const char *function_template = R"(
+    extern "C" void
+    %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) {}
+  )";
+
+  char empty_function_code[2048];
+  int len = ::snprintf(empty_function_code, sizeof(empty_function_code),
+                       function_template, name.c_str());
+
+  assert(len < (int)sizeof(empty_function_code));
+  UNUSED_IF_ASSERT_DISABLED(len);
+
+  return GetTargetRef().CreateUtilityFunction(empty_function_code, name,
+                                              eLanguageTypeC, exe_ctx);
+}
+
+ThreadPlanSP
+GNUstepObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread,
+                                                 bool stop_others) {
+  // TODO: Implement this properly to avoid stepping into things like PLT stubs
+  return nullptr;
+}
+
+void GNUstepObjCRuntime::UpdateISAToDescriptorMapIfNeeded() {
+  // TODO: Support lazily named and dynamically loaded Objective-C classes
+}
+
+bool GNUstepObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) {
+  if (!module_sp)
+    return false;
+  const FileSpec &module_file_spec = module_sp->GetFileSpec();
+  if (!module_file_spec)
+    return false;
+  llvm::StringRef filename = module_file_spec.GetFilename().GetStringRef();
+  return filename.starts_with("libobjc.so") || filename == "objc.dll";
+}
+
+bool GNUstepObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) {
+  assert(m_objc_module_sp == nullptr && "Check HasReadObjCLibrary() first");
+  m_objc_module_sp = module_sp;
+
+  // Right now we don't use this, but we might want to check for debugger
+  // runtime support symbols like 'gdb_object_getClass' in the future.
+  return true;
+}
+
+void GNUstepObjCRuntime::ModulesDidLoad(const ModuleList &module_list) {
+  ReadObjCLibraryIfNeeded(module_list);
+}

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

 class TypeSystemClang;
 class UtilityFunction;
 
 class ObjCLanguageRuntime : public LanguageRuntime {
 public:
   enum class ObjCRuntimeVersions {
     eObjC_VersionUnknown = 0,
     eAppleObjC_V1 = 1,
-    eAppleObjC_V2 = 2
+    eAppleObjC_V2 = 2,
+    eGNUstep_libobjc2 = 3,
   };
 
   typedef lldb::addr_t ObjCISA;
 
   class ClassDescriptor;
   typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP;
 
   // the information that we want to support retrieving from an ObjC class this

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

ObjCLanguageRuntime::GetDescriptorIteratorPair(bool update_if_needed) {
   if (update_if_needed)
     UpdateISAToDescriptorMapIfNeeded();
 
   return std::pair<ObjCLanguageRuntime::ISAToDescriptorIterator,
                    ObjCLanguageRuntime::ISAToDescriptorIterator>(
       m_isa_to_descriptor.begin(), m_isa_to_descriptor.end());
 }
 
+void ObjCLanguageRuntime::ReadObjCLibraryIfNeeded(
+    const ModuleList &module_list) {
+  if (!HasReadObjCLibrary()) {
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
+
+    size_t num_modules = module_list.GetSize();
+    for (size_t i = 0; i < num_modules; i++) {
+      auto mod = module_list.GetModuleAtIndex(i);
+      if (IsModuleObjCLibrary(mod)) {
+        ReadObjCLibrary(mod);
+        break;
+      }
+    }
+  }
+}
+
 ObjCLanguageRuntime::ObjCISA
 ObjCLanguageRuntime::GetParentClass(ObjCLanguageRuntime::ObjCISA isa) {
   ClassDescriptorSP objc_class_sp(GetClassDescriptorFromISA(isa));
   if (objc_class_sp) {
     ClassDescriptorSP objc_super_class_sp(objc_class_sp->GetSuperclass());
     if (objc_super_class_sp)
       return objc_super_class_sp->GetISA();
   }

lldb/test/Shell/Expr/objc-gnustep-print.m

 - (id)class {
   return object_getClass(self);
 }
 + (id)new {
   return class_createInstance(self, 0);
 }
 @end
 
-@interface TestObj : NSObject {}
-- (int)ok;
+@interface TestObj : NSObject {
+  int _int;
+  float _float;
+  char _char;
+  void *_ptr_void;
+  NSObject *_ptr_nsobject;
+  id _id_objc;
+}
+- (void)check_ivars_zeroed;
+- (void)set_ivars;
 @end
 @implementation TestObj
-- (int)ok {
-  return self ? 0 : 1;
+- (void)check_ivars_zeroed {
+  ;
+}
+- (void)set_ivars {
+  _int = 1;
+  _float = 2.0f;
+  _char = '\3';
+  _ptr_void = (void*)4;
+  _ptr_nsobject = (NSObject*)5;
+  _id_objc = (id)6;
 }
 @end
 
-// RUN: %lldb -b -o "b objc-gnustep-print.m:35" -o "run" -o "p self" -o "p *self" -- %t | FileCheck %s --check-prefix=SELF
+// RUN: %lldb -b -o "b objc-gnustep-print.m:43" -o "run" -o "p self" -o "p *self" -- %t | FileCheck %s --check-prefix=SELF
 //
-// SELF: (lldb) b objc-gnustep-print.m:35
+// SELF: (lldb) b objc-gnustep-print.m:43
 // SELF: Breakpoint {{.*}} at objc-gnustep-print.m
 //
 // SELF: (lldb) run
 // SELF: Process {{[0-9]+}} stopped
-// SELF: -[TestObj ok](self=[[SELF_PTR:0x[0-9]+]]{{.*}}) at objc-gnustep-print.m:35
+// SELF: -[TestObj check_ivars_zeroed](self=[[SELF_PTR:0x[0-9]+]]{{.*}}) at objc-gnustep-print.m
 //
 // SELF: (lldb) p self
 // SELF: (TestObj *) $0 = [[SELF_PTR]]
 //
 // SELF: (lldb) p *self
 // SELF: (TestObj) $1 = {
 // SELF:   NSObject = {
 // SELF:     isa
 // SELF:     refcount
 // SELF:   }
+// SELF:   _int = 0
+// SELF:   _float = 0
+// SELF:   _char = '\0'
+// SELF:   _ptr_void = 0x{{0*}}
+// SELF:   _ptr_nsobject = nil
+// SELF:   _id_objc = nil
 // SELF: }
 
+// RUN: %lldb -b -o "b objc-gnustep-print.m:106" -o "run" -o "p t->_int" -o "p t->_float" -o "p t->_char" \
+// RUN:          -o "p t->_ptr_void" -o "p t->_ptr_nsobject" -o "p t->_id_objc" -- %t | FileCheck %s --check-prefix=IVARS_SET
+//
+// IVARS_SET: (lldb) p t->_int
+// IVARS_SET: (int) $0 = 1
+//
+// IVARS_SET: (lldb) p t->_float
+// IVARS_SET: (float) $1 = 2
+//
+// IVARS_SET: (lldb) p t->_char
+// IVARS_SET: (char) $2 = '\x03'
+//
+// IVARS_SET: (lldb) p t->_ptr_void
+// IVARS_SET: (void *) $3 = 0x{{0*}}4
+//
+// IVARS_SET: (lldb) p t->_ptr_nsobject
+// IVARS_SET: (NSObject *) $4 = 0x{{0*}}5
+//
+// IVARS_SET: (lldb) p t->_id_objc
+// IVARS_SET: (id) $5 = 0x{{0*}}6
+
 int main() {
   TestObj *t = [TestObj new];
-  return [t ok];
+  [t check_ivars_zeroed];
+  [t set_ivars];
+  return 0;
 }