debuginfo: slices are DW_TAG_array_type's

Author: shua

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -152,7 +152,20 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
         cx.size_and_align_of(Ty::new_mut_ptr(cx.tcx, pointee_type))
     );
 
-    let pointee_type_di_node = type_di_node(cx, pointee_type);
+    let pointee_type_di_node = match pointee_type.kind() {
+        // `&[T]` will look like `{ data_ptr: *const T, length: usize }`
+        ty::Slice(element_type) => type_di_node(cx, *element_type),
+        // `&str` will look like `{ data_ptr: *const u8, length: usize }`
+        ty::Str => type_di_node(cx, cx.tcx.types.u8),
+
+        // `&dyn K` will look like `{ pointer: _, vtable: _}`
+        // any Adt `Foo` containing an unsized type (eg `&[_]` or `&dyn _`)
+        //   will look like `{ data_ptr: *const Foo, length: usize }`
+        // and thin pointers `&Foo` will just look like `*const Foo`.
+        //
+        // in all those cases, we just use the pointee_type
+        _ => type_di_node(cx, pointee_type),
+    };
 
     return_if_di_node_created_in_meantime!(cx, unique_type_id);
 
@@ -194,23 +207,7 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
                     DIFlags::FlagZero,
                 ),
                 |cx, owner| {
-                    // FIXME: If this wide pointer is a `Box` then we don't want to use its
-                    //        type layout and instead use the layout of the raw pointer inside
-                    //        of it.
-                    //        The proper way to handle this is to not treat Box as a pointer
-                    //        at all and instead emit regular struct debuginfo for it. We just
-                    //        need to make sure that we don't break existing debuginfo consumers
-                    //        by doing that (at least not without a warning period).
-                    let layout_type = if ptr_type.is_box() {
-                        // The assertion at the start of this function ensures we have a ZST
-                        // allocator. We'll make debuginfo "skip" all ZST allocators, not just the
-                        // default allocator.
-                        Ty::new_mut_ptr(cx.tcx, pointee_type)
-                    } else {
-                        ptr_type
-                    };
-
-                    let layout = cx.layout_of(layout_type);
+                    let layout = cx.layout_of(ptr_type);
                     let addr_field = layout.field(cx, WIDE_PTR_ADDR);
                     let extra_field = layout.field(cx, WIDE_PTR_EXTRA);
 
@@ -389,26 +386,11 @@ fn build_dyn_type_di_node<'ll, 'tcx>(
 }
 
 /// Create debuginfo for `[T]` and `str`. These are unsized.
-///
-/// NOTE: We currently emit just emit the debuginfo for the element type here
-/// (i.e. `T` for slices and `u8` for `str`), so that we end up with
-/// `*const T` for the `data_ptr` field of the corresponding wide-pointer
-/// debuginfo of `&[T]`.
-///
-/// It would be preferable and more accurate if we emitted a DIArray of T
-/// without an upper bound instead. That is, LLVM already supports emitting
-/// debuginfo of arrays of unknown size. But GDB currently seems to end up
-/// in an infinite loop when confronted with such a type.
-///
-/// As a side effect of the current encoding every instance of a type like
-/// `struct Foo { unsized_field: [u8] }` will look like
-/// `struct Foo { unsized_field: u8 }` in debuginfo. If the length of the
-/// slice is zero, then accessing `unsized_field` in the debugger would
-/// result in an out-of-bounds access.
 fn build_slice_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     slice_type: Ty<'tcx>,
     unique_type_id: UniqueTypeId<'tcx>,
+    span: Span,
 ) -> DINodeCreationResult<'ll> {
     let element_type = match slice_type.kind() {
         ty::Slice(element_type) => *element_type,
@@ -423,7 +405,20 @@ fn build_slice_type_di_node<'ll, 'tcx>(
 
     let element_type_di_node = type_di_node(cx, element_type);
     return_if_di_node_created_in_meantime!(cx, unique_type_id);
-    DINodeCreationResult { di_node: element_type_di_node, already_stored_in_typemap: false }
+    let (size, align) = cx.spanned_size_and_align_of(slice_type, span);
+    let subrange = unsafe { llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0, -1) };
+    let subscripts = &[subrange];
+    let di_node = unsafe {
+        llvm::LLVMDIBuilderCreateArrayType(
+            DIB(cx),
+            size.bits(),
+            align.bits() as u32,
+            element_type_di_node,
+            subscripts.as_ptr(),
+            subscripts.len() as c_uint,
+        )
+    };
+    DINodeCreationResult { di_node, already_stored_in_typemap: false }
 }
 
 /// Get the debuginfo node for the given type.
@@ -454,21 +449,12 @@ pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
         }
         ty::Tuple(elements) if elements.is_empty() => build_basic_type_di_node(cx, t),
         ty::Array(..) => build_fixed_size_array_di_node(cx, unique_type_id, t, span),
-        ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id),
+        ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id, span),
         ty::Dynamic(..) => build_dyn_type_di_node(cx, t, unique_type_id),
         ty::Foreign(..) => build_foreign_type_di_node(cx, t, unique_type_id),
         ty::RawPtr(pointee_type, _) | ty::Ref(_, pointee_type, _) => {
             build_pointer_or_reference_di_node(cx, t, pointee_type, unique_type_id)
         }
-        // Some `Box` are newtyped pointers, make debuginfo aware of that.
-        // Only works if the allocator argument is a 1-ZST and hence irrelevant for layout
-        // (or if there is no allocator argument).
-        ty::Adt(def, args)
-            if def.is_box()
-                && args.get(1).is_none_or(|arg| cx.layout_of(arg.expect_ty()).is_1zst()) =>
-        {
-            build_pointer_or_reference_di_node(cx, t, t.expect_boxed_ty(), unique_type_id)
-        }
         ty::FnDef(..) | ty::FnPtr(..) => build_subroutine_type_di_node(cx, unique_type_id),
         ty::Closure(..) => build_closure_env_di_node(cx, unique_type_id),
         ty::CoroutineClosure(..) => build_closure_env_di_node(cx, unique_type_id),

src/etc/gdb_lookup.py

@@ -104,6 +104,7 @@ def __call__(self, valobj):
 printer.add(RustType.STD_OS_STRING, StdOsStringProvider)
 printer.add(RustType.STD_STR, StdStrProvider)
 printer.add(RustType.STD_SLICE, StdSliceProvider)
+printer.add(RustType.STD_BOX, StdBoxProvider)
 printer.add(RustType.STD_VEC, StdVecProvider)
 printer.add(RustType.STD_VEC_DEQUE, StdVecDequeProvider)
 printer.add(RustType.STD_BTREE_SET, StdBTreeSetProvider)

src/etc/gdb_providers.py

@@ -136,6 +136,29 @@ def display_hint():
         return "array"
 
 
+class StdBoxProvider(printer_base):
+    def __init__(self, valobj):
+        self._valobj = valobj
+        self._pointer = unwrap_unique_or_non_null(valobj[ZERO_FIELD])
+        # An unfortunate kludge.
+        # I can't find any good way to distinguish a `Box<str>` from a `Box<u8>`
+        # as the debuginfo template argument for both is `u8`.
+        # If we could get `self._valobj.type.template_argument(0) == str`
+        # then we could make this a bit nicer.
+        #
+        # FIXME(shua): the debuginfo template type should be 'str' not 'u8'
+        if self._valobj.type.name == 'alloc::boxed::Box<str, alloc::alloc::Global>':
+            ptr_ty = gdb.Type.pointer(gdb.lookup_type("u8"))
+            data = self._pointer["data_ptr"].cast(ptr_ty)
+            length = self._pointer["length"]
+            self._pointer = data.lazy_string(encoding="utf-8", length=length)
+
+    def to_string(self):
+        return "Box"
+
+    def children(self):
+        yield "pointer", self._pointer
+
 class StdVecProvider(printer_base):
     def __init__(self, valobj):
         self._valobj = valobj
@@ -197,6 +220,11 @@ def __init__(self, valobj, is_atomic=False):
         self._is_atomic = is_atomic
         self._ptr = unwrap_unique_or_non_null(valobj["ptr"])
         self._value = self._ptr["data" if is_atomic else "value"]
+        # FIXME(shua): the debuginfo template type should be 'str' not 'u8'
+        if self._ptr.type.target().name == "alloc::rc::RcInner<str>":
+            length = self._valobj["ptr"]["pointer"]["length"]
+            ptr = self._value.address.reinterpret_cast(gdb.Type.pointer(gdb.lookup_type("u8")))
+            self._value = ptr.lazy_string(encoding="utf-8", length=length)
         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
 

src/etc/rust_types.py

@@ -20,6 +20,7 @@ class RustType(object):
     STD_OS_STRING = "StdOsString"
     STD_STR = "StdStr"
     STD_SLICE = "StdSlice"
+    STD_BOX = "StdBox"
     STD_VEC = "StdVec"
     STD_VEC_DEQUE = "StdVecDeque"
     STD_BTREE_SET = "StdBTreeSet"
@@ -41,6 +42,7 @@ class RustType(object):
 STD_STR_REGEX = re.compile(r"^&(mut )?str$")
 STD_SLICE_REGEX = re.compile(r"^&(mut )?\[.+\]$")
 STD_OS_STRING_REGEX = re.compile(r"^(std::ffi::([a-z_]+::)+)OsString$")
+STD_BOX_REGEX = re.compile(r"^(alloc::([a-z_]+::)+)Box<.+>$")
 STD_VEC_REGEX = re.compile(r"^(alloc::([a-z_]+::)+)Vec<.+>$")
 STD_VEC_DEQUE_REGEX = re.compile(r"^(alloc::([a-z_]+::)+)VecDeque<.+>$")
 STD_BTREE_SET_REGEX = re.compile(r"^(alloc::([a-z_]+::)+)BTreeSet<.+>$")
@@ -68,6 +70,7 @@ class RustType(object):
     RustType.STD_OS_STRING: STD_OS_STRING_REGEX,
     RustType.STD_STR: STD_STR_REGEX,
     RustType.STD_SLICE: STD_SLICE_REGEX,
+    RustType.STD_BOX: STD_BOX_REGEX,
     RustType.STD_VEC: STD_VEC_REGEX,
     RustType.STD_VEC_DEQUE: STD_VEC_DEQUE_REGEX,
     RustType.STD_HASH_MAP: STD_HASH_MAP_REGEX,

tests/debuginfo/strings-and-strs.rs

@@ -23,6 +23,12 @@
 //@ 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-command:print box_str
+//@ gdb-check:$6 = alloc::boxed::Box<str, alloc::alloc::Global> (core::ptr::unique::Unique<str> {pointer: core::ptr::non_null::NonNull<str> {pointer: *const str [87, 111, 114, 108, 100]}, _marker: core::marker::PhantomData<str>}, alloc::alloc::Global)
+
+//@ gdb-command:print rc_str
+//@ gdb-check:$7 = alloc::rc::Rc<str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull<alloc::rc::RcInner<str>> {pointer: alloc::rc::RcInner<str> {strong: core::cell::Cell<usize> {value: core::cell::UnsafeCell<usize> {value: 1}}, weak: core::cell::Cell<usize> {value: core::cell::UnsafeCell<usize> {value: 1}}, value: 0x[...]}}, phantom: core::marker::PhantomData<alloc::rc::RcInner<str>>, alloc: alloc::alloc::Global}
+
 // === LLDB TESTS ==================================================================================
 //@ lldb-command:run
 //@ lldb-command:v plain_string
@@ -40,6 +46,12 @@
 //@ lldb-command:v str_in_rc
 //@ lldb-check:(alloc::rc::Rc<&str, alloc::alloc::Global>) str_in_rc = strong=1, weak=0 { value = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } }
 
+//@ lldb-command:v box_str
+//@ lldb-check:(alloc::boxed::Box<unsigned char[], alloc::alloc::Global>) box_str = { __0 = { pointer = { pointer = { data_ptr = 0x[...] "World" length = 5 } } _marker = } __1 = }
+
+//@ lldb-command:v rc_str
+//@ lldb-check:(alloc::rc::Rc<unsigned char[], alloc::alloc::Global>) rc_str = strong=1, weak=0 { value = "World" }
+
 #![allow(unused_variables)]
 
 pub struct Foo<'a> {
@@ -53,6 +65,8 @@ fn main() {
     let str_in_tuple = ("Hello", "World");
 
     let str_in_rc = std::rc::Rc::new("Hello");
+    let box_str: Box<str> = "World".into();
+    let rc_str: std::rc::Rc<str> = "World".into();
     zzz(); // #break
 }