[lldb] Add a setting to specify the preferred dynamic class info extractor function

[JDevlieghere]

Summary

Add a setting to specify the preferred dynamic class info extractor function.

[aprantl]

lldb/source/Target/TargetProperties.td

57

Should this have "objc" in the name?

60

Configure how LLDB parses dynamic Objective-C class metadata. By default LLDB will choose the most appropriate method for the target OS.

[aprantl]

Patch looks fine. Wording suggestion for the user-visible parts inside.

[JDevlieghere]

Adress Adrian's code review feedback

lldb/include/lldb/Target/Target.h

 };
 
 enum ImportStdModule {
   eImportStdModuleFalse,
   eImportStdModuleFallback,
   eImportStdModuleTrue,
 };
 
+enum DynamicClassInfoHelper {
+  eDynamicClassInfoHelperAuto,
+  eDynamicClassInfoHelperRealizedClassesStruct,
+  eDynamicClassInfoHelperCopyRealizedClassList,
+  eDynamicClassInfoHelperGetRealizedClassList,
+};
+
 class TargetExperimentalProperties : public Properties {
 public:
   TargetExperimentalProperties();
 };
 
 class TargetProperties : public Properties {
 public:
   TargetProperties(Target *target);
public:
   FileSpecList GetDebugFileSearchPaths();
 
   FileSpecList GetClangModuleSearchPaths();
 
   bool GetEnableAutoImportClangModules() const;
 
   ImportStdModule GetImportStdModule() const;
 
+  DynamicClassInfoHelper GetDynamicClassInfoHelper() const;
+
   bool GetEnableAutoApplyFixIts() const;
 
   uint64_t GetNumberOfRetriesWithFixits() const;
 
   bool GetEnableNotifyAboutFixIts() const;
 
   FileSpec GetSaveJITObjectsDir() const;
   

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

enum Helper {
       objc_copyRealizedClassList,
       objc_getRealizedClassList_trylock
     };
 
     /// Compute which helper to use. If dyld is not yet fully initialized we
     /// must use gdb_objc_realized_classes. Otherwise, we prefer
     /// objc_getRealizedClassList_trylock and objc_copyRealizedClassList
     /// respectively, depending on availability.
-    Helper ComputeHelper() const;
+    Helper ComputeHelper(ExecutionContext &exe_ctx) const;
 
     UtilityFunction *GetClassInfoUtilityFunction(ExecutionContext &exe_ctx,
                                                  Helper helper);
     lldb::addr_t &GetClassInfoArgs(Helper helper);
 
     std::unique_ptr<UtilityFunction>
     GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx, Helper helper,
                                     std::string code, std::string name);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

case objc_copyRealizedClassList:
     return m_objc_copyRealizedClassList_helper.args;
   case objc_getRealizedClassList_trylock:
     return m_objc_getRealizedClassList_trylock_helper.args;
   }
   llvm_unreachable("Unexpected helper");
 }
 
 AppleObjCRuntimeV2::DynamicClassInfoExtractor::Helper
-AppleObjCRuntimeV2::DynamicClassInfoExtractor::ComputeHelper() const {
+AppleObjCRuntimeV2::DynamicClassInfoExtractor::ComputeHelper(
+    ExecutionContext &exe_ctx) const {
   if (!m_runtime.m_has_objc_copyRealizedClassList &&
       !m_runtime.m_has_objc_getRealizedClassList_trylock)
     return DynamicClassInfoExtractor::gdb_objc_realized_classes;
 
   if (Process *process = m_runtime.GetProcess()) {
     if (DynamicLoader *loader = process->GetDynamicLoader()) {
       if (loader->IsFullyInitialized()) {
+        switch (exe_ctx.GetTargetRef().GetDynamicClassInfoHelper()) {
+        case eDynamicClassInfoHelperAuto:
+          [[clang::fallthrough]];
+        case eDynamicClassInfoHelperGetRealizedClassList:
           if (m_runtime.m_has_objc_getRealizedClassList_trylock)
             return DynamicClassInfoExtractor::objc_getRealizedClassList_trylock;
+          [[clang::fallthrough]];
+        case eDynamicClassInfoHelperCopyRealizedClassList:
           if (m_runtime.m_has_objc_copyRealizedClassList)
             return DynamicClassInfoExtractor::objc_copyRealizedClassList;
+          [[clang::fallthrough]];
+        case eDynamicClassInfoHelperRealizedClassesStruct:
+          return DynamicClassInfoExtractor::gdb_objc_realized_classes;
+        }
       }
     }
   }
 
   return DynamicClassInfoExtractor::gdb_objc_realized_classes;
 }
 
 std::unique_ptr<UtilityFunction>
AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(
 
   Address function_address;
 
   const uint32_t addr_size = process->GetAddressByteSize();
 
   Status err;
 
   // Compute which helper we're going to use for this update.
-  const DynamicClassInfoExtractor::Helper helper = ComputeHelper();
+  const DynamicClassInfoExtractor::Helper helper = ComputeHelper(exe_ctx);
 
   // Read the total number of classes from the hash table
   const uint32_t num_classes =
       helper == DynamicClassInfoExtractor::gdb_objc_realized_classes
           ? hash_table.GetCount()
           : m_runtime.m_realized_class_generation_count;
   if (num_classes == 0) {
     LLDB_LOGF(log, "No dynamic classes found.");

lldb/source/Target/Target.cpp

static constexpr OptionEnumValueElement g_import_std_module_value_types[] = {
         eImportStdModuleTrue,
         "true",
         "Always import the 'std' C++ module. This allows evaluating more "
         "complex expressions involving C++ standard library types. This feature"
         " is experimental."
     },
 };
 
+static constexpr OptionEnumValueElement
+    g_dynamic_class_info_helper_value_types[] = {
+        {
+            eDynamicClassInfoHelperAuto,
+            "auto",
+            "Automatically determine the most appropriate method for the "
+            "target OS.",
+        },
+        {eDynamicClassInfoHelperRealizedClassesStruct, "RealizedClassesStruct",
+         "Prefer using the realized classes struct."},
+        {eDynamicClassInfoHelperCopyRealizedClassList, "CopyRealizedClassList",
+         "Prefer using the CopyRealizedClassList API."},
+        {eDynamicClassInfoHelperGetRealizedClassList, "GetRealizedClassList",
+         "Prefer using the GetRealizedClassList API."},
+};
+
 static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = {
     {
         Disassembler::eHexStyleC,
         "c",
         "C-style (0xffff).",
     },
     {
         Disassembler::eHexStyleAsm,

 }
 
 ImportStdModule TargetProperties::GetImportStdModule() const {
   const uint32_t idx = ePropertyImportStdModule;
   return (ImportStdModule)m_collection_sp->GetPropertyAtIndexAsEnumeration(
       nullptr, idx, g_target_properties[idx].default_uint_value);
 }
 
+DynamicClassInfoHelper TargetProperties::GetDynamicClassInfoHelper() const {
+  const uint32_t idx = ePropertyDynamicClassInfoHelper;
+  return (DynamicClassInfoHelper)
+      m_collection_sp->GetPropertyAtIndexAsEnumeration(
+          nullptr, idx, g_target_properties[idx].default_uint_value);
+}
+
 bool TargetProperties::GetEnableAutoApplyFixIts() const {
   const uint32_t idx = ePropertyAutoApplyFixIts;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_target_properties[idx].default_uint_value != 0);
 }
 
 uint64_t TargetProperties::GetNumberOfRetriesWithFixits() const {
   const uint32_t idx = ePropertyRetriesWithFixIts;

lldb/source/Target/TargetProperties.td

let Definition = "target" in {
   def AutoImportClangModules: Property<"auto-import-clang-modules", "Boolean">,
     DefaultTrue,
     Desc<"Automatically load Clang modules referred to by the program.">;
   def ImportStdModule: Property<"import-std-module", "Enum">,
     DefaultEnumValue<"eImportStdModuleFalse">,
     EnumValues<"OptionEnumValues(g_import_std_module_value_types)">,
     Desc<"Import the 'std' C++ module to improve expression parsing involving "
          " C++ standard library types.">;
+  def DynamicClassInfoHelper: Property<"objc-dynamic-class-extractor", "Enum">,
+    DefaultEnumValue<"eDynamicClassInfoHelperAuto">,
+    EnumValues<"OptionEnumValues(g_dynamic_class_info_helper_value_types)">,
+    Desc<"Configure how LLDB parses dynamic Objective-C class metadata. By default LLDB will choose the most appropriate method for the target OS.">;
   def AutoApplyFixIts: Property<"auto-apply-fixits", "Boolean">,
     DefaultTrue,
     Desc<"Automatically apply fix-it hints to expressions.">;
   def RetriesWithFixIts: Property<"retries-with-fixits", "UInt64">,
     DefaultUnsignedValue<1>,
     Desc<"Maximum number of attempts to fix an expression with Fix-Its">;
   def NotifyAboutFixIts: Property<"notify-about-fixits", "Boolean">,
     DefaultTrue,