Adapt lldb to the new swift weak reference representation.

include/lldb/Target/SwiftLanguageRuntime.h

@@ -354,7 +354,9 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   // to record useful runtime information
   // This API's task is to strip those bits if necessary and return
   // a pure pointer (or a tagged pointer)
-  lldb::addr_t MaybeMaskNonTrivialReferencePointer(lldb::addr_t);
+  lldb::addr_t MaybeMaskNonTrivialReferencePointer(
+      lldb::addr_t, 
+      SwiftASTContext::NonTriviallyManagedReferenceStrategy strategy);
 
   ConstString GetErrorBackstopName();
 

source/Plugins/Language/Swift/SwiftOptional.cpp

@@ -74,7 +74,8 @@ ExtractSomeIfAny(ValueObject *optional,
         lldb::addr_t original_ptr =
             value_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
         lldb::addr_t tweaked_ptr =
-            swift_runtime->MaybeMaskNonTrivialReferencePointer(original_ptr);
+            swift_runtime->MaybeMaskNonTrivialReferencePointer(original_ptr,
+                                                               strategy);
         if (original_ptr != tweaked_ptr) {
           CompilerType value_type(value_sp->GetCompilerType());
           DataBufferSP buffer_sp(

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

@@ -104,6 +104,8 @@ class AppleObjCRuntime : public lldb_private::ObjCLanguageRuntime {
 
   virtual void GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
                                             lldb::addr_t &cf_false);
+
+  virtual bool IsTaggedPointer (lldb::addr_t addr) { return false; }
 
 protected:
   // Call CreateInstance instead.

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

@@ -94,7 +94,7 @@ class AppleObjCRuntimeV2 : public AppleObjCRuntime {
 
   EncodingToTypeSP GetEncodingToType() override;
 
-  bool IsTaggedPointer(lldb::addr_t ptr);
+  bool IsTaggedPointer(lldb::addr_t ptr) override;
 
   TaggedPointerVendor *GetTaggedPointerVendor() override {
     return m_tagged_pointer_vendor_ap.get();

source/Target/SwiftLanguageRuntime.cpp

@@ -3327,8 +3327,16 @@ SwiftLanguageRuntime::MaskMaybeBridgedPointer(lldb::addr_t addr,
 }
 
 lldb::addr_t
-SwiftLanguageRuntime::MaybeMaskNonTrivialReferencePointer(lldb::addr_t addr) {
-  if (auto objc_runtime = GetObjCRuntime()) {
+SwiftLanguageRuntime::MaybeMaskNonTrivialReferencePointer(
+    lldb::addr_t addr,
+    SwiftASTContext::NonTriviallyManagedReferenceStrategy strategy) {
+
+  if (addr == 0)
+    return addr;
+
+  AppleObjCRuntime *objc_runtime = GetObjCRuntime();
+
+  if (objc_runtime) {
     // tagged pointers don't perform any masking
     if (objc_runtime->IsTaggedPointer(addr))
       return addr;
@@ -3372,16 +3380,77 @@ SwiftLanguageRuntime::MaybeMaskNonTrivialReferencePointer(lldb::addr_t addr) {
 
   lldb::addr_t mask = 0;
 
-  if (is_arm && is_64)
-    mask = SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS;
-  else if (is_intel && is_64)
-    mask = SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS;
-  else
-    mask = SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS;
+  if (strategy == SwiftASTContext::NonTriviallyManagedReferenceStrategy::eWeak) {
+    bool is_indirect = true;
+
+    // On non-objc platforms, the weak reference pointer always pointed to a
+    // runtime structure.
+    // For ObjC platforms, the masked value determines whether it is indirect.
+
+    uint32_t value = 0;
+
+    if (objc_runtime)
+    {
+
+      if (is_intel) {
+        if (is_64) {
+          mask = SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_MASK;
+          value = SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_VALUE;
+        } else {
+          mask = SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_MASK;
+          value = SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_VALUE;
+        }
+      } else if (is_arm) {
+        if (is_64) {
+            mask = SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_MASK;
+            value = SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_VALUE;
+        } else {
+            mask = SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_MASK;
+            value = SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_VALUE;
+        }
+      }
+    } else {
+        // This name is a little confusing. The "DEFAULT" marking in System.h
+        // is supposed to mean: the value for non-ObjC platforms.  So
+        // DEFAULT_OBJC here actually means "non-ObjC".
+        mask = SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_MASK;
+        value = SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_VALUE;
+    }
+
+    is_indirect = ((addr & mask) == value);
+
+    if (!is_indirect)
+      return addr;
+
+    // The masked value of address is a pointer to the runtime structure.
+    // The first field of the structure is the actual pointer.
+    Process *process = GetProcess();
+    Error error;
+
+    lldb::addr_t masked_addr = addr & ~mask;
+    lldb::addr_t isa_addr = process->ReadPointerFromMemory(masked_addr, error);
+    if (error.Fail())
+    {
+        // FIXME: do some logging here.
+        return addr;
+    }
+    return isa_addr;
+
+
+  } else {
+    if (is_arm && is_64)
+      mask = SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS;
+    else if (is_intel && is_64)
+      mask = SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS;
+    else
+      mask = SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS;
 
-  mask = (1 << mask) | (1 << (mask + 1));
+    mask = (1 << mask) | (1 << (mask + 1));
 
-  return addr & ~mask;
+    return addr & ~mask;
+  }
+
+  return addr;
 }
 
 ConstString SwiftLanguageRuntime::GetErrorBackstopName() {