diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs index 5e966d7055b..a752d8045f7 100644 --- a/src/bootstrap/dist.rs +++ b/src/bootstrap/dist.rs @@ -619,19 +619,21 @@ impl Step for DebuggerScripts { cp_debugger_script("natvis/libcore.natvis"); cp_debugger_script("natvis/libstd.natvis"); } else { - cp_debugger_script("debugger_pretty_printers_common.py"); + cp_debugger_script("rust_types.py"); // gdb debugger scripts builder.install(&builder.src.join("src/etc/rust-gdb"), &sysroot.join("bin"), 0o755); builder.install(&builder.src.join("src/etc/rust-gdbgui"), &sysroot.join("bin"), 0o755); cp_debugger_script("gdb_load_rust_pretty_printers.py"); - cp_debugger_script("gdb_rust_pretty_printing.py"); + cp_debugger_script("gdb_lookup.py"); + cp_debugger_script("gdb_providers.py"); // lldb debugger scripts builder.install(&builder.src.join("src/etc/rust-lldb"), &sysroot.join("bin"), 0o755); - cp_debugger_script("lldb_rust_formatters.py"); + cp_debugger_script("lldb_lookup.py"); + cp_debugger_script("lldb_providers.py"); } } } diff --git a/src/etc/debugger_pretty_printers_common.py b/src/etc/debugger_pretty_printers_common.py deleted file mode 100644 index b3f8f50636b..00000000000 --- a/src/etc/debugger_pretty_printers_common.py +++ /dev/null @@ -1,401 +0,0 @@ -""" -This module provides an abstraction layer over common Rust pretty printing -functionality needed by both GDB and LLDB. -""" - -import re - -# Type codes that indicate the kind of type as it appears in DWARF debug -# information. This code alone is not sufficient to determine the Rust type. -# For example structs, tuples, fat pointers, or enum variants will all have -# DWARF_TYPE_CODE_STRUCT. -DWARF_TYPE_CODE_STRUCT = 1 -DWARF_TYPE_CODE_UNION = 2 -DWARF_TYPE_CODE_PTR = 3 -DWARF_TYPE_CODE_ARRAY = 4 -DWARF_TYPE_CODE_ENUM = 5 - -# These constants specify the most specific kind of type that could be -# determined for a given value. -TYPE_KIND_UNKNOWN = -1 -TYPE_KIND_EMPTY = 0 -TYPE_KIND_SLICE = 1 -TYPE_KIND_REGULAR_STRUCT = 2 -TYPE_KIND_TUPLE = 3 -TYPE_KIND_TUPLE_STRUCT = 4 -TYPE_KIND_CSTYLE_VARIANT = 5 -TYPE_KIND_TUPLE_VARIANT = 6 -TYPE_KIND_STRUCT_VARIANT = 7 -TYPE_KIND_STR_SLICE = 8 -TYPE_KIND_STD_VEC = 9 -TYPE_KIND_STD_STRING = 10 -TYPE_KIND_REGULAR_ENUM = 11 -TYPE_KIND_COMPRESSED_ENUM = 12 -TYPE_KIND_SINGLETON_ENUM = 13 -TYPE_KIND_CSTYLE_ENUM = 14 -TYPE_KIND_PTR = 15 -TYPE_KIND_FIXED_SIZE_VEC = 16 -TYPE_KIND_REGULAR_UNION = 17 -TYPE_KIND_OS_STRING = 18 -TYPE_KIND_STD_VECDEQUE = 19 -TYPE_KIND_STD_BTREESET = 20 -TYPE_KIND_STD_BTREEMAP = 21 - -ENCODED_ENUM_PREFIX = "RUST$ENCODED$ENUM$" -ENUM_DISR_FIELD_NAME = "RUST$ENUM$DISR" - -# Slice related constants -SLICE_FIELD_NAME_DATA_PTR = "data_ptr" -SLICE_FIELD_NAME_LENGTH = "length" -SLICE_FIELD_NAMES = [SLICE_FIELD_NAME_DATA_PTR, SLICE_FIELD_NAME_LENGTH] - -# std::Vec<> related constants -STD_VEC_FIELD_NAME_LENGTH = "len" -STD_VEC_FIELD_NAME_BUF = "buf" -STD_VEC_FIELD_NAMES = [STD_VEC_FIELD_NAME_BUF, - STD_VEC_FIELD_NAME_LENGTH] - -# std::collections::VecDeque<> related constants -STD_VECDEQUE_FIELD_NAME_TAIL = "tail" -STD_VECDEQUE_FIELD_NAME_HEAD = "head" -STD_VECDEQUE_FIELD_NAME_BUF = "buf" -STD_VECDEQUE_FIELD_NAMES = [STD_VECDEQUE_FIELD_NAME_TAIL, - STD_VECDEQUE_FIELD_NAME_HEAD, - STD_VECDEQUE_FIELD_NAME_BUF] - -# std::collections::BTreeSet<> related constants -STD_BTREESET_FIELD_NAMES = ["map"] - -# std::collections::BTreeMap<> related constants -STD_BTREEMAP_FIELD_NAMES = ["root", "length"] - -# std::String related constants -STD_STRING_FIELD_NAMES = ["vec"] - -# std::ffi::OsString related constants -OS_STRING_FIELD_NAMES = ["inner"] - - -class Type(object): - """ - This class provides a common interface for type-oriented operations. - Sub-classes are supposed to wrap a debugger-specific type-object and - provide implementations for the abstract methods in this class. - """ - - def __init__(self): - self.__type_kind = None - - def get_unqualified_type_name(self): - """ - Implementations of this method should return the unqualified name of the - type-object they are wrapping. Some examples: - - 'int' -> 'int' - 'std::vec::Vec' -> 'Vec' - '&std::option::Option' -> '&std::option::Option' - - As you can see, type arguments stay fully qualified. - """ - raise NotImplementedError("Override this method") - - def get_dwarf_type_kind(self): - """ - Implementations of this method should return the correct - DWARF_TYPE_CODE_* value for the wrapped type-object. - """ - raise NotImplementedError("Override this method") - - def get_fields(self): - """ - Implementations of this method should return a list of field-objects of - this type. For Rust-enums (i.e. with DWARF_TYPE_CODE_UNION) these field- - objects represent the variants of the enum. Field-objects must have a - `name` attribute that gives their name as specified in DWARF. - """ - assert ((self.get_dwarf_type_kind() == DWARF_TYPE_CODE_STRUCT) or - (self.get_dwarf_type_kind() == DWARF_TYPE_CODE_UNION)) - raise NotImplementedError("Override this method") - - def get_wrapped_value(self): - """ - Returns the debugger-specific type-object wrapped by this object. This - is sometimes needed for doing things like pointer-arithmetic in GDB. - """ - raise NotImplementedError("Override this method") - - def get_type_kind(self): - """This method returns the TYPE_KIND_* value for this type-object.""" - if self.__type_kind is None: - dwarf_type_code = self.get_dwarf_type_kind() - - if dwarf_type_code == DWARF_TYPE_CODE_STRUCT: - self.__type_kind = self.__classify_struct() - elif dwarf_type_code == DWARF_TYPE_CODE_UNION: - self.__type_kind = self.__classify_union() - elif dwarf_type_code == DWARF_TYPE_CODE_PTR: - self.__type_kind = TYPE_KIND_PTR - elif dwarf_type_code == DWARF_TYPE_CODE_ARRAY: - self.__type_kind = TYPE_KIND_FIXED_SIZE_VEC - else: - self.__type_kind = TYPE_KIND_UNKNOWN - return self.__type_kind - - def __classify_struct(self): - assert self.get_dwarf_type_kind() == DWARF_TYPE_CODE_STRUCT - - unqualified_type_name = self.get_unqualified_type_name() - - # STR SLICE - if unqualified_type_name == "&str": - return TYPE_KIND_STR_SLICE - - # REGULAR SLICE - if (unqualified_type_name.startswith(("&[", "&mut [")) and - unqualified_type_name.endswith("]") and - self.__conforms_to_field_layout(SLICE_FIELD_NAMES)): - return TYPE_KIND_SLICE - - fields = self.get_fields() - field_count = len(fields) - - # EMPTY STRUCT - if field_count == 0: - return TYPE_KIND_EMPTY - - # STD VEC - if (unqualified_type_name.startswith("Vec<") and - self.__conforms_to_field_layout(STD_VEC_FIELD_NAMES)): - return TYPE_KIND_STD_VEC - - # STD COLLECTION VECDEQUE - if (unqualified_type_name.startswith("VecDeque<") and - self.__conforms_to_field_layout(STD_VECDEQUE_FIELD_NAMES)): - return TYPE_KIND_STD_VECDEQUE - - # STD COLLECTION BTREESET - if (unqualified_type_name.startswith("BTreeSet<") and - self.__conforms_to_field_layout(STD_BTREESET_FIELD_NAMES)): - return TYPE_KIND_STD_BTREESET - - # STD COLLECTION BTREEMAP - if (unqualified_type_name.startswith("BTreeMap<") and - self.__conforms_to_field_layout(STD_BTREEMAP_FIELD_NAMES)): - return TYPE_KIND_STD_BTREEMAP - - # STD STRING - if (unqualified_type_name.startswith("String") and - self.__conforms_to_field_layout(STD_STRING_FIELD_NAMES)): - return TYPE_KIND_STD_STRING - - # OS STRING - if (unqualified_type_name == "OsString" and - self.__conforms_to_field_layout(OS_STRING_FIELD_NAMES)): - return TYPE_KIND_OS_STRING - - # ENUM VARIANTS - if fields[0].name == ENUM_DISR_FIELD_NAME: - if field_count == 1: - return TYPE_KIND_CSTYLE_VARIANT - elif self.__all_fields_conform_to_tuple_field_naming(1): - return TYPE_KIND_TUPLE_VARIANT - else: - return TYPE_KIND_STRUCT_VARIANT - - # TUPLE - if self.__all_fields_conform_to_tuple_field_naming(0): - if unqualified_type_name.startswith("("): - return TYPE_KIND_TUPLE - else: - return TYPE_KIND_TUPLE_STRUCT - - # REGULAR STRUCT - return TYPE_KIND_REGULAR_STRUCT - - def __classify_union(self): - assert self.get_dwarf_type_kind() == DWARF_TYPE_CODE_UNION - - union_members = self.get_fields() - union_member_count = len(union_members) - if union_member_count == 0: - return TYPE_KIND_EMPTY - - first_variant_name = union_members[0].name - if first_variant_name is None: - if union_member_count == 1: - return TYPE_KIND_SINGLETON_ENUM - else: - return TYPE_KIND_REGULAR_ENUM - elif first_variant_name.startswith(ENCODED_ENUM_PREFIX): - assert union_member_count == 1 - return TYPE_KIND_COMPRESSED_ENUM - else: - return TYPE_KIND_REGULAR_UNION - - def __conforms_to_field_layout(self, expected_fields): - actual_fields = self.get_fields() - actual_field_count = len(actual_fields) - - if actual_field_count != len(expected_fields): - return False - - for i in range(0, actual_field_count): - if actual_fields[i].name != expected_fields[i]: - return False - - return True - - def __all_fields_conform_to_tuple_field_naming(self, start_index): - fields = self.get_fields() - field_count = len(fields) - - for i in range(start_index, field_count): - field_name = fields[i].name - if (field_name is None) or (re.match(r"__\d+$", field_name) is None): - return False - return True - - -class Value(object): - """ - This class provides a common interface for value-oriented operations. - Sub-classes are supposed to wrap a debugger-specific value-object and - provide implementations for the abstract methods in this class. - """ - def __init__(self, ty): - self.type = ty - - def get_child_at_index(self, index): - """Returns the value of the field, array element or variant at the given index""" - raise NotImplementedError("Override this method") - - def as_integer(self): - """ - Try to convert the wrapped value into a Python integer. This should - always succeed for values that are pointers or actual integers. - """ - raise NotImplementedError("Override this method") - - def get_wrapped_value(self): - """ - Returns the debugger-specific value-object wrapped by this object. This - is sometimes needed for doing things like pointer-arithmetic in GDB. - """ - raise NotImplementedError("Override this method") - - -class EncodedEnumInfo(object): - """ - This class provides facilities for handling enum values with compressed - encoding where a non-null field in one variant doubles as the discriminant. - """ - - def __init__(self, enum_val): - assert enum_val.type.get_type_kind() == TYPE_KIND_COMPRESSED_ENUM - variant_name = enum_val.type.get_fields()[0].name - last_separator_index = variant_name.rfind("$") - start_index = len(ENCODED_ENUM_PREFIX) - indices_substring = variant_name[start_index:last_separator_index].split("$") - self.__enum_val = enum_val - self.__disr_field_indices = [int(index) for index in indices_substring] - self.__null_variant_name = variant_name[last_separator_index + 1:] - - def is_null_variant(self): - ty = self.__enum_val.type - sole_variant_val = self.__enum_val.get_child_at_index(0) - discriminant_val = sole_variant_val - for disr_field_index in self.__disr_field_indices: - discriminant_val = discriminant_val.get_child_at_index(disr_field_index) - - # If the discriminant field is a fat pointer we have to consider the - # first word as the true discriminant - if discriminant_val.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_STRUCT: - discriminant_val = discriminant_val.get_child_at_index(0) - - return discriminant_val.as_integer() == 0 - - def get_non_null_variant_val(self): - return self.__enum_val.get_child_at_index(0) - - def get_null_variant_name(self): - return self.__null_variant_name - - -def get_discriminant_value_as_integer(enum_val): - assert enum_val.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_UNION - # we can take any variant here because the discriminant has to be the same - # for all of them. - variant_val = enum_val.get_child_at_index(0) - disr_val = variant_val.get_child_at_index(0) - return disr_val.as_integer() - - -def extract_length_ptr_and_cap_from_std_vec(vec_val): - assert vec_val.type.get_type_kind() == TYPE_KIND_STD_VEC - length_field_index = STD_VEC_FIELD_NAMES.index(STD_VEC_FIELD_NAME_LENGTH) - buf_field_index = STD_VEC_FIELD_NAMES.index(STD_VEC_FIELD_NAME_BUF) - - length = vec_val.get_child_at_index(length_field_index).as_integer() - buf = vec_val.get_child_at_index(buf_field_index) - - vec_ptr_val = buf.get_child_at_index(0) - capacity = buf.get_child_at_index(1).as_integer() - data_ptr = vec_ptr_val.get_child_at_index(0) - assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR - return (length, data_ptr, capacity) - - -def extract_tail_head_ptr_and_cap_from_std_vecdeque(vec_val): - assert vec_val.type.get_type_kind() == TYPE_KIND_STD_VECDEQUE - tail_field_index = STD_VECDEQUE_FIELD_NAMES.index(STD_VECDEQUE_FIELD_NAME_TAIL) - head_field_index = STD_VECDEQUE_FIELD_NAMES.index(STD_VECDEQUE_FIELD_NAME_HEAD) - buf_field_index = STD_VECDEQUE_FIELD_NAMES.index(STD_VECDEQUE_FIELD_NAME_BUF) - - tail = vec_val.get_child_at_index(tail_field_index).as_integer() - head = vec_val.get_child_at_index(head_field_index).as_integer() - buf = vec_val.get_child_at_index(buf_field_index) - - vec_ptr_val = buf.get_child_at_index(0) - capacity = buf.get_child_at_index(1).as_integer() - data_ptr = vec_ptr_val.get_child_at_index(0) - assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR - return (tail, head, data_ptr, capacity) - - -def extract_length_and_ptr_from_slice(slice_val): - assert (slice_val.type.get_type_kind() == TYPE_KIND_SLICE or - slice_val.type.get_type_kind() == TYPE_KIND_STR_SLICE) - - length_field_index = SLICE_FIELD_NAMES.index(SLICE_FIELD_NAME_LENGTH) - ptr_field_index = SLICE_FIELD_NAMES.index(SLICE_FIELD_NAME_DATA_PTR) - - length = slice_val.get_child_at_index(length_field_index).as_integer() - data_ptr = slice_val.get_child_at_index(ptr_field_index) - - assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR - return (length, data_ptr) - - -UNQUALIFIED_TYPE_MARKERS = frozenset(["(", "[", "&", "*"]) - - -def extract_type_name(qualified_type_name): - """Extracts the type name from a fully qualified path""" - if qualified_type_name[0] in UNQUALIFIED_TYPE_MARKERS: - return qualified_type_name - - end_of_search = qualified_type_name.find("<") - if end_of_search < 0: - end_of_search = len(qualified_type_name) - - index = qualified_type_name.rfind("::", 0, end_of_search) - if index < 0: - return qualified_type_name - else: - return qualified_type_name[index + 2:] - - -try: - compat_str = unicode # Python 2 -except NameError: - compat_str = str diff --git a/src/etc/gdb_load_rust_pretty_printers.py b/src/etc/gdb_load_rust_pretty_printers.py index fe38c49d270..856b5df2de7 100644 --- a/src/etc/gdb_load_rust_pretty_printers.py +++ b/src/etc/gdb_load_rust_pretty_printers.py @@ -1,3 +1,3 @@ import gdb -import gdb_rust_pretty_printing -gdb_rust_pretty_printing.register_printers(gdb.current_objfile()) +import gdb_lookup +gdb_lookup.register_printers(gdb.current_objfile()) diff --git a/src/etc/gdb_lookup.py b/src/etc/gdb_lookup.py new file mode 100644 index 00000000000..2a46eaadad6 --- /dev/null +++ b/src/etc/gdb_lookup.py @@ -0,0 +1,92 @@ +import gdb +import re + +from gdb_providers import * +from rust_types import * + + +rust_enabled = 'set language rust' in gdb.execute('complete set language ru', to_string=True) +_gdb_version_matched = re.search('([0-9]+)\\.([0-9]+)', gdb.VERSION) +gdb_version = [int(num) for num in _gdb_version_matched.groups()] if _gdb_version_matched else [] + +def register_printers(objfile): + objfile.pretty_printers.append(lookup) + + +# BACKCOMPAT: rust 1.35 +def is_hashbrown_hashmap(hash_map): + return len(hash_map.type.fields()) == 1 + + +def classify_rust_type(type): + type_class = type.code + if type_class == gdb.TYPE_CODE_STRUCT: + return classify_struct(type.tag, type.fields()) + if type_class == gdb.TYPE_CODE_UNION: + return classify_union(type.fields()) + + return RustType.OTHER + + +def check_enum_discriminant(valobj): + content = valobj[valobj.type.fields()[0]] + fields = content.type.fields() + if len(fields) > 1: + discriminant = int(content[fields[0]]) + 1 + if discriminant > len(fields): + # invalid discriminant + return False + return True + + +def lookup(valobj): + rust_type = classify_rust_type(valobj.type) + + if rust_type == RustType.ENUM: + # use enum provider only for GDB <7.12 + if gdb_version[0] < 7 or (gdb_version[0] == 7 and gdb_version[1] < 12): + if check_enum_discriminant(valobj): + return EnumProvider(valobj) + + if rust_type == RustType.STD_STRING: + return StdStringProvider(valobj) + if rust_type == RustType.STD_OS_STRING: + return StdOsStringProvider(valobj) + if rust_type == RustType.STD_STR and not rust_enabled: + return StdStrProvider(valobj) + + if rust_type == RustType.STD_VEC: + return StdVecProvider(valobj) + if rust_type == RustType.STD_VEC_DEQUE: + return StdVecDequeProvider(valobj) + if rust_type == RustType.STD_BTREE_SET: + return StdBTreeSetProvider(valobj) + if rust_type == RustType.STD_BTREE_MAP: + return StdBTreeMapProvider(valobj) + if rust_type == RustType.STD_HASH_MAP: + if is_hashbrown_hashmap(valobj): + return StdHashMapProvider(valobj) + else: + return StdOldHashMapProvider(valobj) + if rust_type == RustType.STD_HASH_SET: + hash_map = valobj["map"] + if is_hashbrown_hashmap(hash_map): + return StdHashMapProvider(hash_map, show_values=False) + else: + return StdOldHashMapProvider(hash_map, show_values=False) + + if rust_type == RustType.STD_RC: + return StdRcProvider(valobj) + if rust_type == RustType.STD_ARC: + return StdRcProvider(valobj, is_atomic=True) + + if rust_type == RustType.STD_CELL: + return StdCellProvider(valobj) + if rust_type == RustType.STD_REF: + return StdRefProvider(valobj) + if rust_type == RustType.STD_REF_MUT: + return StdRefProvider(valobj) + if rust_type == RustType.STD_REF_CELL: + return StdRefCellProvider(valobj) + + return None diff --git a/src/etc/gdb_providers.py b/src/etc/gdb_providers.py new file mode 100644 index 00000000000..cec9c56a235 --- /dev/null +++ b/src/etc/gdb_providers.py @@ -0,0 +1,385 @@ +from sys import version_info + +import gdb +from gdb import lookup_type + +if version_info[0] >= 3: + xrange = range + +ZERO_FIELD = "__0" +FIRST_FIELD = "__1" + + +def unwrap_unique_or_non_null(unique_or_nonnull): + # BACKCOMPAT: rust 1.32 + # https://github.com/rust-lang/rust/commit/7a0911528058e87d22ea305695f4047572c5e067 + ptr = unique_or_nonnull["pointer"] + return ptr if ptr.type.code == gdb.TYPE_CODE_PTR else ptr[ZERO_FIELD] + + +class EnumProvider: + def __init__(self, valobj): + content = valobj[valobj.type.fields()[0]] + fields = content.type.fields() + self.empty = len(fields) == 0 + if not self.empty: + if len(fields) == 1: + discriminant = 0 + else: + discriminant = int(content[fields[0]]) + 1 + self.active_variant = content[fields[discriminant]] + self.name = fields[discriminant].name + self.full_name = "{}::{}".format(valobj.type.name, self.name) + else: + self.full_name = valobj.type.name + + def to_string(self): + return self.full_name + + def children(self): + if not self.empty: + yield self.name, self.active_variant + + +class StdStringProvider: + def __init__(self, valobj): + self.valobj = valobj + vec = valobj["vec"] + self.length = int(vec["len"]) + self.data_ptr = unwrap_unique_or_non_null(vec["buf"]["ptr"]) + + def to_string(self): + return self.data_ptr.lazy_string(encoding="utf-8", length=self.length) + + @staticmethod + def display_hint(): + return "string" + + +class StdOsStringProvider: + def __init__(self, valobj): + self.valobj = valobj + buf = self.valobj["inner"]["inner"] + is_windows = "Wtf8Buf" in buf.type.name + vec = buf[ZERO_FIELD] if is_windows else buf + + self.length = int(vec["len"]) + self.data_ptr = unwrap_unique_or_non_null(vec["buf"]["ptr"]) + + def to_string(self): + return self.data_ptr.lazy_string(encoding="utf-8", length=self.length) + + def display_hint(self): + return "string" + + +class StdStrProvider: + def __init__(self, valobj): + self.valobj = valobj + self.length = int(valobj["length"]) + self.data_ptr = valobj["data_ptr"] + + def to_string(self): + return self.data_ptr.lazy_string(encoding="utf-8", length=self.length) + + @staticmethod + def display_hint(): + return "string" + + +class StdVecProvider: + def __init__(self, valobj): + self.valobj = valobj + self.length = int(valobj["len"]) + self.data_ptr = unwrap_unique_or_non_null(valobj["buf"]["ptr"]) + + def to_string(self): + return "Vec(size={})".format(self.length) + + def children(self): + saw_inaccessible = False + for index in xrange(self.length): + element_ptr = self.data_ptr + index + if saw_inaccessible: + return + try: + # rust-lang/rust#64343: passing deref expr to `str` allows + # catching exception on garbage pointer + str(element_ptr.dereference()) + yield "[{}]".format(index), element_ptr.dereference() + except RuntimeError: + saw_inaccessible = True + yield str(index), "inaccessible" + + @staticmethod + def display_hint(): + return "array" + + +class StdVecDequeProvider: + def __init__(self, valobj): + self.valobj = valobj + self.head = int(valobj["head"]) + self.tail = int(valobj["tail"]) + self.cap = int(valobj["buf"]["cap"]) + self.data_ptr = unwrap_unique_or_non_null(valobj["buf"]["ptr"]) + if self.head >= self.tail: + self.size = self.head - self.tail + else: + self.size = self.cap + self.head - self.tail + + def to_string(self): + return "VecDeque(size={})".format(self.size) + + def children(self): + for index in xrange(0, self.size): + value = (self.data_ptr + ((self.tail + index) % self.cap)).dereference() + yield "[{}]".format(index), value + + @staticmethod + def display_hint(): + return "array" + + +class StdRcProvider: + def __init__(self, valobj, is_atomic=False): + self.valobj = valobj + self.is_atomic = is_atomic + self.ptr = unwrap_unique_or_non_null(valobj["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 + + def to_string(self): + if self.is_atomic: + return "Arc(strong={}, weak={})".format(int(self.strong), int(self.weak)) + else: + return "Rc(strong={}, weak={})".format(int(self.strong), int(self.weak)) + + def children(self): + yield "value", self.value + yield "strong", self.strong + yield "weak", self.weak + + +class StdCellProvider: + def __init__(self, valobj): + self.value = valobj["value"]["value"] + + def to_string(self): + return "Cell" + + def children(self): + yield "value", self.value + + +class StdRefProvider: + def __init__(self, valobj): + self.value = valobj["value"].dereference() + self.borrow = valobj["borrow"]["borrow"]["value"]["value"] + + def to_string(self): + borrow = int(self.borrow) + if borrow >= 0: + return "Ref(borrow={})".format(borrow) + else: + return "Ref(borrow_mut={})".format(-borrow) + + def children(self): + yield "*value", self.value + yield "borrow", self.borrow + + +class StdRefCellProvider: + def __init__(self, valobj): + self.value = valobj["value"]["value"] + self.borrow = valobj["borrow"]["value"]["value"] + + def to_string(self): + borrow = int(self.borrow) + if borrow >= 0: + return "RefCell(borrow={})".format(borrow) + else: + return "RefCell(borrow_mut={})".format(-borrow) + + def children(self): + yield "value", self.value + yield "borrow", self.borrow + + +# Yield each key (and optionally value) from a BoxedNode. +def children_of_node(boxed_node, height, want_values): + def cast_to_internal(node): + internal_type_name = str(node.type.target()).replace("LeafNode", "InternalNode", 1) + internal_type = lookup_type(internal_type_name) + return node.cast(internal_type.pointer()) + + node_ptr = unwrap_unique_or_non_null(boxed_node["ptr"]) + node_ptr = cast_to_internal(node_ptr) if height > 0 else node_ptr + leaf = node_ptr["data"] if height > 0 else node_ptr.dereference() + keys = leaf["keys"] + values = leaf["vals"] + length = int(leaf["len"]) + + for i in xrange(0, length + 1): + if height > 0: + child_ptr = node_ptr["edges"][i]["value"]["value"] + for child in children_of_node(child_ptr, height - 1, want_values): + yield child + if i < length: + if want_values: + yield keys[i]["value"]["value"], values[i]["value"]["value"] + else: + yield keys[i]["value"]["value"] + + +class StdBTreeSetProvider: + def __init__(self, valobj): + self.valobj = valobj + + def to_string(self): + return "BTreeSet(size={})".format(self.valobj["map"]["length"]) + + def children(self): + inner_map = self.valobj["map"] + if inner_map["length"] > 0: + root = inner_map["root"] + if "core::option::Option<" in root.type.name: + type_name = str(root.type.name).replace("core::option::Option<", "", 1)[:-1] + root = root.cast(gdb.lookup_type(type_name)) + + node_ptr = root["node"] + for i, child in enumerate(children_of_node(node_ptr, root["height"], False)): + yield "[{}]".format(i), child + + @staticmethod + def display_hint(): + return "array" + + +class StdBTreeMapProvider: + def __init__(self, valobj): + self.valobj = valobj + + def to_string(self): + return "BTreeMap(size={})".format(self.valobj["length"]) + + def children(self): + if self.valobj["length"] > 0: + root = self.valobj["root"] + if "core::option::Option<" in root.type.name: + type_name = str(root.type.name).replace("core::option::Option<", "", 1)[:-1] + root = root.cast(gdb.lookup_type(type_name)) + + node_ptr = root["node"] + for i, child in enumerate(children_of_node(node_ptr, root["height"], True)): + yield "key{}".format(i), child[0] + yield "val{}".format(i), child[1] + + @staticmethod + def display_hint(): + return "map" + + +# BACKCOMPAT: rust 1.35 +class StdOldHashMapProvider: + def __init__(self, valobj, show_values=True): + self.valobj = valobj + self.show_values = show_values + + self.table = self.valobj["table"] + self.size = int(self.table["size"]) + self.hashes = self.table["hashes"] + self.hash_uint_type = self.hashes.type + self.hash_uint_size = self.hashes.type.sizeof + self.modulo = 2 ** self.hash_uint_size + self.data_ptr = self.hashes[ZERO_FIELD]["pointer"] + + self.capacity_mask = int(self.table["capacity_mask"]) + self.capacity = (self.capacity_mask + 1) % self.modulo + + marker = self.table["marker"].type + self.pair_type = marker.template_argument(0) + self.pair_type_size = self.pair_type.sizeof + + self.valid_indices = [] + for idx in range(self.capacity): + data_ptr = self.data_ptr.cast(self.hash_uint_type.pointer()) + address = data_ptr + idx + hash_uint = address.dereference() + hash_ptr = hash_uint[ZERO_FIELD]["pointer"] + if int(hash_ptr) != 0: + self.valid_indices.append(idx) + + def to_string(self): + if self.show_values: + return "HashMap(size={})".format(self.size) + else: + return "HashSet(size={})".format(self.size) + + def children(self): + start = int(self.data_ptr) & ~1 + + hashes = self.hash_uint_size * self.capacity + align = self.pair_type_size + len_rounded_up = (((((hashes + align) % self.modulo - 1) % self.modulo) & ~( + (align - 1) % self.modulo)) % self.modulo - hashes) % self.modulo + + pairs_offset = hashes + len_rounded_up + pairs_start = gdb.Value(start + pairs_offset).cast(self.pair_type.pointer()) + + for index in range(self.size): + table_index = self.valid_indices[index] + idx = table_index & self.capacity_mask + element = (pairs_start + idx).dereference() + if self.show_values: + yield "key{}".format(index), element[ZERO_FIELD] + yield "val{}".format(index), element[FIRST_FIELD] + else: + yield "[{}]".format(index), element[ZERO_FIELD] + + def display_hint(self): + return "map" if self.show_values else "array" + + +class StdHashMapProvider: + def __init__(self, valobj, show_values=True): + self.valobj = valobj + self.show_values = show_values + + table = self.valobj["base"]["table"] + capacity = int(table["bucket_mask"]) + 1 + ctrl = table["ctrl"]["pointer"] + + self.size = int(table["items"]) + self.data_ptr = table["data"]["pointer"] + self.pair_type = self.data_ptr.dereference().type + + self.valid_indices = [] + for idx in range(capacity): + address = ctrl + idx + value = address.dereference() + is_presented = value & 128 == 0 + if is_presented: + self.valid_indices.append(idx) + + def to_string(self): + if self.show_values: + return "HashMap(size={})".format(self.size) + else: + return "HashSet(size={})".format(self.size) + + def children(self): + pairs_start = self.data_ptr + + for index in range(self.size): + idx = self.valid_indices[index] + element = (pairs_start + idx).dereference() + if self.show_values: + yield "key{}".format(index), element[ZERO_FIELD] + yield "val{}".format(index), element[FIRST_FIELD] + else: + yield "[{}]".format(index), element[ZERO_FIELD] + + def display_hint(self): + return "map" if self.show_values else "array" diff --git a/src/etc/gdb_rust_pretty_printing.py b/src/etc/gdb_rust_pretty_printing.py deleted file mode 100755 index d580329cb50..00000000000 --- a/src/etc/gdb_rust_pretty_printing.py +++ /dev/null @@ -1,466 +0,0 @@ -import gdb -import re -import sys -import debugger_pretty_printers_common as rustpp - -# We want a version of `range` which doesn't allocate an intermediate list, -# specifically it should use a lazy iterator. In Python 2 this was `xrange`, but -# if we're running with Python 3 then we need to use `range` instead. -if sys.version_info[0] >= 3: - xrange = range - -rust_enabled = 'set language rust' in gdb.execute('complete set language ru', to_string=True) - -# The btree pretty-printers fail in a confusing way unless -# https://sourceware.org/bugzilla/show_bug.cgi?id=21763 is fixed. -# This fix went in 8.1, so check for that. -# See https://github.com/rust-lang/rust/issues/56730 -gdb_81 = False -_match = re.search('([0-9]+)\\.([0-9]+)', gdb.VERSION) -if _match: - if int(_match.group(1)) > 8 or (int(_match.group(1)) == 8 and int(_match.group(2)) >= 1): - gdb_81 = True - -# =============================================================================== -# GDB Pretty Printing Module for Rust -# =============================================================================== - - -class GdbType(rustpp.Type): - - def __init__(self, ty): - super(GdbType, self).__init__() - self.ty = ty - self.fields = None - - def get_unqualified_type_name(self): - tag = self.ty.tag - - if tag is None: - return tag - - return rustpp.extract_type_name(tag).replace("&'static ", "&") - - def get_dwarf_type_kind(self): - if self.ty.code == gdb.TYPE_CODE_STRUCT: - return rustpp.DWARF_TYPE_CODE_STRUCT - - if self.ty.code == gdb.TYPE_CODE_UNION: - return rustpp.DWARF_TYPE_CODE_UNION - - if self.ty.code == gdb.TYPE_CODE_PTR: - return rustpp.DWARF_TYPE_CODE_PTR - - if self.ty.code == gdb.TYPE_CODE_ENUM: - return rustpp.DWARF_TYPE_CODE_ENUM - - def get_fields(self): - assert ((self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_STRUCT) or - (self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_UNION)) - if self.fields is None: - self.fields = list(self.ty.fields()) - return self.fields - - def get_wrapped_value(self): - return self.ty - - -class GdbValue(rustpp.Value): - def __init__(self, gdb_val): - super(GdbValue, self).__init__(GdbType(gdb_val.type)) - self.gdb_val = gdb_val - self.children = {} - - def get_child_at_index(self, index): - child = self.children.get(index) - if child is None: - gdb_field = get_field_at_index(self.gdb_val, index) - child = GdbValue(self.gdb_val[gdb_field]) - self.children[index] = child - return child - - def as_integer(self): - if self.gdb_val.type.code == gdb.TYPE_CODE_PTR: - as_str = rustpp.compat_str(self.gdb_val).split()[0] - return int(as_str, 0) - return int(self.gdb_val) - - def get_wrapped_value(self): - return self.gdb_val - - -def register_printers(objfile): - """Registers Rust pretty printers for the given objfile""" - objfile.pretty_printers.append(rust_pretty_printer_lookup_function) - - -def rust_pretty_printer_lookup_function(gdb_val): - """ - Returns the correct Rust pretty printer for the given value - if there is one - """ - - val = GdbValue(gdb_val) - type_kind = val.type.get_type_kind() - - if type_kind == rustpp.TYPE_KIND_SLICE: - return RustSlicePrinter(val) - - if type_kind == rustpp.TYPE_KIND_STD_VEC: - return RustStdVecPrinter(val) - - if type_kind == rustpp.TYPE_KIND_STD_VECDEQUE: - return RustStdVecDequePrinter(val) - - if type_kind == rustpp.TYPE_KIND_STD_BTREESET and gdb_81: - return RustStdBTreeSetPrinter(val) - - if type_kind == rustpp.TYPE_KIND_STD_BTREEMAP and gdb_81: - return RustStdBTreeMapPrinter(val) - - if type_kind == rustpp.TYPE_KIND_STD_STRING: - return RustStdStringPrinter(val) - - if type_kind == rustpp.TYPE_KIND_OS_STRING: - return RustOsStringPrinter(val) - - # Checks after this point should only be for "compiler" types -- - # things that gdb's Rust language support knows about. - if rust_enabled: - return None - - if type_kind == rustpp.TYPE_KIND_EMPTY: - return RustEmptyPrinter(val) - - if type_kind == rustpp.TYPE_KIND_REGULAR_STRUCT: - return RustStructPrinter(val, - omit_first_field=False, - omit_type_name=False, - is_tuple_like=False) - - if type_kind == rustpp.TYPE_KIND_STRUCT_VARIANT: - return RustStructPrinter(val, - omit_first_field=True, - omit_type_name=False, - is_tuple_like=False) - - if type_kind == rustpp.TYPE_KIND_STR_SLICE: - return RustStringSlicePrinter(val) - - if type_kind == rustpp.TYPE_KIND_TUPLE: - return RustStructPrinter(val, - omit_first_field=False, - omit_type_name=True, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_TUPLE_STRUCT: - return RustStructPrinter(val, - omit_first_field=False, - omit_type_name=False, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_CSTYLE_VARIANT: - return RustCStyleVariantPrinter(val.get_child_at_index(0)) - - if type_kind == rustpp.TYPE_KIND_TUPLE_VARIANT: - return RustStructPrinter(val, - omit_first_field=True, - omit_type_name=False, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_SINGLETON_ENUM: - variant = get_field_at_index(gdb_val, 0) - return rust_pretty_printer_lookup_function(gdb_val[variant]) - - if type_kind == rustpp.TYPE_KIND_REGULAR_ENUM: - # This is a regular enum, extract the discriminant - discriminant_val = rustpp.get_discriminant_value_as_integer(val) - variant = get_field_at_index(gdb_val, discriminant_val) - return rust_pretty_printer_lookup_function(gdb_val[variant]) - - if type_kind == rustpp.TYPE_KIND_COMPRESSED_ENUM: - encoded_enum_info = rustpp.EncodedEnumInfo(val) - if encoded_enum_info.is_null_variant(): - return IdentityPrinter(encoded_enum_info.get_null_variant_name()) - - non_null_val = encoded_enum_info.get_non_null_variant_val() - return rust_pretty_printer_lookup_function(non_null_val.get_wrapped_value()) - - # No pretty printer has been found - return None - - -# =------------------------------------------------------------------------------ -# Pretty Printer Classes -# =------------------------------------------------------------------------------ -class RustEmptyPrinter(object): - def __init__(self, val): - self.__val = val - - def to_string(self): - return self.__val.type.get_unqualified_type_name() - - -class RustStructPrinter(object): - def __init__(self, val, omit_first_field, omit_type_name, is_tuple_like): - self.__val = val - self.__omit_first_field = omit_first_field - self.__omit_type_name = omit_type_name - self.__is_tuple_like = is_tuple_like - - def to_string(self): - if self.__omit_type_name: - return None - return self.__val.type.get_unqualified_type_name() - - def children(self): - cs = [] - wrapped_value = self.__val.get_wrapped_value() - - for number, field in enumerate(self.__val.type.get_fields()): - field_value = wrapped_value[field.name] - if self.__is_tuple_like: - cs.append((str(number), field_value)) - else: - cs.append((field.name, field_value)) - - if self.__omit_first_field: - cs = cs[1:] - - return cs - - def display_hint(self): - if self.__is_tuple_like: - return "array" - else: - return "" - - -class RustSlicePrinter(object): - def __init__(self, val): - self.__val = val - - @staticmethod - def display_hint(): - return "array" - - def to_string(self): - (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(self.__val) - return (self.__val.type.get_unqualified_type_name() + - ("(len: %i)" % length)) - - def children(self): - (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(self.__val) - assert data_ptr.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_PTR - raw_ptr = data_ptr.get_wrapped_value() - - for index in xrange(0, length): - yield (str(index), (raw_ptr + index).dereference()) - - -class RustStringSlicePrinter(object): - def __init__(self, val): - self.__val = val - - def to_string(self): - (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(self.__val) - raw_ptr = data_ptr.get_wrapped_value() - return raw_ptr.lazy_string(encoding="utf-8", length=length) - - def display_hint(self): - return "string" - - -class RustStdVecPrinter(object): - def __init__(self, val): - self.__val = val - - @staticmethod - def display_hint(): - return "array" - - def to_string(self): - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(self.__val) - return (self.__val.type.get_unqualified_type_name() + - ("(len: %i, cap: %i)" % (length, cap))) - - def children(self): - saw_inaccessible = False - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(self.__val) - gdb_ptr = data_ptr.get_wrapped_value() - for index in xrange(0, length): - if saw_inaccessible: - return - try: - # rust-lang/rust#64343: passing deref expr to `str` allows - # catching exception on garbage pointer - str((gdb_ptr + index).dereference()) - yield (str(index), (gdb_ptr + index).dereference()) - except RuntimeError: - saw_inaccessible = True - yield (str(index), "inaccessible") - - -class RustStdVecDequePrinter(object): - def __init__(self, val): - self.__val = val - - @staticmethod - def display_hint(): - return "array" - - def to_string(self): - (tail, head, data_ptr, cap) = \ - rustpp.extract_tail_head_ptr_and_cap_from_std_vecdeque(self.__val) - if head >= tail: - size = head - tail - else: - size = cap + head - tail - return (self.__val.type.get_unqualified_type_name() + - ("(len: %i, cap: %i)" % (size, cap))) - - def children(self): - (tail, head, data_ptr, cap) = \ - rustpp.extract_tail_head_ptr_and_cap_from_std_vecdeque(self.__val) - gdb_ptr = data_ptr.get_wrapped_value() - if head >= tail: - size = head - tail - else: - size = cap + head - tail - for index in xrange(0, size): - yield (str(index), (gdb_ptr + ((tail + index) % cap)).dereference()) - - -# Yield each key (and optionally value) from a BoxedNode. -def children_of_node(boxed_node, height, want_values): - node_ptr = boxed_node['ptr']['pointer'] - if height > 0: - type_name = str(node_ptr.type.target()).replace('LeafNode', 'InternalNode', 1) - node_type = gdb.lookup_type(type_name) - node_ptr = node_ptr.cast(node_type.pointer()) - leaf = node_ptr['data'] - else: - leaf = node_ptr.dereference() - keys = leaf['keys'] - if want_values: - values = leaf['vals'] - length = int(leaf['len']) - for i in xrange(0, length + 1): - if height > 0: - child_ptr = node_ptr['edges'][i]['value']['value'] - for child in children_of_node(child_ptr, height - 1, want_values): - yield child - if i < length: - if want_values: - yield (keys[i]['value']['value'], values[i]['value']['value']) - else: - yield keys[i]['value']['value'] - - -class RustStdBTreeSetPrinter(object): - def __init__(self, val): - self.__val = val - - @staticmethod - def display_hint(): - return "array" - - def to_string(self): - return (self.__val.type.get_unqualified_type_name() + - ("(len: %i)" % self.__val.get_wrapped_value()['map']['length'])) - - def children(self): - prev_idx = None - innermap = GdbValue(self.__val.get_wrapped_value()['map']) - if innermap.get_wrapped_value()['length'] > 0: - root = GdbValue(innermap.get_wrapped_value()['root']) - type_name = str(root.type.ty.name).replace('core::option::Option<', '', 1)[:-1] - root = root.get_wrapped_value().cast(gdb.lookup_type(type_name)) - node_ptr = root['node'] - i = 0 - for child in children_of_node(node_ptr, root['height'], False): - yield (str(i), child) - i = i + 1 - - -class RustStdBTreeMapPrinter(object): - def __init__(self, val): - self.__val = val - - @staticmethod - def display_hint(): - return "map" - - def to_string(self): - return (self.__val.type.get_unqualified_type_name() + - ("(len: %i)" % self.__val.get_wrapped_value()['length'])) - - def children(self): - if self.__val.get_wrapped_value()['length'] > 0: - root = GdbValue(self.__val.get_wrapped_value()['root']) - type_name = str(root.type.ty.name).replace('core::option::Option<', '', 1)[:-1] - root = root.get_wrapped_value().cast(gdb.lookup_type(type_name)) - node_ptr = root['node'] - i = 0 - for child in children_of_node(node_ptr, root['height'], True): - yield (str(i), child[0]) - yield (str(i), child[1]) - i = i + 1 - - -class RustStdStringPrinter(object): - def __init__(self, val): - self.__val = val - - def to_string(self): - vec = self.__val.get_child_at_index(0) - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(vec) - return data_ptr.get_wrapped_value().lazy_string(encoding="utf-8", - length=length) - - def display_hint(self): - return "string" - - -class RustOsStringPrinter(object): - def __init__(self, val): - self.__val = val - - def to_string(self): - buf = self.__val.get_child_at_index(0) - vec = buf.get_child_at_index(0) - if vec.type.get_unqualified_type_name() == "Wtf8Buf": - vec = vec.get_child_at_index(0) - - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec( - vec) - return data_ptr.get_wrapped_value().lazy_string(length=length) - - def display_hint(self): - return "string" - - -class RustCStyleVariantPrinter(object): - def __init__(self, val): - assert val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_ENUM - self.__val = val - - def to_string(self): - return str(self.__val.get_wrapped_value()) - - -class IdentityPrinter(object): - def __init__(self, string): - self.string = string - - def to_string(self): - return self.string - - -def get_field_at_index(gdb_val, index): - i = 0 - for field in gdb_val.type.fields(): - if i == index: - return field - i += 1 - return None diff --git a/src/etc/lldb_commands b/src/etc/lldb_commands new file mode 100644 index 00000000000..f470c62d899 --- /dev/null +++ b/src/etc/lldb_commands @@ -0,0 +1,19 @@ +command script import \"$RUSTC_SYSROOT/lib/rustlib/etc/lldb_lookup.py\" +type synthetic add -l lldb_lookup.synthetic_lookup -x \".*\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)String$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^&str$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^&\\[.+\\]$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(std::ffi::([a-z_]+::)+)OsString$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)Vec<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)VecDeque<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)BTreeSet<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)BTreeMap<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(std::collections::([a-z_]+::)+)HashMap<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(std::collections::([a-z_]+::)+)HashSet<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)Rc<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(alloc::([a-z_]+::)+)Arc<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(core::([a-z_]+::)+)Cell<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(core::([a-z_]+::)+)Ref<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(core::([a-z_]+::)+)RefMut<.+>$\" --category Rust +type summary add -F lldb_lookup.summary_lookup -e -x -h \"^(core::([a-z_]+::)+)RefCell<.+>$\" --category Rust +type category enable Rust diff --git a/src/etc/lldb_lookup.py b/src/etc/lldb_lookup.py new file mode 100644 index 00000000000..13420fbaf0a --- /dev/null +++ b/src/etc/lldb_lookup.py @@ -0,0 +1,115 @@ +import lldb + +from lldb_providers import * +from rust_types import RustType, classify_struct, classify_union + + +# BACKCOMPAT: rust 1.35 +def is_hashbrown_hashmap(hash_map): + return len(hash_map.type.fields) == 1 + + +def classify_rust_type(type): + type_class = type.GetTypeClass() + if type_class == lldb.eTypeClassStruct: + return classify_struct(type.name, type.fields) + if type_class == lldb.eTypeClassUnion: + return classify_union(type.fields) + + return RustType.OTHER + + +def summary_lookup(valobj, dict): + # type: (SBValue, dict) -> str + """Returns the summary provider for the given value""" + rust_type = classify_rust_type(valobj.GetType()) + + if rust_type == RustType.STD_STRING: + return StdStringSummaryProvider(valobj, dict) + if rust_type == RustType.STD_OS_STRING: + return StdOsStringSummaryProvider(valobj, dict) + if rust_type == RustType.STD_STR: + return StdStrSummaryProvider(valobj, dict) + + if rust_type == RustType.STD_VEC: + return SizeSummaryProvider(valobj, dict) + if rust_type == RustType.STD_VEC_DEQUE: + return SizeSummaryProvider(valobj, dict) + if rust_type == RustType.STD_SLICE: + return SizeSummaryProvider(valobj, dict) + + if rust_type == RustType.STD_HASH_MAP: + return SizeSummaryProvider(valobj, dict) + if rust_type == RustType.STD_HASH_SET: + return SizeSummaryProvider(valobj, dict) + + if rust_type == RustType.STD_RC: + return StdRcSummaryProvider(valobj, dict) + if rust_type == RustType.STD_ARC: + return StdRcSummaryProvider(valobj, dict) + + if rust_type == RustType.STD_REF: + return StdRefSummaryProvider(valobj, dict) + if rust_type == RustType.STD_REF_MUT: + return StdRefSummaryProvider(valobj, dict) + if rust_type == RustType.STD_REF_CELL: + return StdRefSummaryProvider(valobj, dict) + + return "" + + +def synthetic_lookup(valobj, dict): + # type: (SBValue, dict) -> object + """Returns the synthetic provider for the given value""" + rust_type = classify_rust_type(valobj.GetType()) + + if rust_type == RustType.STRUCT: + return StructSyntheticProvider(valobj, dict) + if rust_type == RustType.STRUCT_VARIANT: + return StructSyntheticProvider(valobj, dict, is_variant=True) + if rust_type == RustType.TUPLE: + return TupleSyntheticProvider(valobj, dict) + if rust_type == RustType.TUPLE_VARIANT: + return TupleSyntheticProvider(valobj, dict, is_variant=True) + if rust_type == RustType.EMPTY: + return EmptySyntheticProvider(valobj, dict) + if rust_type == RustType.REGULAR_ENUM: + discriminant = valobj.GetChildAtIndex(0).GetChildAtIndex(0).GetValueAsUnsigned() + return synthetic_lookup(valobj.GetChildAtIndex(discriminant), dict) + if rust_type == RustType.SINGLETON_ENUM: + return synthetic_lookup(valobj.GetChildAtIndex(0), dict) + + if rust_type == RustType.STD_VEC: + return StdVecSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_VEC_DEQUE: + return StdVecDequeSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_SLICE: + return StdSliceSyntheticProvider(valobj, dict) + + if rust_type == RustType.STD_HASH_MAP: + if is_hashbrown_hashmap(valobj): + return StdHashMapSyntheticProvider(valobj, dict) + else: + return StdOldHashMapSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_HASH_SET: + hash_map = valobj.GetChildAtIndex(0) + if is_hashbrown_hashmap(hash_map): + return StdHashMapSyntheticProvider(hash_map, dict, show_values=False) + else: + return StdOldHashMapSyntheticProvider(hash_map, dict, show_values=False) + + if rust_type == RustType.STD_RC: + return StdRcSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_ARC: + return StdRcSyntheticProvider(valobj, dict, is_atomic=True) + + if rust_type == RustType.STD_CELL: + return StdCellSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_REF: + return StdRefSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_REF_MUT: + return StdRefSyntheticProvider(valobj, dict) + if rust_type == RustType.STD_REF_CELL: + return StdRefSyntheticProvider(valobj, dict, is_cell=True) + + return DefaultSynthteticProvider(valobj, dict) diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py new file mode 100644 index 00000000000..3c7817b3a61 --- /dev/null +++ b/src/etc/lldb_providers.py @@ -0,0 +1,715 @@ +import sys + +from lldb import SBValue, SBData, SBError, eBasicTypeLong, eBasicTypeUnsignedLong, \ + eBasicTypeUnsignedChar + +# from lldb.formatters import Logger + +#################################################################################################### +# This file contains two kinds of pretty-printers: summary and synthetic. +# +# Important classes from LLDB module: +# SBValue: the value of a variable, a register, or an expression +# SBType: the data type; each SBValue has a corresponding SBType +# +# Summary provider is a function with the type `(SBValue, dict) -> str`. +# The first parameter is the object encapsulating the actual variable being displayed; +# The second parameter is an internal support parameter used by LLDB, and you should not touch it. +# +# Synthetic children is the way to provide a children-based representation of the object's value. +# Synthetic provider is a class that implements the following interface: +# +# class SyntheticChildrenProvider: +# def __init__(self, SBValue, dict) +# def num_children(self) +# def get_child_index(self, str) +# def get_child_at_index(self, int) +# def update(self) +# def has_children(self) +# def get_value(self) +# +# +# You can find more information and examples here: +# 1. https://lldb.llvm.org/varformats.html +# 2. https://lldb.llvm.org/python-reference.html +# 3. https://lldb.llvm.org/python_reference/lldb.formatters.cpp.libcxx-pysrc.html +# 4. https://github.com/llvm-mirror/lldb/tree/master/examples/summaries/cocoa +#################################################################################################### + +PY3 = sys.version_info[0] == 3 + + +class ValueBuilder: + def __init__(self, valobj): + # type: (SBValue) -> ValueBuilder + self.valobj = valobj + process = valobj.GetProcess() + self.endianness = process.GetByteOrder() + self.pointer_size = process.GetAddressByteSize() + + def from_int(self, name, value): + # type: (str, int) -> SBValue + type = self.valobj.GetType().GetBasicType(eBasicTypeLong) + data = SBData.CreateDataFromSInt64Array(self.endianness, self.pointer_size, [value]) + return self.valobj.CreateValueFromData(name, data, type) + + def from_uint(self, name, value): + # type: (str, int) -> SBValue + type = self.valobj.GetType().GetBasicType(eBasicTypeUnsignedLong) + data = SBData.CreateDataFromUInt64Array(self.endianness, self.pointer_size, [value]) + return self.valobj.CreateValueFromData(name, data, type) + + +def unwrap_unique_or_non_null(unique_or_nonnull): + # BACKCOMPAT: rust 1.32 + # https://github.com/rust-lang/rust/commit/7a0911528058e87d22ea305695f4047572c5e067 + ptr = unique_or_nonnull.GetChildMemberWithName("pointer") + return ptr if ptr.TypeIsPointerType() else ptr.GetChildAtIndex(0) + + +class DefaultSynthteticProvider: + def __init__(self, valobj, dict): + # type: (SBValue, dict) -> DefaultSynthteticProvider + # logger = Logger.Logger() + # logger >> "Default synthetic provider for " + str(valobj.GetName()) + self.valobj = valobj + + def num_children(self): + # type: () -> int + return self.valobj.GetNumChildren() + + def get_child_index(self, name): + # type: (str) -> int + return self.valobj.GetIndexOfChildWithName(name) + + def get_child_at_index(self, index): + # type: (int) -> SBValue + return self.valobj.GetChildAtIndex(index) + + def update(self): + # type: () -> None + pass + + def has_children(self): + # type: () -> bool + return self.valobj.MightHaveChildren() + + +class EmptySyntheticProvider: + def __init__(self, valobj, dict): + # type: (SBValue, dict) -> EmptySyntheticProvider + # logger = Logger.Logger() + # logger >> "[EmptySyntheticProvider] for " + str(valobj.GetName()) + self.valobj = valobj + + def num_children(self): + # type: () -> int + return 0 + + def get_child_index(self, name): + # type: (str) -> int + return None + + def get_child_at_index(self, index): + # type: (int) -> SBValue + return None + + def update(self): + # type: () -> None + pass + + def has_children(self): + # type: () -> bool + return False + + +def SizeSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + return 'size=' + str(valobj.GetNumChildren()) + + +def vec_to_string(vec): + length = vec.GetNumChildren() + chars = [vec.GetChildAtIndex(i).GetValueAsUnsigned() for i in range(length)] + return bytes(chars).decode(errors='replace') if PY3 else "".join(chr(char) for char in chars) + + +def StdStringSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + # logger = Logger.Logger() + # logger >> "[StdStringSummaryProvider] for " + str(valobj.GetName()) + vec = valobj.GetChildAtIndex(0) + return '"%s"' % vec_to_string(vec) + + +def StdOsStringSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + # logger = Logger.Logger() + # logger >> "[StdOsStringSummaryProvider] for " + str(valobj.GetName()) + buf = valobj.GetChildAtIndex(0).GetChildAtIndex(0) + is_windows = "Wtf8Buf" in buf.type.name + vec = buf.GetChildAtIndex(0) if is_windows else buf + return '"%s"' % vec_to_string(vec) + + +def StdStrSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + # logger = Logger.Logger() + # logger >> "[StdStrSummaryProvider] for " + str(valobj.GetName()) + + length = valobj.GetChildMemberWithName("length").GetValueAsUnsigned() + if length == 0: + return '""' + + data_ptr = valobj.GetChildMemberWithName("data_ptr") + + start = data_ptr.GetValueAsUnsigned() + error = SBError() + process = data_ptr.GetProcess() + data = process.ReadMemory(start, length, error) + data = data.decode(encoding='UTF-8') if PY3 else data + return '"%s"' % data + + +class StructSyntheticProvider: + """Pretty-printer for structs and struct enum variants""" + + def __init__(self, valobj, dict, is_variant=False): + # type: (SBValue, dict, bool) -> StructSyntheticProvider + # logger = Logger.Logger() + self.valobj = valobj + self.is_variant = is_variant + self.type = valobj.GetType() + self.fields = {} + + if is_variant: + self.fields_count = self.type.GetNumberOfFields() - 1 + real_fields = self.type.fields[1:] + else: + self.fields_count = self.type.GetNumberOfFields() + real_fields = self.type.fields + + for number, field in enumerate(real_fields): + self.fields[field.name] = number + + def num_children(self): + # type: () -> int + return self.fields_count + + def get_child_index(self, name): + # type: (str) -> int + return self.fields.get(name, -1) + + def get_child_at_index(self, index): + # type: (int) -> SBValue + if self.is_variant: + field = self.type.GetFieldAtIndex(index + 1) + else: + field = self.type.GetFieldAtIndex(index) + return self.valobj.GetChildMemberWithName(field.name) + + def update(self): + # type: () -> None + pass + + def has_children(self): + # type: () -> bool + return True + + +class TupleSyntheticProvider: + """Pretty-printer for tuples and tuple enum variants""" + + def __init__(self, valobj, dict, is_variant=False): + # type: (SBValue, dict, bool) -> TupleSyntheticProvider + # logger = Logger.Logger() + self.valobj = valobj + self.is_variant = is_variant + self.type = valobj.GetType() + + if is_variant: + self.size = self.type.GetNumberOfFields() - 1 + else: + self.size = self.type.GetNumberOfFields() + + def num_children(self): + # type: () -> int + return self.size + + def get_child_index(self, name): + # type: (str) -> int + if name.isdigit(): + return int(name) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + if self.is_variant: + field = self.type.GetFieldAtIndex(index + 1) + else: + field = self.type.GetFieldAtIndex(index) + element = self.valobj.GetChildMemberWithName(field.name) + return self.valobj.CreateValueFromData(str(index), element.GetData(), element.GetType()) + + def update(self): + # type: () -> None + pass + + def has_children(self): + # type: () -> bool + return True + + +class StdVecSyntheticProvider: + """Pretty-printer for alloc::vec::Vec + + struct Vec { buf: RawVec, len: usize } + struct RawVec { ptr: Unique, cap: usize, ... } + rust 1.31.1: struct Unique { pointer: NonZero<*const T>, ... } + rust 1.33.0: struct Unique { pointer: *const T, ... } + struct NonZero(T) + """ + + def __init__(self, valobj, dict): + # type: (SBValue, dict) -> StdVecSyntheticProvider + # logger = Logger.Logger() + # logger >> "[StdVecSyntheticProvider] for " + str(valobj.GetName()) + self.valobj = valobj + self.update() + + def num_children(self): + # type: () -> int + return self.length + + def get_child_index(self, name): + # type: (str) -> int + index = name.lstrip('[').rstrip(']') + if index.isdigit(): + return int(index) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + start = self.data_ptr.GetValueAsUnsigned() + address = start + index * self.element_type_size + element = self.data_ptr.CreateValueFromAddress("[%s]" % index, address, self.element_type) + return element + + def update(self): + # type: () -> None + self.length = self.valobj.GetChildMemberWithName("len").GetValueAsUnsigned() + self.buf = self.valobj.GetChildMemberWithName("buf") + + self.data_ptr = unwrap_unique_or_non_null(self.buf.GetChildMemberWithName("ptr")) + + self.element_type = self.data_ptr.GetType().GetPointeeType() + self.element_type_size = self.element_type.GetByteSize() + + def has_children(self): + # type: () -> bool + return True + + +class StdSliceSyntheticProvider: + def __init__(self, valobj, dict): + self.valobj = valobj + self.update() + + def num_children(self): + # type: () -> int + return self.length + + def get_child_index(self, name): + # type: (str) -> int + index = name.lstrip('[').rstrip(']') + if index.isdigit(): + return int(index) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + start = self.data_ptr.GetValueAsUnsigned() + address = start + index * self.element_type_size + element = self.data_ptr.CreateValueFromAddress("[%s]" % index, address, self.element_type) + return element + + def update(self): + # type: () -> None + self.length = self.valobj.GetChildMemberWithName("length").GetValueAsUnsigned() + self.data_ptr = self.valobj.GetChildMemberWithName("data_ptr") + + self.element_type = self.data_ptr.GetType().GetPointeeType() + self.element_type_size = self.element_type.GetByteSize() + + def has_children(self): + # type: () -> bool + return True + + +class StdVecDequeSyntheticProvider: + """Pretty-printer for alloc::collections::vec_deque::VecDeque + + struct VecDeque { tail: usize, head: usize, buf: RawVec } + """ + + def __init__(self, valobj, dict): + # type: (SBValue, dict) -> StdVecDequeSyntheticProvider + # logger = Logger.Logger() + # logger >> "[StdVecDequeSyntheticProvider] for " + str(valobj.GetName()) + self.valobj = valobj + self.update() + + def num_children(self): + # type: () -> int + return self.size + + def get_child_index(self, name): + # type: (str) -> int + index = name.lstrip('[').rstrip(']') + if index.isdigit() and self.tail <= index and (self.tail + index) % self.cap < self.head: + return int(index) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + start = self.data_ptr.GetValueAsUnsigned() + address = start + ((index + self.tail) % self.cap) * self.element_type_size + element = self.data_ptr.CreateValueFromAddress("[%s]" % index, address, self.element_type) + return element + + def update(self): + # type: () -> None + self.head = self.valobj.GetChildMemberWithName("head").GetValueAsUnsigned() + self.tail = self.valobj.GetChildMemberWithName("tail").GetValueAsUnsigned() + self.buf = self.valobj.GetChildMemberWithName("buf") + self.cap = self.buf.GetChildMemberWithName("cap").GetValueAsUnsigned() + if self.head >= self.tail: + self.size = self.head - self.tail + else: + self.size = self.cap + self.head - self.tail + + self.data_ptr = unwrap_unique_or_non_null(self.buf.GetChildMemberWithName("ptr")) + + self.element_type = self.data_ptr.GetType().GetPointeeType() + self.element_type_size = self.element_type.GetByteSize() + + def has_children(self): + # type: () -> bool + return True + + +# BACKCOMPAT: rust 1.35 +class StdOldHashMapSyntheticProvider: + """Pretty-printer for std::collections::hash::map::HashMap + + struct HashMap {..., table: RawTable, ... } + struct RawTable { capacity_mask: usize, size: usize, hashes: TaggedHashUintPtr, ... } + """ + + def __init__(self, valobj, dict, show_values=True): + # type: (SBValue, dict, bool) -> StdOldHashMapSyntheticProvider + self.valobj = valobj + self.show_values = show_values + self.update() + + def num_children(self): + # type: () -> int + return self.size + + def get_child_index(self, name): + # type: (str) -> int + index = name.lstrip('[').rstrip(']') + if index.isdigit(): + return int(index) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + # logger = Logger.Logger() + start = self.data_ptr.GetValueAsUnsigned() & ~1 + + # See `libstd/collections/hash/table.rs:raw_bucket_at + hashes = self.hash_uint_size * self.capacity + align = self.pair_type_size + # See `libcore/alloc.rs:padding_needed_for` + len_rounded_up = (((((hashes + align) % self.modulo - 1) % self.modulo) & ~( + (align - 1) % self.modulo)) % self.modulo - hashes) % self.modulo + # len_rounded_up = ((hashes + align - 1) & ~(align - 1)) - hashes + + pairs_offset = hashes + len_rounded_up + pairs_start = start + pairs_offset + + table_index = self.valid_indices[index] + idx = table_index & self.capacity_mask + address = pairs_start + idx * self.pair_type_size + element = self.data_ptr.CreateValueFromAddress("[%s]" % index, address, self.pair_type) + if self.show_values: + return element + else: + key = element.GetChildAtIndex(0) + return self.valobj.CreateValueFromData("[%s]" % index, key.GetData(), key.GetType()) + + def update(self): + # type: () -> None + # logger = Logger.Logger() + + self.table = self.valobj.GetChildMemberWithName("table") # type: SBValue + self.size = self.table.GetChildMemberWithName("size").GetValueAsUnsigned() + self.hashes = self.table.GetChildMemberWithName("hashes") + self.hash_uint_type = self.hashes.GetType() + self.hash_uint_size = self.hashes.GetType().GetByteSize() + self.modulo = 2 ** self.hash_uint_size + self.data_ptr = self.hashes.GetChildAtIndex(0).GetChildAtIndex(0) + + self.capacity_mask = self.table.GetChildMemberWithName("capacity_mask").GetValueAsUnsigned() + self.capacity = (self.capacity_mask + 1) % self.modulo + + marker = self.table.GetChildMemberWithName("marker").GetType() # type: SBType + self.pair_type = marker.template_args[0] + self.pair_type_size = self.pair_type.GetByteSize() + + self.valid_indices = [] + for idx in range(self.capacity): + address = self.data_ptr.GetValueAsUnsigned() + idx * self.hash_uint_size + hash_uint = self.data_ptr.CreateValueFromAddress("[%s]" % idx, address, + self.hash_uint_type) + hash_ptr = hash_uint.GetChildAtIndex(0).GetChildAtIndex(0) + if hash_ptr.GetValueAsUnsigned() != 0: + self.valid_indices.append(idx) + + # logger >> "Valid indices: {}".format(str(self.valid_indices)) + + def has_children(self): + # type: () -> bool + return True + + +class StdHashMapSyntheticProvider: + """Pretty-printer for hashbrown's HashMap""" + + def __init__(self, valobj, dict, show_values=True): + # type: (SBValue, dict, bool) -> StdHashMapSyntheticProvider + self.valobj = valobj + self.show_values = show_values + self.update() + + def num_children(self): + # type: () -> int + return self.size + + def get_child_index(self, name): + # type: (str) -> int + index = name.lstrip('[').rstrip(']') + if index.isdigit(): + return int(index) + else: + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + pairs_start = self.data_ptr.GetValueAsUnsigned() + idx = self.valid_indices[index] + address = pairs_start + idx * self.pair_type_size + element = self.data_ptr.CreateValueFromAddress("[%s]" % index, address, self.pair_type) + if self.show_values: + return element + else: + key = element.GetChildAtIndex(0) + return self.valobj.CreateValueFromData("[%s]" % index, key.GetData(), key.GetType()) + + def update(self): + # type: () -> None + table = self.valobj.GetChildMemberWithName("base").GetChildMemberWithName("table") + capacity = table.GetChildMemberWithName("bucket_mask").GetValueAsUnsigned() + 1 + ctrl = table.GetChildMemberWithName("ctrl").GetChildAtIndex(0) + + self.size = table.GetChildMemberWithName("items").GetValueAsUnsigned() + self.data_ptr = table.GetChildMemberWithName("data").GetChildAtIndex(0) + self.pair_type = self.data_ptr.Dereference().GetType() + self.pair_type_size = self.pair_type.GetByteSize() + + u8_type = self.valobj.GetTarget().GetBasicType(eBasicTypeUnsignedChar) + u8_type_size = self.valobj.GetTarget().GetBasicType(eBasicTypeUnsignedChar).GetByteSize() + + self.valid_indices = [] + for idx in range(capacity): + address = ctrl.GetValueAsUnsigned() + idx * u8_type_size + value = ctrl.CreateValueFromAddress("ctrl[%s]" % idx, address, + u8_type).GetValueAsUnsigned() + is_present = value & 128 == 0 + if is_present: + self.valid_indices.append(idx) + + def has_children(self): + # type: () -> bool + return True + + +def StdRcSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + strong = valobj.GetChildMemberWithName("strong").GetValueAsUnsigned() + weak = valobj.GetChildMemberWithName("weak").GetValueAsUnsigned() + return "strong={}, weak={}".format(strong, weak) + + +class StdRcSyntheticProvider: + """Pretty-printer for alloc::rc::Rc and alloc::sync::Arc + + struct Rc { ptr: NonNull>, ... } + rust 1.31.1: struct NonNull { pointer: NonZero<*const T> } + rust 1.33.0: struct NonNull { pointer: *const T } + struct NonZero(T) + struct RcBox { strong: Cell, weak: Cell, value: T } + struct Cell { value: UnsafeCell } + struct UnsafeCell { value: T } + + struct Arc { ptr: NonNull>, ... } + struct ArcInner { strong: atomic::AtomicUsize, weak: atomic::AtomicUsize, data: T } + struct AtomicUsize { v: UnsafeCell } + """ + + 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.value = self.ptr.GetChildMemberWithName("data" if is_atomic else "value") + + self.strong = self.ptr.GetChildMemberWithName("strong").GetChildAtIndex( + 0).GetChildMemberWithName("value") + self.weak = self.ptr.GetChildMemberWithName("weak").GetChildAtIndex( + 0).GetChildMemberWithName("value") + + self.value_builder = ValueBuilder(valobj) + + self.update() + + def num_children(self): + # type: () -> int + # Actually there are 3 children, but only the `value` should be shown as a child + return 1 + + def get_child_index(self, name): + # type: (str) -> int + if name == "value": + return 0 + if name == "strong": + return 1 + if name == "weak": + return 2 + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + if index == 0: + return self.value + if index == 1: + return self.value_builder.from_uint("strong", self.strong_count) + if index == 2: + return self.value_builder.from_uint("weak", self.weak_count) + + return None + + def update(self): + # type: () -> None + self.strong_count = self.strong.GetValueAsUnsigned() + self.weak_count = self.weak.GetValueAsUnsigned() - 1 + + def has_children(self): + # type: () -> bool + return True + + +class StdCellSyntheticProvider: + """Pretty-printer for std::cell::Cell""" + + def __init__(self, valobj, dict): + # type: (SBValue, dict) -> StdCellSyntheticProvider + self.valobj = valobj + self.value = valobj.GetChildMemberWithName("value").GetChildAtIndex(0) + + def num_children(self): + # type: () -> int + return 1 + + def get_child_index(self, name): + # type: (str) -> int + if name == "value": + return 0 + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + if index == 0: + return self.value + return None + + def update(self): + # type: () -> None + pass + + def has_children(self): + # type: () -> bool + return True + + +def StdRefSummaryProvider(valobj, dict): + # type: (SBValue, dict) -> str + borrow = valobj.GetChildMemberWithName("borrow").GetValueAsSigned() + return "borrow={}".format(borrow) if borrow >= 0 else "borrow_mut={}".format(-borrow) + + +class StdRefSyntheticProvider: + """Pretty-printer for std::cell::Ref, std::cell::RefMut, and std::cell::RefCell""" + + def __init__(self, valobj, dict, is_cell=False): + # type: (SBValue, dict, bool) -> StdRefSyntheticProvider + self.valobj = valobj + + borrow = valobj.GetChildMemberWithName("borrow") + value = valobj.GetChildMemberWithName("value") + if is_cell: + self.borrow = borrow.GetChildMemberWithName("value").GetChildMemberWithName("value") + self.value = value.GetChildMemberWithName("value") + else: + self.borrow = borrow.GetChildMemberWithName("borrow").GetChildMemberWithName( + "value").GetChildMemberWithName("value") + self.value = value.Dereference() + + self.value_builder = ValueBuilder(valobj) + + self.update() + + def num_children(self): + # type: () -> int + # Actually there are 2 children, but only the `value` should be shown as a child + return 1 + + def get_child_index(self, name): + if name == "value": + return 0 + if name == "borrow": + return 1 + return -1 + + def get_child_at_index(self, index): + # type: (int) -> SBValue + if index == 0: + return self.value + if index == 1: + return self.value_builder.from_int("borrow", self.borrow_count) + return None + + def update(self): + # type: () -> None + self.borrow_count = self.borrow.GetValueAsSigned() + + def has_children(self): + # type: () -> bool + return True diff --git a/src/etc/lldb_rust_formatters.py b/src/etc/lldb_rust_formatters.py deleted file mode 100644 index 0c4021b36fb..00000000000 --- a/src/etc/lldb_rust_formatters.py +++ /dev/null @@ -1,305 +0,0 @@ -import lldb -import debugger_pretty_printers_common as rustpp - -# =============================================================================== -# LLDB Pretty Printing Module for Rust -# =============================================================================== - - -class LldbType(rustpp.Type): - - def __init__(self, ty): - super(LldbType, self).__init__() - self.ty = ty - self.fields = None - - def get_unqualified_type_name(self): - qualified_name = self.ty.GetName() - - if qualified_name is None: - return qualified_name - - return rustpp.extract_type_name(qualified_name).replace("&'static ", "&") - - def get_dwarf_type_kind(self): - type_class = self.ty.GetTypeClass() - - if type_class == lldb.eTypeClassStruct: - return rustpp.DWARF_TYPE_CODE_STRUCT - - if type_class == lldb.eTypeClassUnion: - return rustpp.DWARF_TYPE_CODE_UNION - - if type_class == lldb.eTypeClassPointer: - return rustpp.DWARF_TYPE_CODE_PTR - - if type_class == lldb.eTypeClassArray: - return rustpp.DWARF_TYPE_CODE_ARRAY - - if type_class == lldb.eTypeClassEnumeration: - return rustpp.DWARF_TYPE_CODE_ENUM - - return None - - def get_fields(self): - assert ((self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_STRUCT) or - (self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_UNION)) - if self.fields is None: - self.fields = list(self.ty.fields) - return self.fields - - def get_wrapped_value(self): - return self.ty - - -class LldbValue(rustpp.Value): - def __init__(self, lldb_val): - ty = lldb_val.type - wty = LldbType(ty) - super(LldbValue, self).__init__(wty) - self.lldb_val = lldb_val - self.children = {} - - def get_child_at_index(self, index): - child = self.children.get(index) - if child is None: - lldb_field = self.lldb_val.GetChildAtIndex(index) - child = LldbValue(lldb_field) - self.children[index] = child - return child - - def as_integer(self): - return self.lldb_val.GetValueAsUnsigned() - - def get_wrapped_value(self): - return self.lldb_val - - -def print_val(lldb_val, internal_dict): - val = LldbValue(lldb_val) - type_kind = val.type.get_type_kind() - - if (type_kind == rustpp.TYPE_KIND_REGULAR_STRUCT or - type_kind == rustpp.TYPE_KIND_REGULAR_UNION or - type_kind == rustpp.TYPE_KIND_EMPTY): - return print_struct_val(val, - internal_dict, - omit_first_field=False, - omit_type_name=False, - is_tuple_like=False) - - if type_kind == rustpp.TYPE_KIND_STRUCT_VARIANT: - return print_struct_val(val, - internal_dict, - omit_first_field=True, - omit_type_name=False, - is_tuple_like=False) - - if type_kind == rustpp.TYPE_KIND_SLICE: - return print_vec_slice_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_STR_SLICE: - return print_str_slice_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_STD_VEC: - return print_std_vec_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_STD_STRING: - return print_std_string_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_TUPLE: - return print_struct_val(val, - internal_dict, - omit_first_field=False, - omit_type_name=True, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_TUPLE_STRUCT: - return print_struct_val(val, - internal_dict, - omit_first_field=False, - omit_type_name=False, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_CSTYLE_VARIANT: - return val.type.get_unqualified_type_name() - - if type_kind == rustpp.TYPE_KIND_TUPLE_VARIANT: - return print_struct_val(val, - internal_dict, - omit_first_field=True, - omit_type_name=False, - is_tuple_like=True) - - if type_kind == rustpp.TYPE_KIND_SINGLETON_ENUM: - return print_val(lldb_val.GetChildAtIndex(0), internal_dict) - - if type_kind == rustpp.TYPE_KIND_PTR: - return print_pointer_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_FIXED_SIZE_VEC: - return print_fixed_size_vec_val(val, internal_dict) - - if type_kind == rustpp.TYPE_KIND_REGULAR_ENUM: - # This is a regular enum, extract the discriminant - discriminant_val = rustpp.get_discriminant_value_as_integer(val) - return print_val(lldb_val.GetChildAtIndex(discriminant_val), internal_dict) - - if type_kind == rustpp.TYPE_KIND_COMPRESSED_ENUM: - encoded_enum_info = rustpp.EncodedEnumInfo(val) - if encoded_enum_info.is_null_variant(): - return encoded_enum_info.get_null_variant_name() - - non_null_val = encoded_enum_info.get_non_null_variant_val() - return print_val(non_null_val.get_wrapped_value(), internal_dict) - - # No pretty printer has been found - return lldb_val.GetValue() - - -# =--------------------------------------------------------------------------------------- -# Type-Specialized Printing Functions -# =--------------------------------------------------------------------------------------- - -def print_struct_val(val, internal_dict, omit_first_field, omit_type_name, is_tuple_like): - """ - Prints a struct, tuple, or tuple struct value with Rust syntax. - Ignores any fields before field_start_index. - """ - assert (val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_STRUCT or - val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_UNION) - - if omit_type_name: - type_name = "" - else: - type_name = val.type.get_unqualified_type_name() - - if is_tuple_like: - template = "%(type_name)s(%(body)s)" - separator = ", " - else: - template = "%(type_name)s {\n%(body)s\n}" - separator = ", \n" - - fields = val.type.get_fields() - - def render_child(child_index): - this = "" - if not is_tuple_like: - field_name = fields[child_index].name - this += field_name + ": " - - field_val = val.get_child_at_index(child_index) - - if not field_val.get_wrapped_value().IsValid(): - field = fields[child_index] - # LLDB is not good at handling zero-sized values, so we have to help - # it a little - if field.GetType().GetByteSize() == 0: - return this + rustpp.extract_type_name(field.GetType().GetName()) - else: - return this + "" - - return this + print_val(field_val.get_wrapped_value(), internal_dict) - - if omit_first_field: - field_start_index = 1 - else: - field_start_index = 0 - - body = separator.join([render_child(idx) for idx in range(field_start_index, len(fields))]) - - return template % {"type_name": type_name, - "body": body} - - -def print_pointer_val(val, internal_dict): - """Prints a pointer value with Rust syntax""" - assert val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_PTR - sigil = "&" - type_name = val.type.get_unqualified_type_name() - if type_name and type_name[0:1] in ["&", "*"]: - sigil = type_name[0:1] - - return sigil + hex(val.as_integer()) - - -def print_fixed_size_vec_val(val, internal_dict): - assert val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_ARRAY - lldb_val = val.get_wrapped_value() - - output = "[" - - for i in range(lldb_val.num_children): - output += print_val(lldb_val.GetChildAtIndex(i), internal_dict) - if i != lldb_val.num_children - 1: - output += ", " - - output += "]" - return output - - -def print_vec_slice_val(val, internal_dict): - (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(val) - return "&[%s]" % print_array_of_values(val.get_wrapped_value().GetName(), - data_ptr, - length, - internal_dict) - - -def print_std_vec_val(val, internal_dict): - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(val) - return "vec![%s]" % print_array_of_values(val.get_wrapped_value().GetName(), - data_ptr, - length, - internal_dict) - - -def print_str_slice_val(val, internal_dict): - (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(val) - return read_utf8_string(data_ptr, length) - - -def print_std_string_val(val, internal_dict): - vec = val.get_child_at_index(0) - (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(vec) - return read_utf8_string(data_ptr, length) - -# =----------------------------------------------------------------------- -# Helper Functions -# =----------------------------------------------------------------------- - - -def print_array_of_values(array_name, data_ptr_val, length, internal_dict): - """Prints a contiguous memory range, interpreting it as values of the - pointee-type of data_ptr_val.""" - - data_ptr_type = data_ptr_val.type - assert data_ptr_type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_PTR - - element_type = data_ptr_type.get_wrapped_value().GetPointeeType() - element_type_size = element_type.GetByteSize() - - start_address = data_ptr_val.as_integer() - raw_value = data_ptr_val.get_wrapped_value() - - def render_element(i): - address = start_address + i * element_type_size - element_val = raw_value.CreateValueFromAddress(array_name + ("[%s]" % i), - address, - element_type) - return print_val(element_val, internal_dict) - - return ', '.join([render_element(i) for i in range(length)]) - - -def read_utf8_string(ptr_val, byte_count): - if byte_count == 0: - return '""' - error = lldb.SBError() - process = ptr_val.get_wrapped_value().GetProcess() - data = process.ReadMemory(ptr_val.as_integer(), byte_count, error) - if error.Success(): - return '"%s"' % data.decode(encoding='UTF-8') - else: - return '' % error.GetCString() diff --git a/src/etc/rust-lldb b/src/etc/rust-lldb index 7b9b40e6b4a..28b32ef1ad5 100755 --- a/src/etc/rust-lldb +++ b/src/etc/rust-lldb @@ -30,13 +30,5 @@ EOF fi fi -# Prepare commands that will be loaded before any file on the command line has been loaded -script_import="command script import \"$RUSTC_SYSROOT/lib/rustlib/etc/lldb_rust_formatters.py\"" -category_definition="type summary add --no-value --python-function lldb_rust_formatters.print_val -x \".*\" --category Rust" -category_enable="type category enable Rust" - # Call LLDB with the commands added to the argument list -exec "$lldb" --one-line-before-file "$script_import" \ - --one-line-before-file "$category_definition" \ - --one-line-before-file "$category_enable" \ - "$@" +exec "$lldb" --source-before-file ./lldb_commands "$@" diff --git a/src/etc/rust_types.py b/src/etc/rust_types.py new file mode 100644 index 00000000000..b49fd19ed4c --- /dev/null +++ b/src/etc/rust_types.py @@ -0,0 +1,113 @@ +import re + + +class RustType(object): + OTHER = "Other" + STRUCT = "Struct" + TUPLE = "Tuple" + CSTYLE_VARIANT = "CStyleVariant" + TUPLE_VARIANT = "TupleVariant" + STRUCT_VARIANT = "StructVariant" + ENUM = "Enum" + EMPTY = "Empty" + SINGLETON_ENUM = "SingletonEnum" + REGULAR_ENUM = "RegularEnum" + COMPRESSED_ENUM = "CompressedEnum" + REGULAR_UNION = "RegularUnion" + + STD_STRING = "StdString" + STD_OS_STRING = "StdOsString" + STD_STR = "StdStr" + STD_SLICE = "StdSlice" + STD_VEC = "StdVec" + STD_VEC_DEQUE = "StdVecDeque" + STD_BTREE_SET = "StdBTreeSet" + STD_BTREE_MAP = "StdBTreeMap" + STD_HASH_MAP = "StdHashMap" + STD_HASH_SET = "StdHashSet" + STD_RC = "StdRc" + STD_ARC = "StdArc" + STD_CELL = "StdCell" + STD_REF = "StdRef" + STD_REF_MUT = "StdRefMut" + STD_REF_CELL = "StdRefCell" + + +STD_STRING_REGEX = re.compile(r"^(alloc::(\w+::)+)String$") +STD_STR_REGEX = re.compile(r"^&str$") +STD_SLICE_REGEX = re.compile(r"^&\[.+\]$") +STD_OS_STRING_REGEX = re.compile(r"^(std::ffi::(\w+::)+)OsString$") +STD_VEC_REGEX = re.compile(r"^(alloc::(\w+::)+)Vec<.+>$") +STD_VEC_DEQUE_REGEX = re.compile(r"^(alloc::(\w+::)+)VecDeque<.+>$") +STD_BTREE_SET_REGEX = re.compile(r"^(alloc::(\w+::)+)BTreeSet<.+>$") +STD_BTREE_MAP_REGEX = re.compile(r"^(alloc::(\w+::)+)BTreeMap<.+>$") +STD_HASH_MAP_REGEX = re.compile(r"^(std::collections::(\w+::)+)HashMap<.+>$") +STD_HASH_SET_REGEX = re.compile(r"^(std::collections::(\w+::)+)HashSet<.+>$") +STD_RC_REGEX = re.compile(r"^(alloc::(\w+::)+)Rc<.+>$") +STD_ARC_REGEX = re.compile(r"^(alloc::(\w+::)+)Arc<.+>$") +STD_CELL_REGEX = re.compile(r"^(core::(\w+::)+)Cell<.+>$") +STD_REF_REGEX = re.compile(r"^(core::(\w+::)+)Ref<.+>$") +STD_REF_MUT_REGEX = re.compile(r"^(core::(\w+::)+)RefMut<.+>$") +STD_REF_CELL_REGEX = re.compile(r"^(core::(\w+::)+)RefCell<.+>$") + +TUPLE_ITEM_REGEX = re.compile(r"__\d+$") + +ENCODED_ENUM_PREFIX = "RUST$ENCODED$ENUM$" +ENUM_DISR_FIELD_NAME = "<>" + +STD_TYPE_TO_REGEX = { + RustType.STD_STRING: STD_STRING_REGEX, + RustType.STD_OS_STRING: STD_OS_STRING_REGEX, + RustType.STD_STR: STD_STR_REGEX, + RustType.STD_SLICE: STD_SLICE_REGEX, + RustType.STD_VEC: STD_VEC_REGEX, + RustType.STD_VEC_DEQUE: STD_VEC_DEQUE_REGEX, + RustType.STD_HASH_MAP: STD_HASH_MAP_REGEX, + RustType.STD_HASH_SET: STD_HASH_SET_REGEX, + RustType.STD_BTREE_SET: STD_BTREE_SET_REGEX, + RustType.STD_BTREE_MAP: STD_BTREE_MAP_REGEX, + RustType.STD_RC: STD_RC_REGEX, + RustType.STD_ARC: STD_ARC_REGEX, + RustType.STD_REF: STD_REF_REGEX, + RustType.STD_REF_MUT: STD_REF_MUT_REGEX, + RustType.STD_REF_CELL: STD_REF_CELL_REGEX, + RustType.STD_CELL: STD_CELL_REGEX, +} + +def is_tuple_fields(fields): + # type: (list) -> bool + return all(TUPLE_ITEM_REGEX.match(str(field.name)) for field in fields) + + +def classify_struct(name, fields): + if len(fields) == 0: + return RustType.EMPTY + + for ty, regex in STD_TYPE_TO_REGEX.items(): + if regex.match(name): + return ty + + if fields[0].name == ENUM_DISR_FIELD_NAME: + return RustType.ENUM + + if is_tuple_fields(fields): + return RustType.TUPLE + + return RustType.STRUCT + + +def classify_union(fields): + if len(fields) == 0: + return RustType.EMPTY + + first_variant_name = fields[0].name + if first_variant_name is None: + if len(fields) == 1: + return RustType.SINGLETON_ENUM + else: + return RustType.REGULAR_ENUM + elif first_variant_name.startswith(ENCODED_ENUM_PREFIX): + assert len(fields) == 1 + return RustType.COMPRESSED_ENUM + else: + return RustType.REGULAR_UNION diff --git a/src/test/debuginfo/associated-types.rs b/src/test/debuginfo/associated-types.rs index 8d1170fd974..0a0ce3c671f 100644 --- a/src/test/debuginfo/associated-types.rs +++ b/src/test/debuginfo/associated-types.rs @@ -43,8 +43,8 @@ // lldb-command:run // lldb-command:print arg -// lldbg-check:[...]$0 = Struct { b: -1, b1: 0 } -// lldbr-check:(associated_types::Struct) arg = Struct { b: -1, b1: 0 } +// lldbg-check:[...]$0 = { b = -1, b1 = 0 } +// lldbr-check:(associated_types::Struct) arg = { b = -1, b1 = 0 } // lldb-command:continue // lldb-command:print inferred diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs index 3a164a41101..7f97d96b8db 100644 --- a/src/test/debuginfo/borrowed-struct.rs +++ b/src/test/debuginfo/borrowed-struct.rs @@ -35,8 +35,8 @@ // lldb-command:run // lldb-command:print *stack_val_ref -// lldbg-check:[...]$0 = SomeStruct { x: 10, y: 23.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *stack_val_ref = SomeStruct { x: 10, y: 23.5 } +// lldbg-check:[...]$0 = { x = 10 y = 23.5 } +// lldbr-check:(borrowed_struct::SomeStruct) *stack_val_ref = (x = 10, y = 23.5) // lldb-command:print *stack_val_interior_ref_1 // lldbg-check:[...]$1 = 10 @@ -47,12 +47,12 @@ // lldbr-check:(f64) *stack_val_interior_ref_2 = 23.5 // lldb-command:print *ref_to_unnamed -// lldbg-check:[...]$3 = SomeStruct { x: 11, y: 24.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *ref_to_unnamed = SomeStruct { x: 11, y: 24.5 } +// lldbg-check:[...]$3 = { x = 11 y = 24.5 } +// lldbr-check:(borrowed_struct::SomeStruct) *ref_to_unnamed = (x = 11, y = 24.5) // lldb-command:print *unique_val_ref -// lldbg-check:[...]$4 = SomeStruct { x: 13, y: 26.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *unique_val_ref = SomeStruct { x: 13, y: 26.5 } +// lldbg-check:[...]$4 = { x = 13 y = 26.5 } +// lldbr-check:(borrowed_struct::SomeStruct) *unique_val_ref = (x = 13, y = 26.5) // lldb-command:print *unique_val_interior_ref_1 // lldbg-check:[...]$5 = 13 diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs index fc92b629ef3..be4895ef536 100644 --- a/src/test/debuginfo/borrowed-tuple.rs +++ b/src/test/debuginfo/borrowed-tuple.rs @@ -24,16 +24,16 @@ // lldb-command:run // lldb-command:print *stack_val_ref -// lldbg-check:[...]$0 = (-14, -19) -// lldbr-check:((i16, f32)) *stack_val_ref = { = -14 = -19 } +// lldbg-check:[...]$0 = { 0 = -14 1 = -19 } +// lldbr-check:((i16, f32)) *stack_val_ref = { 0 = -14 1 = -19 } // lldb-command:print *ref_to_unnamed -// lldbg-check:[...]$1 = (-15, -20) -// lldbr-check:((i16, f32)) *ref_to_unnamed = { = -15 = -20 } +// lldbg-check:[...]$1 = { 0 = -15 1 = -20 } +// lldbr-check:((i16, f32)) *ref_to_unnamed = { 0 = -15 1 = -20 } // lldb-command:print *unique_val_ref -// lldbg-check:[...]$2 = (-17, -22) -// lldbr-check:((i16, f32)) *unique_val_ref = { = -17 = -22 } +// lldbg-check:[...]$2 = { 0 = -17 1 = -22 } +// lldbr-check:((i16, f32)) *unique_val_ref = { 0 = -17 1 = -22 } #![allow(unused_variables)] diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs index a539d78d3c9..e443b67ebfb 100644 --- a/src/test/debuginfo/box.rs +++ b/src/test/debuginfo/box.rs @@ -20,8 +20,8 @@ // lldbg-check:[...]$0 = 1 // lldbr-check:(i32) *a = 1 // lldb-command:print *b -// lldbg-check:[...]$1 = (2, 3.5) -// lldbr-check:((i32, f64)) *b = { = 2 = 3.5 } +// lldbg-check:[...]$1 = { 0 = 2 1 = 3.5 } +// lldbr-check:((i32, f64)) *b = { 0 = 2 1 = 3.5 } #![allow(unused_variables)] #![feature(box_syntax)] diff --git a/src/test/debuginfo/boxed-struct.rs b/src/test/debuginfo/boxed-struct.rs index 8709fb68170..04bdf728901 100644 --- a/src/test/debuginfo/boxed-struct.rs +++ b/src/test/debuginfo/boxed-struct.rs @@ -22,12 +22,12 @@ // lldb-command:run // lldb-command:print *boxed_with_padding -// lldbg-check:[...]$0 = StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 } -// lldbr-check:(boxed_struct::StructWithSomePadding) *boxed_with_padding = StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 } +// lldbg-check:[...]$0 = { x = 99 y = 999 z = 9999 w = 99999 } +// lldbr-check:(boxed_struct::StructWithSomePadding) *boxed_with_padding = { x = 99 y = 999 z = 9999 w = 99999 } // lldb-command:print *boxed_with_dtor -// lldbg-check:[...]$1 = StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 } -// lldbr-check:(boxed_struct::StructWithDestructor) *boxed_with_dtor = StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 } +// lldbg-check:[...]$1 = { x = 77 y = 777 z = 7777 w = 77777 } +// lldbr-check:(boxed_struct::StructWithDestructor) *boxed_with_dtor = { x = 77 y = 777 z = 7777 w = 77777 } #![allow(unused_variables)] #![feature(box_syntax)] diff --git a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs index deba18cc44a..e60cfc9242a 100644 --- a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -31,13 +31,13 @@ // lldb-command:continue // lldb-command:print self -// lldbg-check:[...]$1 = Struct { x: 2222, y: 3333 } -// lldbr-check:(by_value_self_argument_in_trait_impl::Struct) self = Struct { x: 2222, y: 3333 } +// lldbg-check:[...]$1 = { x = 2222 y = 3333 } +// lldbr-check:(by_value_self_argument_in_trait_impl::Struct) self = { x = 2222 y = 3333 } // lldb-command:continue // lldb-command:print self -// lldbg-check:[...]$2 = (4444.5, 5555, 6666, 7777.5) -// lldbr-check:((f64, isize, isize, f64)) self = { = 4444.5 = 5555 = 6666 = 7777.5 } +// lldbg-check:[...] $2 = { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } +// lldbr-check:((f64, isize, isize, f64)) self = { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/c-style-enum-in-composite.rs b/src/test/debuginfo/c-style-enum-in-composite.rs index 8a356f62d3c..f859fe8d1ce 100644 --- a/src/test/debuginfo/c-style-enum-in-composite.rs +++ b/src/test/debuginfo/c-style-enum-in-composite.rs @@ -40,31 +40,32 @@ // lldb-command:run // lldb-command:print tuple_interior_padding -// lldbg-check:[...]$0 = (0, OneHundred) -// lldbr-check:((i16, c_style_enum_in_composite::AnEnum)) tuple_interior_padding = { = 0 = c_style_enum_in_composite::AnEnum::OneHundred } +// lldbg-check:[...]$0 = { 0 = 0 1 = OneHundred } +// lldbr-check:((i16, c_style_enum_in_composite::AnEnum)) tuple_interior_padding = { 0 = 0 1 = OneHundred } // lldb-command:print tuple_padding_at_end -// lldbg-check:[...]$1 = ((1, OneThousand), 2) -// lldbr-check:(((u64, c_style_enum_in_composite::AnEnum), u64)) tuple_padding_at_end = { = { = 1 = c_style_enum_in_composite::AnEnum::OneThousand } = 2 } +// lldbg-check:[...]$1 = { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } +// lldbr-check:(((u64, c_style_enum_in_composite::AnEnum), u64)) tuple_padding_at_end = { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } + // lldb-command:print tuple_different_enums -// lldbg-check:[...]$2 = (OneThousand, MountainView, OneMillion, Vienna) -// lldbr-check:((c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum, c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum)) tuple_different_enums = { = c_style_enum_in_composite::AnEnum::OneThousand = c_style_enum_in_composite::AnotherEnum::MountainView = c_style_enum_in_composite::AnEnum::OneMillion = c_style_enum_in_composite::AnotherEnum::Vienna } +// lldbg-check:[...]$2 = { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna } +// lldbr-check:((c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum, c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum)) tuple_different_enums = { 0 = c_style_enum_in_composite::AnEnum::OneThousand 1 = c_style_enum_in_composite::AnotherEnum::MountainView 2 = c_style_enum_in_composite::AnEnum::OneMillion 3 = c_style_enum_in_composite::AnotherEnum::Vienna } // lldb-command:print padded_struct -// lldbg-check:[...]$3 = PaddedStruct { a: 3, b: OneMillion, c: 4, d: Toronto, e: 5 } -// lldbr-check:(c_style_enum_in_composite::PaddedStruct) padded_struct = PaddedStruct { a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5 } +// lldbg-check:[...]$3 = { a = 3 b = OneMillion c = 4 d = Toronto e = 5 } +// lldbr-check:(c_style_enum_in_composite::PaddedStruct) padded_struct = { a = 3 b = c_style_enum_in_composite::AnEnum::OneMillion c = 4 d = Toronto e = 5 } // lldb-command:print packed_struct -// lldbg-check:[...]$4 = PackedStruct { a: 6, b: OneHundred, c: 7, d: Vienna, e: 8 } -// lldbr-check:(c_style_enum_in_composite::PackedStruct) packed_struct = PackedStruct { a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8 } +// lldbg-check:[...]$4 = { a = 6 b = OneHundred c = 7 d = Vienna e = 8 } +// lldbr-check:(c_style_enum_in_composite::PackedStruct) packed_struct = { a = 6 b = c_style_enum_in_composite::AnEnum::OneHundred c = 7 d = Vienna e = 8 } // lldb-command:print non_padded_struct -// lldbg-check:[...]$5 = NonPaddedStruct { a: OneMillion, b: MountainView, c: OneThousand, d: Toronto } -// lldbr-check:(c_style_enum_in_composite::NonPaddedStruct) non_padded_struct = NonPaddedStruct { a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto } +// lldbg-check:[...]$5 = { a = OneMillion b = MountainView c = OneThousand d = Toronto } +// lldbr-check:(c_style_enum_in_composite::NonPaddedStruct) non_padded_struct = { a = c_style_enum_in_composite::AnEnum::OneMillion, b = c_style_enum_in_composite::AnotherEnum::MountainView, c = c_style_enum_in_composite::AnEnum::OneThousand, d = c_style_enum_in_composite::AnotherEnum::Toronto } // lldb-command:print struct_with_drop -// lldbg-check:[...]$6 = (StructWithDrop { a: OneHundred, b: Vienna }, 9) -// lldbr-check:((c_style_enum_in_composite::StructWithDrop, i64)) struct_with_drop = { = StructWithDrop { a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna } = 9 } +// lldbg-check:[...]$6 = { 0 = { a = OneHundred b = Vienna } 1 = 9 } +// lldbr-check:((c_style_enum_in_composite::StructWithDrop, i64)) struct_with_drop = { 0 = { a = c_style_enum_in_composite::AnEnum::OneHundred b = c_style_enum_in_composite::AnotherEnum::Vienna } 1 = 9 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/cross-crate-spans.rs b/src/test/debuginfo/cross-crate-spans.rs index 96ddfd2a39e..7c58e1db23f 100644 --- a/src/test/debuginfo/cross-crate-spans.rs +++ b/src/test/debuginfo/cross-crate-spans.rs @@ -44,8 +44,8 @@ extern crate cross_crate_spans; // lldb-command:run // lldb-command:print result -// lldbg-check:[...]$0 = (17, 17) -// lldbr-check:((u32, u32)) result = { = 17 = 17 } +// lldbg-check:[...]$0 = { 0 = 17 1 = 17 } +// lldbr-check:((u32, u32)) result = { 0 = 17 1 = 17 } // lldb-command:print a_variable // lldbg-check:[...]$1 = 123456789 // lldbr-check:(u32) a_variable = 123456789 @@ -55,8 +55,8 @@ extern crate cross_crate_spans; // lldb-command:continue // lldb-command:print result -// lldbg-check:[...]$3 = (1212, 1212) -// lldbr-check:((i16, i16)) result = { = 1212 = 1212 } +// lldbg-check:[...]$3 = { 0 = 1212 1 = 1212 } +// lldbr-check:((i16, i16)) result = { 0 = 1212 1 = 1212 } // lldb-command:print a_variable // lldbg-check:[...]$4 = 123456789 // lldbr-check:(u32) a_variable = 123456789 diff --git a/src/test/debuginfo/destructured-fn-argument.rs b/src/test/debuginfo/destructured-fn-argument.rs index 64133dc6860..a776f519071 100644 --- a/src/test/debuginfo/destructured-fn-argument.rs +++ b/src/test/debuginfo/destructured-fn-argument.rs @@ -186,16 +186,16 @@ // lldbg-check:[...]$5 = 5 // lldbr-check:(isize) a = 5 // lldb-command:print b -// lldbg-check:[...]$6 = (6, 7) -// lldbr-check:((u32, u32)) b = { = 6 = 7 } +// lldbg-check:[...]$6 = { 0 = 6 1 = 7 } +// lldbr-check:((u32, u32)) b = { 0 = 6 1 = 7 } // lldb-command:continue // lldb-command:print h // lldbg-check:[...]$7 = 8 // lldbr-check:(i16) h = 8 // lldb-command:print i -// lldbg-check:[...]$8 = Struct { a: 9, b: 10 } -// lldbr-check:(destructured_fn_argument::Struct) i = Struct { a: 9, b: 10 } +// lldbg-check:[...]$8 = { a = 9 b = 10 } +// lldbr-check:(destructured_fn_argument::Struct) i = { a = 9 b = 10 } // lldb-command:print j // lldbg-check:[...]$9 = 11 // lldbr-check:(i16) j = 11 @@ -229,8 +229,8 @@ // lldbg-check:[...]$16 = 20 // lldbr-check:(i32) q = 20 // lldb-command:print r -// lldbg-check:[...]$17 = Struct { a: 21, b: 22 } -// lldbr-check:(destructured_fn_argument::Struct) r = Struct { a: 21, b: 22 } +// lldbg-check:[...]$17 = { a = 21 b = 22 } +// lldbr-check:(destructured_fn_argument::Struct) r = { a = 21, b = 22 } // lldb-command:continue // lldb-command:print s @@ -271,13 +271,13 @@ // lldb-command:continue // lldb-command:print aa -// lldbg-check:[...]$29 = (34, 35) -// lldbr-check:((isize, isize)) aa = { = 34 = 35 } +// lldbg-check:[...]$29 = { 0 = 34 1 = 35 } +// lldbr-check:((isize, isize)) aa = { 0 = 34 1 = 35 } // lldb-command:continue // lldb-command:print bb -// lldbg-check:[...]$30 = (36, 37) -// lldbr-check:((isize, isize)) bb = { = 36 = 37 } +// lldbg-check:[...]$30 = { 0 = 36 1 = 37 } +// lldbr-check:((isize, isize)) bb = { 0 = 36 1 = 37 } // lldb-command:continue // lldb-command:print cc @@ -286,21 +286,21 @@ // lldb-command:continue // lldb-command:print dd -// lldbg-check:[...]$32 = (40, 41, 42) -// lldbr-check:((isize, isize, isize)) dd = { = 40 = 41 = 42 } +// lldbg-check:[...]$32 = { 0 = 40 1 = 41 2 = 42 } +// lldbr-check:((isize, isize, isize)) dd = { 0 = 40 1 = 41 2 = 42 } // lldb-command:continue // lldb-command:print *ee -// lldbg-check:[...]$33 = (43, 44, 45) -// lldbr-check:((isize, isize, isize)) *ee = { = 43 = 44 = 45 } +// lldbg-check:[...]$33 = { 0 = 43 1 = 44 2 = 45 } +// lldbr-check:((isize, isize, isize)) *ee = { 0 = 43 1 = 44 2 = 45 } // lldb-command:continue // lldb-command:print *ff // lldbg-check:[...]$34 = 46 // lldbr-check:(isize) *ff = 46 // lldb-command:print gg -// lldbg-check:[...]$35 = (47, 48) -// lldbr-check:((isize, isize)) gg = { = 47 = 48 } +// lldbg-check:[...]$35 = { 0 = 47 1 = 48 } +// lldbr-check:((isize, isize)) gg = { 0 = 47 1 = 48 } // lldb-command:continue // lldb-command:print *hh diff --git a/src/test/debuginfo/destructured-for-loop-variable.rs b/src/test/debuginfo/destructured-for-loop-variable.rs index dbb98322317..868f2285f35 100644 --- a/src/test/debuginfo/destructured-for-loop-variable.rs +++ b/src/test/debuginfo/destructured-for-loop-variable.rs @@ -164,13 +164,13 @@ // lldb-command:continue // lldb-command:print simple_struct_ident -// lldbg-check:[...]$22 = Struct { x: 3537, y: 35437.5, z: true } -// lldbr-check:(destructured_for_loop_variable::Struct) simple_struct_ident = Struct { x: 3537, y: 35437.5, z: true } +// lldbg-check:[...]$22 = { x = 3537 y = 35437.5 z = true } +// lldbr-check:(destructured_for_loop_variable::Struct) simple_struct_ident = { x = 3537 y = 35437.5 z = true } // lldb-command:continue // lldb-command:print simple_tuple_ident -// lldbg-check:[...]$23 = (34903493, 232323) -// lldbr-check:((u32, i64)) simple_tuple_ident = { = 34903493 = 232323 } +// lldbg-check:[...]$23 = { 0 = 34903493 1 = 232323 } +// lldbr-check:((u32, i64)) simple_tuple_ident = { 0 = 34903493 1 = 232323 } // lldb-command:continue #![allow(unused_variables)] diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs index 78b6b2764e0..712168b5baa 100644 --- a/src/test/debuginfo/destructured-local.rs +++ b/src/test/debuginfo/destructured-local.rs @@ -150,15 +150,15 @@ // lldbg-check:[...]$5 = 5 // lldbr-check:(isize) f = 5 // lldb-command:print g -// lldbg-check:[...]$6 = (6, 7) -// lldbr-check:((u32, u32)) g = { = 6 = 7 } +// lldbg-check:[...]$6 = { 0 = 6 1 = 7 } +// lldbr-check:((u32, u32)) g = { 0 = 6 1 = 7 } // lldb-command:print h // lldbg-check:[...]$7 = 8 // lldbr-check:(i16) h = 8 // lldb-command:print i -// lldbg-check:[...]$8 = Struct { a: 9, b: 10 } -// lldbr-check:(destructured_local::Struct) i = Struct { a: 9, b: 10 } +// lldbg-check:[...]$8 = { a = 9 b = 10 } +// lldbr-check:(destructured_local::Struct) i = { a = 9 b = 10 } // lldb-command:print j // lldbg-check:[...]$9 = 11 // lldbr-check:(i16) j = 11 @@ -188,8 +188,8 @@ // lldbg-check:[...]$16 = 20 // lldbr-check:(i32) q = 20 // lldb-command:print r -// lldbg-check:[...]$17 = Struct { a: 21, b: 22 } -// lldbr-check:(destructured_local::Struct) r = Struct { a: 21, b: 22 } +// lldbg-check:[...]$17 = { a = 21 b = 22 } +// lldbr-check:(destructured_local::Struct) r = { a = 21 b = 22 } // lldb-command:print s // lldbg-check:[...]$18 = 24 @@ -227,32 +227,32 @@ // lldbr-check:(i32) ue = 33 // lldb-command:print aa -// lldbg-check:[...]$29 = (34, 35) -// lldbr-check:((i32, i32)) aa = { = 34 = 35 } +// lldbg-check:[...]$29 = { 0 = 34 1 = 35 } +// lldbr-check:((i32, i32)) aa = { 0 = 34 1 = 35 } // lldb-command:print bb -// lldbg-check:[...]$30 = (36, 37) -// lldbr-check:((i32, i32)) bb = { = 36 = 37 } +// lldbg-check:[...]$30 = { 0 = 36 1 = 37 } +// lldbr-check:((i32, i32)) bb = { 0 = 36 1 = 37 } // lldb-command:print cc // lldbg-check:[...]$31 = 38 // lldbr-check:(i32) cc = 38 // lldb-command:print dd -// lldbg-check:[...]$32 = (40, 41, 42) -// lldbr-check:((i32, i32, i32)) dd = { = 40 = 41 = 42 } +// lldbg-check:[...]$32 = { 0 = 40 1 = 41 2 = 42 } +// lldbr-check:((i32, i32, i32)) dd = { 0 = 40 1 = 41 2 = 42} // lldb-command:print *ee -// lldbg-check:[...]$33 = (43, 44, 45) -// lldbr-check:((i32, i32, i32)) *ee = { = 43 = 44 = 45 } +// lldbg-check:[...]$33 = { 0 = 43 1 = 44 2 = 45 } +// lldbr-check:((i32, i32, i32)) *ee = { 0 = 43 1 = 44 2 = 45} // lldb-command:print *ff // lldbg-check:[...]$34 = 46 // lldbr-check:(i32) *ff = 46 // lldb-command:print gg -// lldbg-check:[...]$35 = (47, 48) -// lldbr-check:((i32, i32)) gg = { = 47 = 48 } +// lldbg-check:[...]$35 = { 0 = 47 1 = 48 } +// lldbr-check:((i32, i32)) gg = { 0 = 47 1 = 48 } // lldb-command:print *hh // lldbg-check:[...]$36 = 50 diff --git a/src/test/debuginfo/empty-string.rs b/src/test/debuginfo/empty-string.rs index bc4fac3183c..66eb8bae26b 100644 --- a/src/test/debuginfo/empty-string.rs +++ b/src/test/debuginfo/empty-string.rs @@ -1,7 +1,7 @@ // ignore-windows failing on win32 bot // ignore-android: FIXME(#10381) // compile-flags:-g -// min-gdb-version: 7.7 +// min-gdb-version: 8.1 // ignore-gdb-version: 7.11.90 - 8.0.9 // min-lldb-version: 310 @@ -20,10 +20,10 @@ // lldb-command: run // lldb-command: fr v empty_string -// lldb-check:[...]empty_string = "" +// lldb-check:[...]empty_string = "" { vec = size=0 } // lldb-command: fr v empty_str -// lldb-check:[...]empty_str = "" +// lldb-check:[...]empty_str = "" { data_ptr = [...] length = 0 } fn main() { let empty_string = String::new(); diff --git a/src/test/debuginfo/enum-thinlto.rs b/src/test/debuginfo/enum-thinlto.rs index 9359e55dcee..b10e04a4a9e 100644 --- a/src/test/debuginfo/enum-thinlto.rs +++ b/src/test/debuginfo/enum-thinlto.rs @@ -15,7 +15,8 @@ // lldb-command:run // lldb-command:print *abc -// lldbg-check:(enum_thinlto::ABC) $0 = ABC { } +// lldbg-check:(enum_thinlto::ABC) $0 = +// lldbr-check:(enum_thinlto::ABC) *abc = (x = 0, y = 8970181431921507452) #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/evec-in-struct.rs b/src/test/debuginfo/evec-in-struct.rs index cf86374ab31..2033966adad 100644 --- a/src/test/debuginfo/evec-in-struct.rs +++ b/src/test/debuginfo/evec-in-struct.rs @@ -33,23 +33,23 @@ // lldb-command:run // lldb-command:print no_padding1 -// lldbg-check:[...]$0 = NoPadding1 { x: [0, 1, 2], y: -3, z: [4.5, 5.5] } -// lldbr-check:(evec_in_struct::NoPadding1) no_padding1 = NoPadding1 { x: [0, 1, 2], y: -3, z: [4.5, 5.5] } +// lldbg-check:[...]$0 = { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } +// lldbr-check:(evec_in_struct::NoPadding1) no_padding1 = { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } // lldb-command:print no_padding2 -// lldbg-check:[...]$1 = NoPadding2 { x: [6, 7, 8], y: [[9, 10], [11, 12]] } -// lldbr-check:(evec_in_struct::NoPadding2) no_padding2 = NoPadding2 { x: [6, 7, 8], y: [[9, 10], [11, 12]] } +// lldbg-check:[...]$1 = { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } +// lldbr-check:(evec_in_struct::NoPadding2) no_padding2 = { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } // lldb-command:print struct_internal_padding -// lldbg-check:[...]$2 = StructInternalPadding { x: [13, 14], y: [15, 16] } -// lldbr-check:(evec_in_struct::StructInternalPadding) struct_internal_padding = StructInternalPadding { x: [13, 14], y: [15, 16] } +// lldbg-check:[...]$2 = { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } +// lldbr-check:(evec_in_struct::StructInternalPadding) struct_internal_padding = { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } // lldb-command:print single_vec -// lldbg-check:[...]$3 = SingleVec { x: [17, 18, 19, 20, 21] } -// lldbr-check:(evec_in_struct::SingleVec) single_vec = SingleVec { x: [17, 18, 19, 20, 21] } +// lldbg-check:[...]$3 = { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } +// lldbr-check:(evec_in_struct::SingleVec) single_vec = { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } // lldb-command:print struct_padded_at_end -// lldbg-check:[...]$4 = StructPaddedAtEnd { x: [22, 23], y: [24, 25] } -// lldbr-check:(evec_in_struct::StructPaddedAtEnd) struct_padded_at_end = StructPaddedAtEnd { x: [22, 23], y: [24, 25] } +// lldbg-check:[...]$4 = { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } +// lldbr-check:(evec_in_struct::StructPaddedAtEnd) struct_padded_at_end = { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/function-prologue-stepping-regular.rs b/src/test/debuginfo/function-prologue-stepping-regular.rs index 46901030f65..699ff84ee0a 100644 --- a/src/test/debuginfo/function-prologue-stepping-regular.rs +++ b/src/test/debuginfo/function-prologue-stepping-regular.rs @@ -30,9 +30,9 @@ // NON IMMEDIATE ARGS // lldb-command:print a -// lldb-check:[...]$3 = BigStruct { a: 3, b: 4, c: 5, d: 6, e: 7, f: 8, g: 9, h: 10 } +// lldb-check:[...]$3 = { a = 3, b = 4, c = 5, d = 6, e = 7, f = 8, g = 9, h = 10 } // lldb-command:print b -// lldb-check:[...]$4 = BigStruct { a: 11, b: 12, c: 13, d: 14, e: 15, f: 16, g: 17, h: 18 } +// lldb-check:[...]$4 = { a = 11, b = 12, c = 13, d = 14, e = 15, f = 16, g = 17, h = 18 } // lldb-command:continue // BINDING diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs index 7d2b4c95a05..2a8359de522 100644 --- a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs @@ -1,14 +1,14 @@ // ignore-tidy-linelength // ignore-lldb // ignore-android: FIXME(#10381) -// min-gdb-version: 7.11 +// min-gdb-version: 8.1 // compile-flags:-g // gdb-command: run // gdb-command: print regular_struct -// gdbg-check:$1 = RegularStruct = {the_first_field = 101, the_second_field = 102.5, the_third_field = false} +// gdbg-check:$1 = {the_first_field = 101, the_second_field = 102.5, the_third_field = false} // gdbr-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false} // gdb-command: print empty_struct diff --git a/src/test/debuginfo/generator-objects.rs b/src/test/debuginfo/generator-objects.rs index 382b0231d3b..0023f69d27f 100644 --- a/src/test/debuginfo/generator-objects.rs +++ b/src/test/debuginfo/generator-objects.rs @@ -24,16 +24,16 @@ // lldb-command:run // lldb-command:print b -// lldbg-check:(generator_objects::main::generator-0) $0 = generator-0(&0x[...]) +// lldbg-check:(generator_objects::main::generator-0) $0 = { 0 = 0x[...] } // lldb-command:continue // lldb-command:print b -// lldbg-check:(generator_objects::main::generator-0) $1 = generator-0(&0x[...]) +// lldbg-check:(generator_objects::main::generator-0) $1 = { 0 = 0x[...] } // lldb-command:continue // lldb-command:print b -// lldbg-check:(generator_objects::main::generator-0) $2 = generator-0(&0x[...]) +// lldbg-check:(generator_objects::main::generator-0) $2 = { 0 = 0x[...] } // lldb-command:continue // lldb-command:print b -// lldbg-check:(generator_objects::main::generator-0) $3 = generator-0(&0x[...]) +// lldbg-check:(generator_objects::main::generator-0) $3 = { 0 = 0x[...] } #![feature(omit_gdb_pretty_printer_section, generators, generator_trait)] #![omit_gdb_pretty_printer_section] diff --git a/src/test/debuginfo/generic-function.rs b/src/test/debuginfo/generic-function.rs index f5e34c39119..e8f3940c836 100644 --- a/src/test/debuginfo/generic-function.rs +++ b/src/test/debuginfo/generic-function.rs @@ -49,8 +49,8 @@ // lldbg-check:[...]$4 = 5 // lldbr-check:(i32) *t0 = 5 // lldb-command:print *t1 -// lldbg-check:[...]$5 = Struct { a: 6, b: 7.5 } -// lldbr-check:(generic_function::Struct) *t1 = Struct { a: 6, b: 7.5 } +// lldbg-check:[...]$5 = { a = 6 b = 7.5 } +// lldbr-check:(generic_function::Struct) *t1 = { a = 6 b = 7.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/generic-method-on-generic-struct.rs b/src/test/debuginfo/generic-method-on-generic-struct.rs index 7d151cfaa4a..f7767292222 100644 --- a/src/test/debuginfo/generic-method-on-generic-struct.rs +++ b/src/test/debuginfo/generic-method-on-generic-struct.rs @@ -67,8 +67,8 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = Struct<(u32, i32)> { x: (8888, -8888) } -// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { = 8888 = -8888 } } +// lldbg-check:[...]$0 = { x = { 0 = 8888, 1 = -8888 } } +// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { 0 = 8888 1 = -8888 } } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 // lldbr-check:(isize) arg1 = -1 @@ -79,8 +79,8 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = Struct<(u32, i32)> { x: (8888, -8888) } -// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) self = { x = { = 8888 = -8888 } } +// lldbg-check:[...]$3 = { x = { 0 = 8888, 1 = -8888 } } +// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) self = { x = { 0 = 8888, 1 = -8888 } } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 // lldbr-check:(isize) arg1 = -3 @@ -91,8 +91,8 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = Struct { x: 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) *self = Struct { x: 1234.5 } +// lldbg-check:[...]$6 = { x = 1234.5 } +// lldbr-check:(generic_method_on_generic_struct::Struct) *self = { x = 1234.5 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 // lldbr-check:(isize) arg1 = -5 @@ -103,8 +103,8 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = Struct { x: 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) self = Struct { x: 1234.5 } +// lldbg-check:[...]$9 = { x = 1234.5 } +// lldbr-check:(generic_method_on_generic_struct::Struct) self = { x = 1234.5 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 // lldbr-check:(isize) arg1 = -7 @@ -115,8 +115,8 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = Struct { x: 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) *self = Struct { x: 1234.5 } +// lldbg-check:[...]$12 = { x = 1234.5 } +// lldbr-check:(generic_method_on_generic_struct::Struct) *self = { x = 1234.5 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 // lldbr-check:(isize) arg1 = -9 diff --git a/src/test/debuginfo/issue-22656.rs b/src/test/debuginfo/issue-22656.rs index e4634d96a6f..f286566277e 100644 --- a/src/test/debuginfo/issue-22656.rs +++ b/src/test/debuginfo/issue-22656.rs @@ -4,7 +4,6 @@ // min-lldb-version: 310 // ignore-gdb -// ignore-tidy-linelength // compile-flags:-g @@ -12,11 +11,11 @@ // lldb-command:run // lldb-command:print v -// lldbg-check:[...]$0 = vec![1, 2, 3] -// lldbr-check:(alloc::vec::Vec) v = vec![1, 2, 3] +// lldbg-check:[...]$0 = size=3 { [0] = 1 [1] = 2 [2] = 3 } +// lldbr-check:(alloc::vec::Vec) v = size=3 { [0] = 1 [1] = 2 [2] = 3 } // lldb-command:print zs -// lldbg-check:[...]$1 = StructWithZeroSizedField { x: ZeroSizedStruct[...], y: 123, z: ZeroSizedStruct[...], w: 456 } -// lldbr-check:(issue_22656::StructWithZeroSizedField) zs = StructWithZeroSizedField { x: ZeroSizedStruct { }, y: 123, z: ZeroSizedStruct { }, w: 456 } +// lldbg-check:[...]$1 = { x = y = 123 z = w = 456 } +// lldbr-check:(issue_22656::StructWithZeroSizedField) zs = { x = y = 123 z = w = 456 } // lldbr-command:continue #![allow(unused_variables)] diff --git a/src/test/debuginfo/issue-57822.rs b/src/test/debuginfo/issue-57822.rs index e9cfa3f7d69..c2cc6f9d24c 100644 --- a/src/test/debuginfo/issue-57822.rs +++ b/src/test/debuginfo/issue-57822.rs @@ -22,10 +22,10 @@ // lldb-command:run // lldb-command:print g -// lldbg-check:(issue_57822::main::closure-1) $0 = closure-1(closure-0(1)) +// lldbg-check:(issue_57822::main::closure-1) $0 = { 0 = { 0 = 1 } } // lldb-command:print b -// lldbg-check:(issue_57822::main::generator-3) $1 = generator-3(generator-2(2)) +// lldbg-check:(issue_57822::main::generator-3) $1 = { 0 = { 0 = 2 } } #![feature(omit_gdb_pretty_printer_section, generators, generator_trait)] #![omit_gdb_pretty_printer_section] diff --git a/src/test/debuginfo/method-on-struct.rs b/src/test/debuginfo/method-on-struct.rs index cf8ed13e814..c764cf68323 100644 --- a/src/test/debuginfo/method-on-struct.rs +++ b/src/test/debuginfo/method-on-struct.rs @@ -63,7 +63,7 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = Struct { x: 100 } +// lldbg-check:[...]$0 = { x = 100 } // lldbr-check:(method_on_struct::Struct) *self = Struct { x: 100 } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 @@ -75,7 +75,7 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = Struct { x: 100 } +// lldbg-check:[...]$3 = { x = 100 } // lldbr-check:(method_on_struct::Struct) self = Struct { x: 100 } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 @@ -87,7 +87,7 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = Struct { x: 200 } +// lldbg-check:[...]$6 = { x = 200 } // lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 @@ -99,7 +99,7 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = Struct { x: 200 } +// lldbg-check:[...]$9 = { x = 200 } // lldbr-check:(method_on_struct::Struct) self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 @@ -111,7 +111,7 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = Struct { x: 200 } +// lldbg-check:[...]$12 = { x = 200 } // lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 diff --git a/src/test/debuginfo/method-on-trait.rs b/src/test/debuginfo/method-on-trait.rs index 9b321a8fad2..6dcf2896777 100644 --- a/src/test/debuginfo/method-on-trait.rs +++ b/src/test/debuginfo/method-on-trait.rs @@ -63,8 +63,8 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = Struct { x: 100 } -// lldbr-check:(method_on_trait::Struct) *self = Struct { x: 100 } +// lldbg-check:[...]$0 = { x = 100 } +// lldbr-check:(method_on_trait::Struct) *self = { x = 100 } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 // lldbr-check:(isize) arg1 = -1 @@ -75,8 +75,8 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = Struct { x: 100 } -// lldbr-check:(method_on_trait::Struct) self = Struct { x: 100 } +// lldbg-check:[...]$3 = { x = 100 } +// lldbr-check:(method_on_trait::Struct) self = { x = 100 } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 // lldbr-check:(isize) arg1 = -3 @@ -87,8 +87,8 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = Struct { x: 200 } -// lldbr-check:(method_on_trait::Struct) *self = Struct { x: 200 } +// lldbg-check:[...]$6 = { x = 200 } +// lldbr-check:(method_on_trait::Struct) *self = { x = 200 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 // lldbr-check:(isize) arg1 = -5 @@ -99,8 +99,8 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = Struct { x: 200 } -// lldbr-check:(method_on_trait::Struct) self = Struct { x: 200 } +// lldbg-check:[...]$9 = { x = 200 } +// lldbr-check:(method_on_trait::Struct) self = { x = 200 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 // lldbr-check:(isize) arg1 = -7 @@ -111,8 +111,8 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = Struct { x: 200 } -// lldbr-check:(method_on_trait::Struct) *self = Struct { x: 200 } +// lldbg-check:[...]$12 = { x = 200 } +// lldbr-check:(method_on_trait::Struct) *self = { x = 200 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 // lldbr-check:(isize) arg1 = -9 diff --git a/src/test/debuginfo/method-on-tuple-struct.rs b/src/test/debuginfo/method-on-tuple-struct.rs index dc32edd07a4..d06b606e973 100644 --- a/src/test/debuginfo/method-on-tuple-struct.rs +++ b/src/test/debuginfo/method-on-tuple-struct.rs @@ -63,8 +63,8 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = TupleStruct(100, -100.5) -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = TupleStruct(100, -100.5) +// lldbg-check:[...]$0 = { 0 = 100 1 = -100.5 } +// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 100 1 = -100.5 } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 // lldbr-check:(isize) arg1 = -1 @@ -75,8 +75,8 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = TupleStruct(100, -100.5) -// lldbr-check:(method_on_tuple_struct::TupleStruct) self = TupleStruct(100, -100.5) +// lldbg-check:[...]$3 = { 0 = 100 1 = -100.5 } +// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 100 1 = -100.5 } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 // lldbr-check:(isize) arg1 = -3 @@ -87,8 +87,8 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = TupleStruct(200, -200.5) -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = TupleStruct(200, -200.5) +// lldbg-check:[...]$6 = { 0 = 200 1 = -200.5 } +// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 // lldbr-check:(isize) arg1 = -5 @@ -99,8 +99,8 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = TupleStruct(200, -200.5) -// lldbr-check:(method_on_tuple_struct::TupleStruct) self = TupleStruct(200, -200.5) +// lldbg-check:[...]$9 = { 0 = 200 1 = -200.5 } +// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 200 1 = -200.5 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 // lldbr-check:(isize) arg1 = -7 @@ -111,8 +111,8 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = TupleStruct(200, -200.5) -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = TupleStruct(200, -200.5) +// lldbg-check:[...]$12 = { 0 = 200 1 = -200.5 } +// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 // lldbr-check:(isize) arg1 = -9 diff --git a/src/test/debuginfo/packed-struct-with-destructor.rs b/src/test/debuginfo/packed-struct-with-destructor.rs index d17e6e8193e..380e882a0fb 100644 --- a/src/test/debuginfo/packed-struct-with-destructor.rs +++ b/src/test/debuginfo/packed-struct-with-destructor.rs @@ -46,36 +46,36 @@ // lldb-command:run // lldb-command:print packed -// lldbg-check:[...]$0 = Packed { x: 123, y: 234, z: 345 } -// lldbr-check:(packed_struct_with_destructor::Packed) packed = Packed { x: 123, y: 234, z: 345 } +// lldbg-check:[...]$0 = { x = 123 y = 234 z = 345 } +// lldbr-check:(packed_struct_with_destructor::Packed) packed = { x = 123 y = 234 z = 345 } // lldb-command:print packedInPacked -// lldbg-check:[...]$1 = PackedInPacked { a: 1111, b: Packed { x: 2222, y: 3333, z: 4444 }, c: 5555, d: Packed { x: 6666, y: 7777, z: 8888 } } -// lldbr-check:(packed_struct_with_destructor::PackedInPacked) packedInPacked = PackedInPacked { a: 1111, b: Packed { x: 2222, y: 3333, z: 4444 }, c: 5555, d: Packed { x: 6666, y: 7777, z: 8888 } } +// lldbg-check:[...]$1 = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } +// lldbr-check:(packed_struct_with_destructor::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:print packedInUnpacked -// lldbg-check:[...]$2 = PackedInUnpacked { a: -1111, b: Packed { x: -2222, y: -3333, z: -4444 }, c: -5555, d: Packed { x: -6666, y: -7777, z: -8888 } } -// lldbr-check:(packed_struct_with_destructor::PackedInUnpacked) packedInUnpacked = PackedInUnpacked { a: -1111, b: Packed { x: -2222, y: -3333, z: -4444 }, c: -5555, d: Packed { x: -6666, y: -7777, z: -8888 } } +// lldbg-check:[...]$2 = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } +// lldbr-check:(packed_struct_with_destructor::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:print unpackedInPacked -// lldbg-check:[...]$3 = UnpackedInPacked { a: 987, b: Unpacked { x: 876, y: 765, z: 654 }, c: Unpacked { x: 543, y: 432, z: 321 }, d: 210 } -// lldbr-check:(packed_struct_with_destructor::UnpackedInPacked) unpackedInPacked = UnpackedInPacked { a: 987, b: Unpacked { x: 876, y: 765, z: 654 }, c: Unpacked { x: 543, y: 432, z: 321 }, d: 210 } +// lldbg-check:[...]$3 = { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } +// lldbr-check:(packed_struct_with_destructor::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } // lldb-command:print packedInPackedWithDrop -// lldbg-check:[...]$4 = PackedInPackedWithDrop { a: 11, b: Packed { x: 22, y: 33, z: 44 }, c: 55, d: Packed { x: 66, y: 77, z: 88 } } -// lldbr-check:(packed_struct_with_destructor::PackedInPackedWithDrop) packedInPackedWithDrop = PackedInPackedWithDrop { a: 11, b: Packed { x: 22, y: 33, z: 44 }, c: 55, d: Packed { x: 66, y: 77, z: 88 } } +// lldbg-check:[...]$4 = { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } +// lldbr-check:(packed_struct_with_destructor::PackedInPackedWithDrop) packedInPackedWithDrop = { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } // lldb-command:print packedInUnpackedWithDrop -// lldbg-check:[...]$5 = PackedInUnpackedWithDrop { a: -11, b: Packed { x: -22, y: -33, z: -44 }, c: -55, d: Packed { x: -66, y: -77, z: -88 } } -// lldbr-check:(packed_struct_with_destructor::PackedInUnpackedWithDrop) packedInUnpackedWithDrop = PackedInUnpackedWithDrop { a: -11, b: Packed { x: -22, y: -33, z: -44 }, c: -55, d: Packed { x: -66, y: -77, z: -88 } } +// lldbg-check:[...]$5 = { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } +// lldbr-check:(packed_struct_with_destructor::PackedInUnpackedWithDrop) packedInUnpackedWithDrop = { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } // lldb-command:print unpackedInPackedWithDrop -// lldbg-check:[...]$6 = UnpackedInPackedWithDrop { a: 98, b: Unpacked { x: 87, y: 76, z: 65 }, c: Unpacked { x: 54, y: 43, z: 32 }, d: 21 } -// lldbr-check:(packed_struct_with_destructor::UnpackedInPackedWithDrop) unpackedInPackedWithDrop = UnpackedInPackedWithDrop { a: 98, b: Unpacked { x: 87, y: 76, z: 65 }, c: Unpacked { x: 54, y: 43, z: 32 }, d: 21 } +// lldbg-check:[...]$6 = { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } +// lldbr-check:(packed_struct_with_destructor::UnpackedInPackedWithDrop) unpackedInPackedWithDrop = { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } // lldb-command:print deeplyNested -// lldbg-check:[...]$7 = DeeplyNested { a: PackedInPacked { a: 1, b: Packed { x: 2, y: 3, z: 4 }, c: 5, d: Packed { x: 6, y: 7, z: 8 } }, b: UnpackedInPackedWithDrop { a: 9, b: Unpacked { x: 10, y: 11, z: 12 }, c: Unpacked { x: 13, y: 14, z: 15 }, d: 16 }, c: PackedInUnpacked { a: 17, b: Packed { x: 18, y: 19, z: 20 }, c: 21, d: Packed { x: 22, y: 23, z: 24 } }, d: PackedInUnpackedWithDrop { a: 25, b: Packed { x: 26, y: 27, z: 28 }, c: 29, d: Packed { x: 30, y: 31, z: 32 } }, e: UnpackedInPacked { a: 33, b: Unpacked { x: 34, y: 35, z: 36 }, c: Unpacked { x: 37, y: 38, z: 39 }, d: 40 }, f: PackedInPackedWithDrop { a: 41, b: Packed { x: 42, y: 43, z: 44 }, c: 45, d: Packed { x: 46, y: 47, z: 48 } } } -// lldbr-check:(packed_struct_with_destructor::DeeplyNested) deeplyNested = DeeplyNested { a: PackedInPacked { a: 1, b: Packed { x: 2, y: 3, z: 4 }, c: 5, d: Packed { x: 6, y: 7, z: 8 } }, b: UnpackedInPackedWithDrop { a: 9, b: Unpacked { x: 10, y: 11, z: 12 }, c: Unpacked { x: 13, y: 14, z: 15 }, d: 16 }, c: PackedInUnpacked { a: 17, b: Packed { x: 18, y: 19, z: 20 }, c: 21, d: Packed { x: 22, y: 23, z: 24 } }, d: PackedInUnpackedWithDrop { a: 25, b: Packed { x: 26, y: 27, z: 28 }, c: 29, d: Packed { x: 30, y: 31, z: 32 } }, e: UnpackedInPacked { a: 33, b: Unpacked { x: 34, y: 35, z: 36 }, c: Unpacked { x: 37, y: 38, z: 39 }, d: 40 }, f: PackedInPackedWithDrop { a: 41, b: Packed { x: 42, y: 43, z: 44 }, c: 45, d: Packed { x: 46, y: 47, z: 48 } } } +// lldbg-check:[...]$7 = { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } +// lldbr-check:(packed_struct_with_destructor::DeeplyNested) deeplyNested = { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } #![allow(unused_variables)] diff --git a/src/test/debuginfo/packed-struct.rs b/src/test/debuginfo/packed-struct.rs index 494b61f9a24..9654847ce5d 100644 --- a/src/test/debuginfo/packed-struct.rs +++ b/src/test/debuginfo/packed-struct.rs @@ -36,20 +36,20 @@ // lldb-command:run // lldb-command:print packed -// lldbg-check:[...]$0 = Packed { x: 123, y: 234, z: 345 } -// lldbr-check:(packed_struct::Packed) packed = Packed { x: 123, y: 234, z: 345 } +// lldbg-check:[...]$0 = { x = 123 y = 234 z = 345 } +// lldbr-check:(packed_struct::Packed) packed = { x = 123 y = 234 z = 345 } // lldb-command:print packedInPacked -// lldbg-check:[...]$1 = PackedInPacked { a: 1111, b: Packed { x: 2222, y: 3333, z: 4444 }, c: 5555, d: Packed { x: 6666, y: 7777, z: 8888 } } -// lldbr-check:(packed_struct::PackedInPacked) packedInPacked = PackedInPacked { a: 1111, b: Packed { x: 2222, y: 3333, z: 4444 }, c: 5555, d: Packed { x: 6666, y: 7777, z: 8888 } } +// lldbg-check:[...]$1 = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } +// lldbr-check:(packed_struct::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:print packedInUnpacked -// lldbg-check:[...]$2 = PackedInUnpacked { a: -1111, b: Packed { x: -2222, y: -3333, z: -4444 }, c: -5555, d: Packed { x: -6666, y: -7777, z: -8888 } } -// lldbr-check:(packed_struct::PackedInUnpacked) packedInUnpacked = PackedInUnpacked { a: -1111, b: Packed { x: -2222, y: -3333, z: -4444 }, c: -5555, d: Packed { x: -6666, y: -7777, z: -8888 } } +// lldbg-check:[...]$2 = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } +// lldbr-check:(packed_struct::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:print unpackedInPacked -// lldbg-check:[...]$3 = UnpackedInPacked { a: 987, b: Unpacked { x: 876, y: 765, z: 654, w: 543 }, c: Unpacked { x: 432, y: 321, z: 210, w: 109 }, d: -98 } -// lldbr-check:(packed_struct::UnpackedInPacked) unpackedInPacked = UnpackedInPacked { a: 987, b: Unpacked { x: 876, y: 765, z: 654, w: 543 }, c: Unpacked { x: 432, y: 321, z: 210, w: 109 }, d: -98 } +// lldbg-check:[...]$3 = { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } +// lldbr-check:(packed_struct::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } // lldb-command:print sizeof(packed) // lldbg-check:[...]$4 = 14 diff --git a/src/test/debuginfo/pretty-huge-vec.rs b/src/test/debuginfo/pretty-huge-vec.rs index 2e3386b7a36..2616c946524 100644 --- a/src/test/debuginfo/pretty-huge-vec.rs +++ b/src/test/debuginfo/pretty-huge-vec.rs @@ -2,7 +2,7 @@ // ignore-freebsd: gdb package too new // ignore-android: FIXME(#10381) // compile-flags:-g -// min-gdb-version 7.7 +// min-gdb-version 8.1 // min-lldb-version: 310 // === GDB TESTS =================================================================================== @@ -10,11 +10,10 @@ // gdb-command: run // gdb-command: print vec -// gdb-check:$1 = Vec(len: 1000000000, cap: 1000000000) = {[...]...} +// gdb-check:$1 = Vec(size=1000000000) = {[...]...} // gdb-command: print slice -// gdb-check:$2 = &[u8](len: 1000000000) = {[...]...} - +// gdb-check:$2 = &[u8] {data_ptr: [...]"\000", length: 1000000000} #![allow(unused_variables)] diff --git a/src/test/debuginfo/pretty-std-collections.rs b/src/test/debuginfo/pretty-std-collections.rs index 1f4ff00100a..4e95a028e07 100644 --- a/src/test/debuginfo/pretty-std-collections.rs +++ b/src/test/debuginfo/pretty-std-collections.rs @@ -15,38 +15,76 @@ // gdb-command: run // gdb-command: print btree_set -// gdb-check:$1 = BTreeSet(len: 15) = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14} +// gdb-check:$1 = BTreeSet(size=15) = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14} // gdb-command: print empty_btree_set -// gdb-check:$2 = BTreeSet(len: 0) +// gdb-check:$2 = BTreeSet(size=0) // gdb-command: print btree_map -// gdb-check:$3 = BTreeMap(len: 15) = {[0] = 0, [1] = 1, [2] = 2, [3] = 3, [4] = 4, [5] = 5, [6] = 6, [7] = 7, [8] = 8, [9] = 9, [10] = 10, [11] = 11, [12] = 12, [13] = 13, [14] = 14} +// gdb-check:$3 = BTreeMap(size=15) = {[0] = 0, [1] = 1, [2] = 2, [3] = 3, [4] = 4, [5] = 5, [6] = 6, [7] = 7, [8] = 8, [9] = 9, [10] = 10, [11] = 11, [12] = 12, [13] = 13, [14] = 14} // gdb-command: print empty_btree_map -// gdb-check:$4 = BTreeMap(len: 0) +// gdb-check:$4 = BTreeMap(size=0) // gdb-command: print option_btree_map -// gdb-check:$5 = BTreeMap>(len: 2) = {[false] = [...], [true] = [...]} +// gdb-check:$5 = BTreeMap(size=2) = {[false] = [...], [true] = [...]} // (abbreviated because both values vary wildly over gdb versions and/or linux distributions) // gdb-command: print nasty_btree_map -// gdb-check:$6 = BTreeMap(len: 15) = {[0] = pretty_std_collections::MyLeafNode (0), [...]} +// gdb-check:$6 = BTreeMap(size=15) = {[0] = pretty_std_collections::MyLeafNode (0), [...]} // (abbreviated because it's boring but we need enough elements to include internal nodes) // gdb-command: print vec_deque -// gdb-check:$7 = VecDeque(len: 3, cap: 8) = {5, 3, 7} +// gdb-check:$7 = VecDeque(size=3) = {5, 3, 7} // gdb-command: print vec_deque2 -// gdb-check:$8 = VecDeque(len: 7, cap: 8) = {2, 3, 4, 5, 6, 7, 8} +// gdb-check:$8 = VecDeque(size=7) = {2, 3, 4, 5, 6, 7, 8} + +// gdb-command: print hash_map +// gdb-check:$9 = HashMap(size=4) = {[1] = 10, [2] = 20, [3] = 30, [4] = 40} + +// gdb-command: print hash_set +// gdb-check:$10 = HashSet(size=4) = {1, 2, 3, 4} + +// === LLDB TESTS ================================================================================== + +// lldb-command:run + +// lldb-command:print vec_deque +// lldbg-check:[...]$0 = size=3 { [0] = 5 [1] = 3 [2] = 7 } +// lldbr-check:(alloc::collections::vec_deque::VecDeque) vec_deque = size=3 = { [0] = 5 [1] = 3 [2] = 7 } + +// lldb-command:print vec_deque2 +// lldbg-check:[...]$1 = size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } +// lldbr-check:(alloc::collections::vec_deque::VecDeque) vec_deque2 = size=7 = { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } + +// lldb-command:print hash_map +// lldbg-check:[...]$2 = size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } +// lldbr-check:(std::collections::hash::map::HashMap) hash_map = size=4 size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } + +// lldb-command:print hash_set +// lldbg-check:[...]$3 = size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } +// lldbr-check:(std::collections::hash::set::HashSet) hash_set = size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } #![allow(unused_variables)] use std::collections::BTreeMap; use std::collections::BTreeSet; use std::collections::VecDeque; +use std::collections::HashMap; +use std::collections::HashSet; +use std::hash::{BuildHasherDefault, Hasher}; struct MyLeafNode(i32); // helps to ensure we don't blindly replace substring "LeafNode" +#[derive(Default)] +struct SimpleHasher { hash: u64 } + +impl Hasher for SimpleHasher { + fn finish(&self) -> u64 { self.hash } + fn write(&mut self, bytes: &[u8]) {} + fn write_u64(&mut self, i: u64) { self.hash = i } +} + fn main() { // BTreeSet let mut btree_set = BTreeSet::new(); @@ -87,6 +125,18 @@ fn main() { vec_deque2.pop_front(); vec_deque2.push_back(8); + // HashMap + let mut hash_map = HashMap::>::default(); + for i in 1..5 { + hash_map.insert(i, i * 10); + } + + // HashSet + let mut hash_set = HashSet::>::default(); + for i in 1..5 { + hash_set.insert(i); + } + zzz(); // #break } diff --git a/src/test/debuginfo/pretty-std.rs b/src/test/debuginfo/pretty-std.rs index a684d3b88fd..57721ce103c 100644 --- a/src/test/debuginfo/pretty-std.rs +++ b/src/test/debuginfo/pretty-std.rs @@ -61,6 +61,9 @@ // lldb-command: print none // lldb-check:[...]$5 = None +// lldb-command: print os_string +// lldb-check:[...]$6 = "IAMA OS string 😃"[...] + // === CDB TESTS ================================================================================== diff --git a/src/test/debuginfo/pretty-uninitialized-vec.rs b/src/test/debuginfo/pretty-uninitialized-vec.rs index 37aae65d42b..7ce004681e1 100644 --- a/src/test/debuginfo/pretty-uninitialized-vec.rs +++ b/src/test/debuginfo/pretty-uninitialized-vec.rs @@ -2,7 +2,7 @@ // ignore-freebsd: gdb package too new // ignore-android: FIXME(#10381) // compile-flags:-g -// min-gdb-version 7.7 +// min-gdb-version 8.1 // min-lldb-version: 310 // === GDB TESTS =================================================================================== @@ -10,7 +10,7 @@ // gdb-command: run // gdb-command: print vec -// gdb-check:$1 = Vec(len: [...], cap: [...])[...] +// gdb-check:$1 = Vec(size=[...])[...] #![allow(unused_variables)] diff --git a/src/test/debuginfo/rc_arc.rs b/src/test/debuginfo/rc_arc.rs new file mode 100644 index 00000000000..8ab8a2f9c1c --- /dev/null +++ b/src/test/debuginfo/rc_arc.rs @@ -0,0 +1,37 @@ +// compile-flags:-g + +// min-gdb-version: 8.1 + +// === GDB TESTS ================================================================================== + +// gdb-command:run + +// gdb-command:print r +// gdb-check:[...]$1 = Rc(strong=2, weak=1) = {value = 42, strong = 2, weak = 1} +// gdb-command:print a +// gdb-check:[...]$2 = Arc(strong=2, weak=1) = {value = 42, strong = 2, weak = 1} + + +// === LLDB TESTS ================================================================================== + +// lldb-command:run + +// lldb-command:print r +// lldb-check:[...]$0 = strong=2, weak=1 { value = 42 } +// lldb-command:print a +// lldb-check:[...]$1 = strong=2, weak=1 { data = 42 } + +use std::rc::Rc; +use std::sync::Arc; + +fn main() { + let r = Rc::new(42); + let r1 = Rc::clone(&r); + let w1 = Rc::downgrade(&r); + + let a = Arc::new(42); + let a1 = Arc::clone(&a); + let w2 = Arc::downgrade(&a); + + print!(""); // #break +} diff --git a/src/test/debuginfo/self-in-default-method.rs b/src/test/debuginfo/self-in-default-method.rs index bc150e33789..e15c08577e1 100644 --- a/src/test/debuginfo/self-in-default-method.rs +++ b/src/test/debuginfo/self-in-default-method.rs @@ -63,7 +63,7 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = Struct { x: 100 } +// lldbg-check:[...]$0 = { x = 100 } // lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 100 } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 @@ -75,7 +75,7 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = Struct { x: 100 } +// lldbg-check:[...]$3 = { x = 100 } // lldbr-check:(self_in_default_method::Struct) self = Struct { x: 100 } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 @@ -87,7 +87,7 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = Struct { x: 200 } +// lldbg-check:[...]$6 = { x = 200 } // lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 @@ -99,7 +99,7 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = Struct { x: 200 } +// lldbg-check:[...]$9 = { x = 200 } // lldbr-check:(self_in_default_method::Struct) self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 @@ -111,7 +111,7 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = Struct { x: 200 } +// lldbg-check:[...]$12 = { x = 200 } // lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 diff --git a/src/test/debuginfo/self-in-generic-default-method.rs b/src/test/debuginfo/self-in-generic-default-method.rs index 6c156230e53..7634e3247d5 100644 --- a/src/test/debuginfo/self-in-generic-default-method.rs +++ b/src/test/debuginfo/self-in-generic-default-method.rs @@ -63,7 +63,7 @@ // STACK BY REF // lldb-command:print *self -// lldbg-check:[...]$0 = Struct { x: 987 } +// lldbg-check:[...]$0 = { x = 987 } // lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 987 } // lldb-command:print arg1 // lldbg-check:[...]$1 = -1 @@ -75,7 +75,7 @@ // STACK BY VAL // lldb-command:print self -// lldbg-check:[...]$3 = Struct { x: 987 } +// lldbg-check:[...]$3 = { x = 987 } // lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 987 } // lldb-command:print arg1 // lldbg-check:[...]$4 = -3 @@ -87,7 +87,7 @@ // OWNED BY REF // lldb-command:print *self -// lldbg-check:[...]$6 = Struct { x: 879 } +// lldbg-check:[...]$6 = { x = 879 } // lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 } // lldb-command:print arg1 // lldbg-check:[...]$7 = -5 @@ -99,7 +99,7 @@ // OWNED BY VAL // lldb-command:print self -// lldbg-check:[...]$9 = Struct { x: 879 } +// lldbg-check:[...]$9 = { x = 879 } // lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 879 } // lldb-command:print arg1 // lldbg-check:[...]$10 = -7 @@ -111,7 +111,7 @@ // OWNED MOVED // lldb-command:print *self -// lldbg-check:[...]$12 = Struct { x: 879 } +// lldbg-check:[...]$12 = { x = 879 } // lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 } // lldb-command:print arg1 // lldbg-check:[...]$13 = -9 diff --git a/src/test/debuginfo/simple-struct.rs b/src/test/debuginfo/simple-struct.rs index b9475d5429a..49aa3bcbcaa 100644 --- a/src/test/debuginfo/simple-struct.rs +++ b/src/test/debuginfo/simple-struct.rs @@ -100,28 +100,28 @@ // lldb-command:run // lldb-command:print no_padding16 -// lldbg-check:[...]$0 = NoPadding16 { x: 10000, y: -10001 } -// lldbr-check:(simple_struct::NoPadding16) no_padding16 = NoPadding16 { x: 10000, y: -10001 } +// lldbg-check:[...]$0 = { x = 10000 y = -10001 } +// lldbr-check:(simple_struct::NoPadding16) no_padding16 = { x = 10000 y = -10001 } // lldb-command:print no_padding32 -// lldbg-check:[...]$1 = NoPadding32 { x: -10002, y: -10003.5, z: 10004 } -// lldbr-check:(simple_struct::NoPadding32) no_padding32 = NoPadding32 { x: -10002, y: -10003.5, z: 10004 } +// lldbg-check:[...]$1 = { x = -10002 y = -10003.5 z = 10004 } +// lldbr-check:(simple_struct::NoPadding32) no_padding32 = { x = -10002 y = -10003.5 z = 10004 } // lldb-command:print no_padding64 -// lldbg-check:[...]$2 = NoPadding64 { x: -10005.5, y: 10006, z: 10007 } -// lldbr-check:(simple_struct::NoPadding64) no_padding64 = NoPadding64 { x: -10005.5, y: 10006, z: 10007 } +// lldbg-check:[...]$2 = { x = -10005.5 y = 10006 z = 10007 } +// lldbr-check:(simple_struct::NoPadding64) no_padding64 = { x = -10005.5 y = 10006 z = 10007 } // lldb-command:print no_padding163264 -// lldbg-check:[...]$3 = NoPadding163264 { a: -10008, b: 10009, c: 10010, d: 10011 } -// lldbr-check:(simple_struct::NoPadding163264) no_padding163264 = NoPadding163264 { a: -10008, b: 10009, c: 10010, d: 10011 } +// lldbg-check:[...]$3 = { a = -10008 b = 10009 c = 10010 d = 10011 } +// lldbr-check:(simple_struct::NoPadding163264) no_padding163264 = { a = -10008 b = 10009 c = 10010 d = 10011 } // lldb-command:print internal_padding -// lldbg-check:[...]$4 = InternalPadding { x: 10012, y: -10013 } -// lldbr-check:(simple_struct::InternalPadding) internal_padding = InternalPadding { x: 10012, y: -10013 } +// lldbg-check:[...]$4 = { x = 10012 y = -10013 } +// lldbr-check:(simple_struct::InternalPadding) internal_padding = { x = 10012 y = -10013 } // lldb-command:print padding_at_end -// lldbg-check:[...]$5 = PaddingAtEnd { x: -10014, y: 10015 } -// lldbr-check:(simple_struct::PaddingAtEnd) padding_at_end = PaddingAtEnd { x: -10014, y: 10015 } +// lldbg-check:[...]$5 = { x = -10014 y = 10015 } +// lldbr-check:(simple_struct::PaddingAtEnd) padding_at_end = { x = -10014 y = 10015 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/src/test/debuginfo/simple-tuple.rs b/src/test/debuginfo/simple-tuple.rs index f7e5b5c982a..c2db5218e68 100644 --- a/src/test/debuginfo/simple-tuple.rs +++ b/src/test/debuginfo/simple-tuple.rs @@ -100,28 +100,28 @@ // lldb-command:run // lldb-command:print/d noPadding8 -// lldbg-check:[...]$0 = (-100, 100) -// lldbr-check:((i8, u8)) noPadding8 = { = -100 -100 = 100 100 } +// lldbg-check:[...]$0 = { 0 = -100 1 = 100 } +// lldbr-check:((i8, u8)) noPadding8 = { 0 = -100 1 = 100 } // lldb-command:print noPadding16 -// lldbg-check:[...]$1 = (0, 1, 2) -// lldbr-check:((i16, i16, u16)) noPadding16 = { = 0 = 1 = 2 } +// lldbg-check:[...]$1 = { 0 = 0 1 = 1 2 = 2 } +// lldbr-check:((i16, i16, u16)) noPadding16 = { 0 = 0 1 = 1 2 = 2 } // lldb-command:print noPadding32 -// lldbg-check:[...]$2 = (3, 4.5, 5) -// lldbr-check:((i32, f32, u32)) noPadding32 = { = 3 = 4.5 = 5 } +// lldbg-check:[...]$2 = { 0 = 3 1 = 4.5 2 = 5 } +// lldbr-check:((i32, f32, u32)) noPadding32 = { 0 = 3 1 = 4.5 2 = 5 } // lldb-command:print noPadding64 -// lldbg-check:[...]$3 = (6, 7.5, 8) -// lldbr-check:((i64, f64, u64)) noPadding64 = { = 6 = 7.5 = 8 } +// lldbg-check:[...]$3 = { 0 = 6 1 = 7.5 2 = 8 } +// lldbr-check:((i64, f64, u64)) noPadding64 = { 0 = 6 1 = 7.5 2 = 8 } // lldb-command:print internalPadding1 -// lldbg-check:[...]$4 = (9, 10) -// lldbr-check:((i16, i32)) internalPadding1 = { = 9 = 10 } +// lldbg-check:[...]$4 = { 0 = 9 1 = 10 } +// lldbr-check:((i16, i32)) internalPadding1 = { 0 = 9 1 = 10 } // lldb-command:print internalPadding2 -// lldbg-check:[...]$5 = (11, 12, 13, 14) -// lldbr-check:((i16, i32, u32, u64)) internalPadding2 = { = 11 = 12 = 13 = 14 } +// lldbg-check:[...]$5 = { 0 = 11 1 = 12 2 = 13 3 = 14 } +// lldbr-check:((i16, i32, u32, u64)) internalPadding2 = { 0 = 11 1 = 12 2 = 13 3 = 14 } // lldb-command:print paddingAtEnd -// lldbg-check:[...]$6 = (15, 16) -// lldbr-check:((i32, i16)) paddingAtEnd = { = 15 = 16 } +// lldbg-check:[...]$6 = { 0 = 15 1 = 16 } +// lldbr-check:((i32, i16)) paddingAtEnd = { 0 = 15 1 = 16 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/src/test/debuginfo/struct-in-struct.rs b/src/test/debuginfo/struct-in-struct.rs index 46340508ae0..a76a4c05d9b 100644 --- a/src/test/debuginfo/struct-in-struct.rs +++ b/src/test/debuginfo/struct-in-struct.rs @@ -25,36 +25,36 @@ // lldb-command:run // lldb-command:print three_simple_structs -// lldbg-check:[...]$0 = ThreeSimpleStructs { x: Simple { x: 1 }, y: Simple { x: 2 }, z: Simple { x: 3 } } -// lldbr-check:(struct_in_struct::ThreeSimpleStructs) three_simple_structs = ThreeSimpleStructs { x: Simple { x: 1 }, y: Simple { x: 2 }, z: Simple { x: 3 } } +// lldbg-check:[...]$0 = { x = { x = 1 } y = { x = 2 } z = { x = 3 } } +// lldbr-check:(struct_in_struct::ThreeSimpleStructs) three_simple_structs = { x = { x = 1 } y = { x = 2 } z = { x = 3 } } // lldb-command:print internal_padding_parent -// lldbg-check:[...]$1 = InternalPaddingParent { x: InternalPadding { x: 4, y: 5 }, y: InternalPadding { x: 6, y: 7 }, z: InternalPadding { x: 8, y: 9 } } -// lldbr-check:(struct_in_struct::InternalPaddingParent) internal_padding_parent = InternalPaddingParent { x: InternalPadding { x: 4, y: 5 }, y: InternalPadding { x: 6, y: 7 }, z: InternalPadding { x: 8, y: 9 } } +// lldbg-check:[...]$1 = { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } +// lldbr-check:(struct_in_struct::InternalPaddingParent) internal_padding_parent = { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } // lldb-command:print padding_at_end_parent -// lldbg-check:[...]$2 = PaddingAtEndParent { x: PaddingAtEnd { x: 10, y: 11 }, y: PaddingAtEnd { x: 12, y: 13 }, z: PaddingAtEnd { x: 14, y: 15 } } -// lldbr-check:(struct_in_struct::PaddingAtEndParent) padding_at_end_parent = PaddingAtEndParent { x: PaddingAtEnd { x: 10, y: 11 }, y: PaddingAtEnd { x: 12, y: 13 }, z: PaddingAtEnd { x: 14, y: 15 } } +// lldbg-check:[...]$2 = { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } +// lldbr-check:(struct_in_struct::PaddingAtEndParent) padding_at_end_parent = { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } // lldb-command:print mixed -// lldbg-check:[...]$3 = Mixed { x: PaddingAtEnd { x: 16, y: 17 }, y: InternalPadding { x: 18, y: 19 }, z: Simple { x: 20 }, w: 21 } -// lldbr-check:(struct_in_struct::Mixed) mixed = Mixed { x: PaddingAtEnd { x: 16, y: 17 }, y: InternalPadding { x: 18, y: 19 }, z: Simple { x: 20 }, w: 21 } +// lldbg-check:[...]$3 = { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } +// lldbr-check:(struct_in_struct::Mixed) mixed = { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } // lldb-command:print bag -// lldbg-check:[...]$4 = Bag { x: Simple { x: 22 } } -// lldbr-check:(struct_in_struct::Bag) bag = Bag { x: Simple { x: 22 } } +// lldbg-check:[...]$4 = { x = { x = 22 } } +// lldbr-check:(struct_in_struct::Bag) bag = { x = { x = 22 } } // lldb-command:print bag_in_bag -// lldbg-check:[...]$5 = BagInBag { x: Bag { x: Simple { x: 23 } } } -// lldbr-check:(struct_in_struct::BagInBag) bag_in_bag = BagInBag { x: Bag { x: Simple { x: 23 } } } +// lldbg-check:[...]$5 = { x = { x = { x = 23 } } } +// lldbr-check:(struct_in_struct::BagInBag) bag_in_bag = { x = { x = { x = 23 } } } // lldb-command:print tjo -// lldbg-check:[...]$6 = ThatsJustOverkill { x: BagInBag { x: Bag { x: Simple { x: 24 } } } } -// lldbr-check:(struct_in_struct::ThatsJustOverkill) tjo = ThatsJustOverkill { x: BagInBag { x: Bag { x: Simple { x: 24 } } } } +// lldbg-check:[...]$6 = { x = { x = { x = { x = 24 } } } } +// lldbr-check:(struct_in_struct::ThatsJustOverkill) tjo = { x = { x = { x = { x = 24 } } } } // lldb-command:print tree -// lldbg-check:[...]$7 = Tree { x: Simple { x: 25 }, y: InternalPaddingParent { x: InternalPadding { x: 26, y: 27 }, y: InternalPadding { x: 28, y: 29 }, z: InternalPadding { x: 30, y: 31 } }, z: BagInBag { x: Bag { x: Simple { x: 32 } } } } -// lldbr-check:(struct_in_struct::Tree) tree = Tree { x: Simple { x: 25 }, y: InternalPaddingParent { x: InternalPadding { x: 26, y: 27 }, y: InternalPadding { x: 28, y: 29 }, z: InternalPadding { x: 30, y: 31 } }, z: BagInBag { x: Bag { x: Simple { x: 32 } } } } +// lldbg-check:[...]$7 = { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } +// lldbr-check:(struct_in_struct::Tree) tree = { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/struct-with-destructor.rs b/src/test/debuginfo/struct-with-destructor.rs index c478e6d2222..ebae953cb4b 100644 --- a/src/test/debuginfo/struct-with-destructor.rs +++ b/src/test/debuginfo/struct-with-destructor.rs @@ -28,20 +28,20 @@ // lldb-command:run // lldb-command:print simple -// lldbg-check:[...]$0 = WithDestructor { x: 10, y: 20 } -// lldbr-check:(struct_with_destructor::WithDestructor) simple = WithDestructor { x: 10, y: 20 } +// lldbg-check:[...]$0 = { x = 10 y = 20 } +// lldbr-check:(struct_with_destructor::WithDestructor) simple = { x = 10 y = 20 } // lldb-command:print noDestructor -// lldbg-check:[...]$1 = NoDestructorGuarded { a: NoDestructor { x: 10, y: 20 }, guard: -1 } -// lldbr-check:(struct_with_destructor::NoDestructorGuarded) noDestructor = NoDestructorGuarded { a: NoDestructor { x: 10, y: 20 }, guard: -1 } +// lldbg-check:[...]$1 = { a = { x = 10 y = 20 } guard = -1 } +// lldbr-check:(struct_with_destructor::NoDestructorGuarded) noDestructor = { a = { x = 10 y = 20 } guard = -1 } // lldb-command:print withDestructor -// lldbg-check:[...]$2 = WithDestructorGuarded { a: WithDestructor { x: 10, y: 20 }, guard: -1 } -// lldbr-check:(struct_with_destructor::WithDestructorGuarded) withDestructor = WithDestructorGuarded { a: WithDestructor { x: 10, y: 20 }, guard: -1 } +// lldbg-check:[...]$2 = { a = { x = 10 y = 20 } guard = -1 } +// lldbr-check:(struct_with_destructor::WithDestructorGuarded) withDestructor = { a = { x = 10 y = 20 } guard = -1 } // lldb-command:print nested -// lldbg-check:[...]$3 = NestedOuter { a: NestedInner { a: WithDestructor { x: 7890, y: 9870 } } } -// lldbr-check:(struct_with_destructor::NestedOuter) nested = NestedOuter { a: NestedInner { a: WithDestructor { x: 7890, y: 9870 } } } +// lldbg-check:[...]$3 = { a = { a = { x = 7890 y = 9870 } } } +// lldbr-check:(struct_with_destructor::NestedOuter) nested = { a = { a = { x = 7890 y = 9870 } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/tuple-in-tuple.rs b/src/test/debuginfo/tuple-in-tuple.rs index 5727521f5f5..e0f940ca7a1 100644 --- a/src/test/debuginfo/tuple-in-tuple.rs +++ b/src/test/debuginfo/tuple-in-tuple.rs @@ -36,28 +36,28 @@ // lldb-command:run // lldb-command:print no_padding1 -// lldbg-check:[...]$0 = ((0, 1), 2, 3) -// lldbr-check:(((u32, u32), u32, u32)) no_padding1 = { = { = 0 = 1 } = 2 = 3 } +// lldbg-check:[...]$0 = { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } +// lldbr-check:(((u32, u32), u32, u32)) no_padding1 = { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } // lldb-command:print no_padding2 -// lldbg-check:[...]$1 = (4, (5, 6), 7) -// lldbr-check:((u32, (u32, u32), u32)) no_padding2 = { = 4 = { = 5 = 6 } = 7 } +// lldbg-check:[...]$1 = { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } +// lldbr-check:((u32, (u32, u32), u32)) no_padding2 = { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } // lldb-command:print no_padding3 -// lldbg-check:[...]$2 = (8, 9, (10, 11)) -// lldbr-check:((u32, u32, (u32, u32))) no_padding3 = { = 8 = 9 = { = 10 = 11 } } +// lldbg-check:[...]$2 = { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } +// lldbr-check:((u32, u32, (u32, u32))) no_padding3 = { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } // lldb-command:print internal_padding1 -// lldbg-check:[...]$3 = (12, (13, 14)) -// lldbr-check:((i16, (i32, i32))) internal_padding1 = { = 12 = { = 13 = 14 } } +// lldbg-check:[...]$3 = { 0 = 12 1 = { 0 = 13 1 = 14 } } +// lldbr-check:((i16, (i32, i32))) internal_padding1 = { 0 = 12 1 = { 0 = 13 1 = 14 } } // lldb-command:print internal_padding2 -// lldbg-check:[...]$4 = (15, (16, 17)) -// lldbr-check:((i16, (i16, i32))) internal_padding2 = { = 15 = { = 16 = 17 } } +// lldbg-check:[...]$4 = { 0 = 15 1 = { 0 = 16 1 = 17 } } +// lldbr-check:((i16, (i16, i32))) internal_padding2 = { 0 = 15 1 = { 0 = 16 1 = 17 } } // lldb-command:print padding_at_end1 -// lldbg-check:[...]$5 = (18, (19, 20)) -// lldbr-check:((i32, (i32, i16))) padding_at_end1 = { = 18 = { = 19 = 20 } } +// lldbg-check:[...]$5 = { 0 = 18 1 = { 0 = 19 1 = 20 } } +// lldbr-check:((i32, (i32, i16))) padding_at_end1 = { 0 = 18 1 = { 0 = 19 1 = 20 } } // lldb-command:print padding_at_end2 -// lldbg-check:[...]$6 = ((21, 22), 23) -// lldbr-check:(((i32, i16), i32)) padding_at_end2 = { = { = 21 = 22 } = 23 } +// lldbg-check:[...]$6 = { 0 = { 0 = 21 1 = 22 } 1 = 23 } +// lldbr-check:(((i32, i16), i32)) padding_at_end2 = { 0 = { 0 = 21 1 = 22 } 1 = 23 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/tuple-struct.rs b/src/test/debuginfo/tuple-struct.rs index f06ff176acd..78b6e6a54db 100644 --- a/src/test/debuginfo/tuple-struct.rs +++ b/src/test/debuginfo/tuple-struct.rs @@ -38,28 +38,28 @@ // lldb-command:run // lldb-command:print no_padding16 -// lldbg-check:[...]$0 = NoPadding16(10000, -10001) -// lldbr-check:(tuple_struct::NoPadding16) no_padding16 = { = 10000 = -10001 } +// lldbg-check:[...]$0 = { 0 = 10000 1 = -10001 } +// lldbr-check:(tuple_struct::NoPadding16) no_padding16 = { 0 = 10000 1 = -10001 } // lldb-command:print no_padding32 -// lldbg-check:[...]$1 = NoPadding32(-10002, -10003.5, 10004) -// lldbr-check:(tuple_struct::NoPadding32) no_padding32 = { = -10002 = -10003.5 = 10004 } +// lldbg-check:[...]$1 = { 0 = -10002 1 = -10003.5 2 = 10004 } +// lldbr-check:(tuple_struct::NoPadding32) no_padding32 = { 0 = -10002 1 = -10003.5 2 = 10004 } // lldb-command:print no_padding64 -// lldbg-check:[...]$2 = NoPadding64(-10005.5, 10006, 10007) -// lldbr-check:(tuple_struct::NoPadding64) no_padding64 = { = -10005.5 = 10006 = 10007 } +// lldbg-check:[...]$2 = { 0 = -10005.5 1 = 10006 2 = 10007 } +// lldbr-check:(tuple_struct::NoPadding64) no_padding64 = { 0 = -10005.5 1 = 10006 2 = 10007 } // lldb-command:print no_padding163264 -// lldbg-check:[...]$3 = NoPadding163264(-10008, 10009, 10010, 10011) -// lldbr-check:(tuple_struct::NoPadding163264) no_padding163264 = { = -10008 = 10009 = 10010 = 10011 } +// lldbg-check:[...]$3 = { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } +// lldbr-check:(tuple_struct::NoPadding163264) no_padding163264 = { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } // lldb-command:print internal_padding -// lldbg-check:[...]$4 = InternalPadding(10012, -10013) -// lldbr-check:(tuple_struct::InternalPadding) internal_padding = { = 10012 = -10013 } +// lldbg-check:[...]$4 = { 0 = 10012 1 = -10013 } +// lldbr-check:(tuple_struct::InternalPadding) internal_padding = { 0 = 10012 1 = -10013 } // lldb-command:print padding_at_end -// lldbg-check:[...]$5 = PaddingAtEnd(-10014, 10015) -// lldbr-check:(tuple_struct::PaddingAtEnd) padding_at_end = { = -10014 = 10015 } +// lldbg-check:[...]$5 = { 0 = -10014 1 = 10015 } +// lldbr-check:(tuple_struct::PaddingAtEnd) padding_at_end = { 0 = -10014 1 = 10015 } // This test case mainly makes sure that no field names are generated for tuple structs (as opposed // to all fields having the name ""). Otherwise they are handled the same a normal diff --git a/src/test/debuginfo/union-smoke.rs b/src/test/debuginfo/union-smoke.rs index 79b4030ee34..4d4b6cc96fb 100644 --- a/src/test/debuginfo/union-smoke.rs +++ b/src/test/debuginfo/union-smoke.rs @@ -19,13 +19,13 @@ // lldb-command:run // lldb-command:print u -// lldbg-check:[...]$0 = U { a: ('\x02', '\x02'), b: 514 } -// lldbr-check:(union_smoke::U) u = { a = { = 2 = 2 } b = 514 } +// lldbg-check:[...]$0 = { a = { 0 = '\x02' 1 = '\x02' } b = 514 } +// lldbr-check:(union_smoke::U) u = { a = { 0 = '\x02' 1 = '\x02' } b = 514 } // Don't test this with rust-enabled lldb for now; see // https://github.com/rust-lang-nursery/lldb/issues/18 // lldbg-command:print union_smoke::SU -// lldbg-check:[...]$1 = U { a: ('\x01', '\x01'), b: 257 } +// lldbg-check:[...]$1 = { a = { 0 = '\x01' 1 = '\x01' } b = 257 } #![allow(unused)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs index a0f0de20d0c..8ab6d141731 100644 --- a/src/test/debuginfo/var-captured-in-nested-closure.rs +++ b/src/test/debuginfo/var-captured-in-nested-closure.rs @@ -50,11 +50,11 @@ // lldbg-check:[...]$1 = 2 // lldbr-check:(isize) constant = 2 // lldb-command:print a_struct -// lldbg-check:[...]$2 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$2 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:print *struct_ref -// lldbg-check:[...]$3 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$3 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:print *owned // lldbg-check:[...]$4 = 6 // lldbr-check:(isize) *owned = 6 @@ -70,11 +70,11 @@ // lldbg-check:[...]$7 = 2 // lldbr-check:(isize) constant = 2 // lldb-command:print a_struct -// lldbg-check:[...]$8 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$8 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:print *struct_ref -// lldbg-check:[...]$9 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$9 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:print *owned // lldbg-check:[...]$10 = 6 // lldbr-check:(isize) *owned = 6 diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs index b6a3c32ac47..bd7c2bfe2c3 100644 --- a/src/test/debuginfo/var-captured-in-sendable-closure.rs +++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs @@ -27,8 +27,8 @@ // lldbg-check:[...]$0 = 1 // lldbr-check:(isize) constant = 1 // lldb-command:print a_struct -// lldbg-check:[...]$1 = Struct { a: -2, b: 3.5, c: 4 } -// lldbr-check:(var_captured_in_sendable_closure::Struct) a_struct = Struct { a: -2, b: 3.5, c: 4 } +// lldbg-check:[...]$1 = { a = -2 b = 3.5 c = 4 } +// lldbr-check:(var_captured_in_sendable_closure::Struct) a_struct = { a = -2 b = 3.5 c = 4 } // lldb-command:print *owned // lldbg-check:[...]$2 = 5 // lldbr-check:(isize) *owned = 5 diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs index 2402b5f6851..f53f8aaa670 100644 --- a/src/test/debuginfo/var-captured-in-stack-closure.rs +++ b/src/test/debuginfo/var-captured-in-stack-closure.rs @@ -46,11 +46,11 @@ // lldbg-check:[...]$1 = 2 // lldbr-check:(isize) constant = 2 // lldb-command:print a_struct -// lldbg-check:[...]$2 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$2 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:print *struct_ref -// lldbg-check:[...]$3 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$3 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:print *owned // lldbg-check:[...]$4 = 6 // lldbr-check:(isize) *owned = 6 @@ -64,11 +64,11 @@ // lldbg-check:[...]$6 = 2 // lldbr-check:(isize) constant = 2 // lldb-command:print a_struct -// lldbg-check:[...]$7 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$7 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:print *struct_ref -// lldbg-check:[...]$8 = Struct { a: -3, b: 4.5, c: 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = Struct { a: -3, b: 4.5, c: 5 } +// lldbg-check:[...]$8 = { a = -3 b = 4.5 c = 5 } +// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:print *owned // lldbg-check:[...]$9 = 6 // lldbr-check:(isize) *owned = 6 diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs index 8d9fc498882..c385491bd1d 100644 --- a/src/test/debuginfo/vec-slices.rs +++ b/src/test/debuginfo/vec-slices.rs @@ -72,28 +72,28 @@ // lldb-command:run // lldb-command:print empty -// lldbg-check:[...]$0 = &[] -// lldbr-check:(&[i64]) empty = &[] +// lldbg-check:[...]$0 = size=0 +// lldbr-check:(&[i64]) empty = size=0 // lldb-command:print singleton -// lldbg-check:[...]$1 = &[1] +// lldbg-check:[...]$1 = size=1 { [0] = 1 } // lldbr-check:(&[i64]) singleton = &[1] // lldb-command:print multiple -// lldbg-check:[...]$2 = &[2, 3, 4, 5] -// lldbr-check:(&[i64]) multiple = &[2, 3, 4, 5] +// lldbg-check:[...]$2 = size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } +// lldbr-check:(&[i64]) multiple = size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } // lldb-command:print slice_of_slice -// lldbg-check:[...]$3 = &[3, 4] -// lldbr-check:(&[i64]) slice_of_slice = &[3, 4] +// lldbg-check:[...]$3 = size=2 { [0] = 3 [1] = 4 } +// lldbr-check:(&[i64]) slice_of_slice = size=2 { [0] = 3 [1] = 4 } // lldb-command:print padded_tuple -// lldbg-check:[...]$4 = &[(6, 7), (8, 9)] -// lldbr-check:(&[(i32, i16)]) padded_tuple = { data_ptr = *[...] length = 2 } +// lldbg-check:[...]$4 = size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } +// lldbr-check:(&[(i32, i16)]) padded_tuple = size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } // lldb-command:print padded_struct -// lldbg-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }] -// lldbr-check:(&[vec_slices::AStruct]) padded_struct = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }] +// lldbg-check:[...]$5 = size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } +// lldbr-check:(&[vec_slices::AStruct]) padded_struct = size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } #![allow(dead_code, unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/test/debuginfo/vec.rs b/src/test/debuginfo/vec.rs index b0ee521c145..895661816b8 100644 --- a/src/test/debuginfo/vec.rs +++ b/src/test/debuginfo/vec.rs @@ -18,8 +18,8 @@ // lldb-command:run // lldb-command:print a -// lldbg-check:[...]$0 = [1, 2, 3] -// lldbr-check:([i32; 3]) a = [1, 2, 3] +// lldbg-check:[...]$0 = { [0] = 1 [1] = 2 [2] = 3 } +// lldbr-check:([i32; 3]) a = { [0] = 1 [1] = 2 [2] = 3 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs index 93a414ff6b9..93c53e779d5 100644 --- a/src/tools/compiletest/src/main.rs +++ b/src/tools/compiletest/src/main.rs @@ -464,11 +464,13 @@ fn common_inputs_stamp(config: &Config) -> Stamp { // Relevant pretty printer files let pretty_printer_files = [ - "src/etc/debugger_pretty_printers_common.py", + "src/etc/rust_types.py", "src/etc/gdb_load_rust_pretty_printers.py", - "src/etc/gdb_rust_pretty_printing.py", + "src/etc/gdb_lookup.py", + "src/etc/gdb_providers.py", "src/etc/lldb_batchmode.py", - "src/etc/lldb_rust_formatters.py", + "src/etc/lldb_lookup.py", + "src/etc/lldb_providers.py", ]; for file in &pretty_printer_files { let path = rust_src_dir.join(file); diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 63fd052a556..4949575fa6d 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -1079,15 +1079,38 @@ impl<'test> TestCx<'test> { // Switch LLDB into "Rust mode" let rust_src_root = self.config.find_rust_src_root().expect("Could not find Rust source root"); - let rust_pp_module_rel_path = Path::new("./src/etc/lldb_rust_formatters.py"); + let rust_pp_module_rel_path = Path::new("./src/etc/lldb_lookup.py"); let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path).to_str().unwrap().to_owned(); + let rust_type_regexes = vec![ + "^(alloc::([a-z_]+::)+)String$", + "^&str$", + "^&\\[.+\\]$", + "^(std::ffi::([a-z_]+::)+)OsString$", + "^(alloc::([a-z_]+::)+)Vec<.+>$", + "^(alloc::([a-z_]+::)+)VecDeque<.+>$", + "^(alloc::([a-z_]+::)+)BTreeSet<.+>$", + "^(alloc::([a-z_]+::)+)BTreeMap<.+>$", + "^(std::collections::([a-z_]+::)+)HashMap<.+>$", + "^(std::collections::([a-z_]+::)+)HashSet<.+>$", + "^(alloc::([a-z_]+::)+)Rc<.+>$", + "^(alloc::([a-z_]+::)+)Arc<.+>$", + "^(core::([a-z_]+::)+)Cell<.+>$", + "^(core::([a-z_]+::)+)Ref<.+>$", + "^(core::([a-z_]+::)+)RefMut<.+>$", + "^(core::([a-z_]+::)+)RefCell<.+>$", + ]; + script_str .push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[..])[..]); - script_str.push_str("type summary add --no-value "); - script_str.push_str("--python-function lldb_rust_formatters.print_val "); - script_str.push_str("-x \".*\" --category Rust\n"); + script_str.push_str("type synthetic add -l lldb_lookup.synthetic_lookup -x '.*' "); + script_str.push_str("--category Rust\n"); + for type_regex in rust_type_regexes { + script_str.push_str("type summary add -F lldb_lookup.summary_lookup -e -x -h "); + script_str.push_str(&format!("'{}' ", type_regex)); + script_str.push_str("--category Rust\n"); + } script_str.push_str("type category enable Rust\n"); // Set breakpoints on every line that contains the string "#break"