Store pointer to data directly in Rc and Arc

Author: EFanZh

library/alloc/src/rc.rs

@@ -180,12 +180,22 @@ def children(self):
     def display_hint():
         return "array"
 
+BYTE_PTR_TYPE = gdb.lookup_type("u8").pointer()
 
 class StdRcProvider(printer_base):
     def __init__(self, valobj, is_atomic=False):
+        def inner_ptr():
+            data_ptr = unwrap_unique_or_non_null(valobj["ptr"])
+            formatter = "alloc::sync::ArcInner<{}>" if is_atomic else "alloc::rc::RcInner<{}>"
+            inner_type = gdb.lookup_type(formatter.format(data_ptr.type.target().name))
+            data_offset = inner_type.fields()[-1].bitpos // 8
+            inner_ptr = data_ptr.reinterpret_cast(BYTE_PTR_TYPE) - data_offset
+
+            return inner_ptr.reinterpret_cast(inner_type.pointer())
+
         self._valobj = valobj
         self._is_atomic = is_atomic
-        self._ptr = unwrap_unique_or_non_null(valobj["ptr"])
+        self._ptr = inner_ptr()
         self._value = self._ptr["data" if is_atomic else "value"]
         self._strong = self._ptr["strong"]["v" if is_atomic else "value"]["value"]
         self._weak = self._ptr["weak"]["v" if is_atomic else "value"]["value"] - 1

library/alloc/src/sync.rs

@@ -40,7 +40,7 @@ def print_debug(s):
 
 def normalize_whitespace(s):
     """Replace newlines, tabs, multiple spaces, etc with exactly one space"""
-    return re.sub("\s+", " ", s)
+    return re.sub("\\s+", " ", s)
 
 
 def breakpoint_callback(frame, bp_loc, dict):
@@ -208,7 +208,7 @@ def watchdog():
 
     for line in script_file:
         command = line.strip()
-        if command == "run" or command == "r" or re.match("^process\s+launch.*", command):
+        if command == "run" or command == "r" or re.match("^process\\s+launch.*", command):
             # Before starting to run the program, let the thread sleep a bit, so all
             # breakpoint added events can be processed
             time.sleep(0.5)

src/etc/gdb_providers.py

@@ -44,9 +44,9 @@ def summary_lookup(valobj, dict):
         return SizeSummaryProvider(valobj, dict)
 
     if rust_type == RustType.STD_RC:
-        return StdRcSummaryProvider(valobj, dict)
+        return StdRcSummaryProvider(valobj, dict, False)
     if rust_type == RustType.STD_ARC:
-        return StdRcSummaryProvider(valobj, dict)
+        return StdRcSummaryProvider(valobj, dict, True)
 
     if rust_type == RustType.STD_REF:
         return StdRefSummaryProvider(valobj, dict)

src/etc/lldb_batchmode.py

@@ -660,7 +660,16 @@ def has_children(self):
         return True
 
 
-def StdRcSummaryProvider(valobj, dict):
+def get_rc_inner(valobj, is_atomic):
+    data_ptr = unwrap_unique_or_non_null(valobj.GetChildMemberWithName("ptr"))
+    inner_type = valobj.type.fields[1].type.template_args[0]
+    data_offset = inner_type.fields[-1].byte_offset
+    inner_address = data_ptr.GetValueAsAddress() - data_offset
+
+    return data_ptr.CreateValueFromAddress("inner", inner_address, inner_type)
+
+
+def StdRcSummaryProvider(valobj, dict, is_atomic):
     # type: (SBValue, dict) -> str
     strong = valobj.GetChildMemberWithName("strong").GetValueAsUnsigned()
     weak = valobj.GetChildMemberWithName("weak").GetValueAsUnsigned()
@@ -670,15 +679,15 @@ def StdRcSummaryProvider(valobj, dict):
 class StdRcSyntheticProvider:
     """Pretty-printer for alloc::rc::Rc<T> and alloc::sync::Arc<T>
 
-    struct Rc<T> { ptr: NonNull<RcInner<T>>, ... }
+    struct Rc<T> { ptr: NonNull<T>, ... }
     rust 1.31.1: struct NonNull<T> { pointer: NonZero<*const T> }
     rust 1.33.0: struct NonNull<T> { pointer: *const T }
     struct NonZero<T>(T)
     struct RcInner<T> { strong: Cell<usize>, weak: Cell<usize>, value: T }
     struct Cell<T> { value: UnsafeCell<T> }
     struct UnsafeCell<T> { value: T }
 
-    struct Arc<T> { ptr: NonNull<ArcInner<T>>, ... }
+    struct Arc<T> { ptr: NonNull<T>, ... }
     struct ArcInner<T> { strong: atomic::AtomicUsize, weak: atomic::AtomicUsize, data: T }
     struct AtomicUsize { v: UnsafeCell<usize> }
     """
@@ -687,14 +696,17 @@ def __init__(self, valobj, dict, is_atomic=False):
         # type: (SBValue, dict, bool) -> StdRcSyntheticProvider
         self.valobj = valobj
 
-        self.ptr = unwrap_unique_or_non_null(self.valobj.GetChildMemberWithName("ptr"))
+        self.inner = get_rc_inner(valobj, is_atomic)
 
-        self.value = self.ptr.GetChildMemberWithName("data" if is_atomic else "value")
+        self.value = self.inner.GetChildMemberWithName("data" if is_atomic else "value")
+
+        if is_atomic:
+            read_cell = lambda x: x.GetChildAtIndex(0).GetChildAtIndex(0)
+        else:
+            read_cell = lambda x: x.GetChildAtIndex(0)
 
-        self.strong = self.ptr.GetChildMemberWithName("strong").GetChildAtIndex(
-            0).GetChildMemberWithName("value")
-        self.weak = self.ptr.GetChildMemberWithName("weak").GetChildAtIndex(
-            0).GetChildMemberWithName("value")
+        self.strong = read_cell(self.inner.GetChildMemberWithName("strong"))
+        self.weak = read_cell(self.inner.GetChildMemberWithName("weak"))
 
         self.value_builder = ValueBuilder(valobj)
 

src/etc/lldb_lookup.py

@@ -22,18 +22,22 @@ pub fn box_default_inplace() -> Box<(String, String)> {
 #[no_mangle]
 pub fn rc_default_inplace() -> Rc<(String, String)> {
     // CHECK-NOT: alloca
-    // CHECK: [[RC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
+    // CHECK: [[RC:%.*]] = {{.*}}call {{.*}}__rust_alloc(i[[#BITS:]]
     // CHECK-NOT: call void @llvm.memcpy
-    // CHECK: ret ptr [[RC]]
+    // CHECK: [[DATA:%.*]] = getelementptr inbounds i8, ptr [[RC]], i[[#BITS]] [[#div(BITS,4)]]
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK: ret ptr [[DATA]]
     Rc::default()
 }
 
 // CHECK-LABEL: @arc_default_inplace
 #[no_mangle]
 pub fn arc_default_inplace() -> Arc<(String, String)> {
     // CHECK-NOT: alloca
-    // CHECK: [[ARC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
+    // CHECK: [[RC:%.*]] = {{.*}}call {{.*}}__rust_alloc(i[[#BITS:]]
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK: [[DATA:%.*]] = getelementptr inbounds i8, ptr [[RC]], i[[#BITS]] [[#div(BITS,4)]]
     // CHECK-NOT: call void @llvm.memcpy
-    // CHECK: ret ptr [[ARC]]
+    // CHECK: ret ptr [[DATA]]
     Arc::default()
 }

src/etc/lldb_providers.py

@@ -0,0 +1,82 @@
+//@ compile-flags: -O -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+
+use std::rc::Rc;
+use std::sync::Arc;
+
+// CHECK-LABEL: @deref_rc_sized(
+// CHECK-NOT: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn deref_rc_sized(rc: &Rc<u32>) -> &u32 {
+    &rc
+}
+
+// CHECK-LABEL: @deref_rc_unsized(
+// CHECK-COUNT-1: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn deref_rc_unsized(rc: &Rc<str>) -> &str {
+    &rc
+}
+
+// CHECK-LABEL: @deref_arc_sized(
+// CHECK-NOT: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn deref_arc_sized(arc: &Arc<u32>) -> &u32 {
+    &arc
+}
+
+// CHECK-LABEL: @deref_arc_unsized(
+// CHECK-COUNT-1: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn deref_arc_unsized(arc: &Arc<str>) -> &str {
+    &arc
+}
+
+// CHECK-LABEL: @rc_slice_to_ref_slice_sized(
+// CHECK-NOT: getelementptr
+// CHECK: tail call void @llvm.memcpy
+// CHECK-COUNT-1: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn rc_slice_to_ref_slice_sized(s: &[Rc<u32>]) -> Box<[&u32]> {
+    s.iter().map(|x| &**x).collect()
+}
+
+// This test doesn’t work yet.
+//
+// COM: CHECK-LABEL: @rc_slice_to_ref_slice_unsized(
+// COM: CHECK-NOT: getelementptr
+// COM: CHECK: tail call void @llvm.memcpy
+// COM: CHECK-NOT: getelementptr
+// COM: CHECK: ret
+// #[no_mangle]
+// pub fn rc_slice_to_ref_slice_unsized(s: &[Rc<str>]) -> Box<[&str]> {
+//     s.iter().map(|x| &**x).collect()
+// }
+
+// CHECK-LABEL: @arc_slice_to_ref_slice_sized(
+// CHECK-NOT: getelementptr
+// CHECK: tail call void @llvm.memcpy
+// CHECK-COUNT-1: getelementptr
+// CHECK: ret
+#[no_mangle]
+pub fn arc_slice_to_ref_slice_sized(s: &[Arc<u32>]) -> Box<[&u32]> {
+    s.iter().map(|x| &**x).collect()
+}
+
+// This test doesn’t work yet.
+//
+// COM: CHECK-LABEL: @arc_slice_to_ref_slice_unsized(
+// COM: CHECK-NOT: getelementptr
+// COM: CHECK: tail call void @llvm.memcpy
+// COM: CHECK-NOT: getelementptr
+// COM: CHECK: ret
+// #[no_mangle]
+// pub fn arc_slice_to_ref_slice_unsized(s: &[Arc<str>]) -> Box<[&str]> {
+//     s.iter().map(|x| &**x).collect()
+// }

tests/codegen/placement-new.rs

@@ -19,7 +19,7 @@
 // gdb-check:$4 = ("Hello", "World")
 
 // gdb-command:print str_in_rc
-// gdb-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull<alloc::rc::RcInner<&str>> {pointer: 0x[...]}, phantom: core::marker::PhantomData<alloc::rc::RcInner<&str>>, alloc: alloc::alloc::Global}
+// gdb-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull<&str> {pointer: 0x[...]}, phantom: core::marker::PhantomData<alloc::rc::RcInner<&str>>, alloc: alloc::alloc::Global}
 
 // === LLDB TESTS ==================================================================================
 // lldb-command:run

tests/codegen/zero-cost-rc-arc-deref.rs

@@ -126,7 +126,7 @@ mod prelude {
         value: T,
     }
     pub struct Rc<T: ?Sized, A = Global> {
-        ptr: NonNull<RcInner<T>>,
+        ptr: NonNull<T>,
         phantom: PhantomData<RcInner<T>>,
         alloc: A,
     }
@@ -140,7 +140,7 @@ mod prelude {
         data: T,
     }
     pub struct Arc<T: ?Sized, A = Global> {
-        ptr: NonNull<ArcInner<T>>,
+        ptr: NonNull<T>,
         phantom: PhantomData<ArcInner<T>>,
         alloc: A,
     }