add swift-use-reflection-symbols experimental setting (default true)

Author: kastiglione

lldb/include/lldb/Target/Target.h

@@ -173,6 +173,8 @@ class TargetProperties : public Properties {
 
   bool GetSwiftReadMetadataFromFileCache() const;
 
+  bool GetSwiftUseReflectionSymbols() const;
+
   bool GetEnableAutoImportClangModules() const;
 
   bool GetUseAllCompilerFlags() const;

lldb/source/Plugins/LanguageRuntime/Swift/LLDBMemoryReader.cpp

@@ -127,20 +127,28 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   // by loading other parts of reflection metadata, but that work has a cost.
   // For lldb, that data loading can be a significant performance hit. Providing
   // a symbol greatly reduces memory read traffic to the process.
-  Address addr;
+  auto pointer = swift::remote::RemoteAbsolutePointer("", readValue);
+
   auto &target = m_process.GetTarget();
-  if (target.ResolveLoadAddress(address.getAddressData(), addr))
-    if (addr.GetSection()->CanContainSwiftReflectionData())
-      if (auto *symbol = addr.CalculateSymbolContextSymbol()) {
-        auto mangledName = symbol->GetMangled().GetMangledName().GetStringRef();
-        // MemoryReader requires this to be a Swift symbol. LLDB can also be
-        // aware of local symbols, so avoid returning those.
-        if (swift::Demangle::isSwiftSymbol(mangledName))
-          return {mangledName, 0};
-      }
+  if (!target.GetSwiftUseReflectionSymbols())
+    return pointer;
+
+  Address addr;
+  if (!target.ResolveLoadAddress(address.getAddressData(), addr))
+    return pointer;
+
+  if (!addr.GetSection()->CanContainSwiftReflectionData())
+    return pointer;
+
+  if (auto *symbol = addr.CalculateSymbolContextSymbol()) {
+    auto mangledName = symbol->GetMangled().GetMangledName().GetStringRef();
+    // MemoryReader requires this to be a Swift symbol. LLDB can also be
+    // aware of local symbols, so avoid returning those.
+    if (swift::Demangle::isSwiftSymbol(mangledName))
+      return {mangledName, 0};
+  }
 
-  // Return the read value as is.
-  return {"", (int64_t)readValue};
+  return pointer;
 }
 
 bool LLDBMemoryReader::readBytes(swift::remote::RemoteAddress address,

lldb/source/Target/Target.cpp

@@ -4168,6 +4168,18 @@ bool TargetProperties::GetSwiftReadMetadataFromFileCache() const {
   return true;
 }
 
+bool TargetProperties::GetSwiftUseReflectionSymbols() const {
+  const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
+      nullptr, false, ePropertyExperimental);
+  OptionValueProperties *exp_values =
+      exp_property->GetValue()->GetAsProperties();
+  if (exp_values)
+    return exp_values->GetPropertyAtIndexAsBoolean(
+        nullptr, ePropertySwiftUseReflectionSymbols, true);
+  else
+    return true;
+}
+
 ArchSpec TargetProperties::GetDefaultArchitecture() const {
   OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
       nullptr, ePropertyDefaultArch);

lldb/source/Target/TargetProperties.td

@@ -10,6 +10,9 @@ let Definition = "target_experimental" in {
   def SwiftReadMetadataFromFileCache: Property<"swift-read-metadata-from-file-cache", "Boolean">,
     DefaultTrue,
     Desc<"Read Swift reflection metadata from the file cache instead of the process when possible">;
+  def SwiftUseReflectionSymbols : Property<"swift-use-reflection-symbols", "Boolean">,
+    Global, DefaultTrue,
+    Desc<"if true, optimize the loading of Swift reflection metadata by making use of available symbols.">;
 }
 
 let Definition = "target" in {