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,
  }