fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #71365 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum4fb7144ed15

1.43.0
10.5 KiB305 linesraw
1import lldb
2import debugger_pretty_printers_common as rustpp
3
4# ===============================================================================
5# LLDB Pretty Printing Module for Rust
6# ===============================================================================
7
8
9class LldbType(rustpp.Type):
10
11    def __init__(self, ty):
12        super(LldbType, self).__init__()
13        self.ty = ty
14        self.fields = None
15
16    def get_unqualified_type_name(self):
17        qualified_name = self.ty.GetName()
18
19        if qualified_name is None:
20            return qualified_name
21
22        return rustpp.extract_type_name(qualified_name).replace("&'static ", "&")
23
24    def get_dwarf_type_kind(self):
25        type_class = self.ty.GetTypeClass()
26
27        if type_class == lldb.eTypeClassStruct:
28            return rustpp.DWARF_TYPE_CODE_STRUCT
29
30        if type_class == lldb.eTypeClassUnion:
31            return rustpp.DWARF_TYPE_CODE_UNION
32
33        if type_class == lldb.eTypeClassPointer:
34            return rustpp.DWARF_TYPE_CODE_PTR
35
36        if type_class == lldb.eTypeClassArray:
37            return rustpp.DWARF_TYPE_CODE_ARRAY
38
39        if type_class == lldb.eTypeClassEnumeration:
40            return rustpp.DWARF_TYPE_CODE_ENUM
41
42        return None
43
44    def get_fields(self):
45        assert ((self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_STRUCT) or
46                (self.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_UNION))
47        if self.fields is None:
48            self.fields = list(self.ty.fields)
49        return self.fields
50
51    def get_wrapped_value(self):
52        return self.ty
53
54
55class LldbValue(rustpp.Value):
56    def __init__(self, lldb_val):
57        ty = lldb_val.type
58        wty = LldbType(ty)
59        super(LldbValue, self).__init__(wty)
60        self.lldb_val = lldb_val
61        self.children = {}
62
63    def get_child_at_index(self, index):
64        child = self.children.get(index)
65        if child is None:
66            lldb_field = self.lldb_val.GetChildAtIndex(index)
67            child = LldbValue(lldb_field)
68            self.children[index] = child
69        return child
70
71    def as_integer(self):
72        return self.lldb_val.GetValueAsUnsigned()
73
74    def get_wrapped_value(self):
75        return self.lldb_val
76
77
78def print_val(lldb_val, internal_dict):
79    val = LldbValue(lldb_val)
80    type_kind = val.type.get_type_kind()
81
82    if (type_kind == rustpp.TYPE_KIND_REGULAR_STRUCT or
83        type_kind == rustpp.TYPE_KIND_REGULAR_UNION or
84        type_kind == rustpp.TYPE_KIND_EMPTY):
85        return print_struct_val(val,
86                                internal_dict,
87                                omit_first_field=False,
88                                omit_type_name=False,
89                                is_tuple_like=False)
90
91    if type_kind == rustpp.TYPE_KIND_STRUCT_VARIANT:
92        return print_struct_val(val,
93                                internal_dict,
94                                omit_first_field=True,
95                                omit_type_name=False,
96                                is_tuple_like=False)
97
98    if type_kind == rustpp.TYPE_KIND_SLICE:
99        return print_vec_slice_val(val, internal_dict)
100
101    if type_kind == rustpp.TYPE_KIND_STR_SLICE:
102        return print_str_slice_val(val, internal_dict)
103
104    if type_kind == rustpp.TYPE_KIND_STD_VEC:
105        return print_std_vec_val(val, internal_dict)
106
107    if type_kind == rustpp.TYPE_KIND_STD_STRING:
108        return print_std_string_val(val, internal_dict)
109
110    if type_kind == rustpp.TYPE_KIND_TUPLE:
111        return print_struct_val(val,
112                                internal_dict,
113                                omit_first_field=False,
114                                omit_type_name=True,
115                                is_tuple_like=True)
116
117    if type_kind == rustpp.TYPE_KIND_TUPLE_STRUCT:
118        return print_struct_val(val,
119                                internal_dict,
120                                omit_first_field=False,
121                                omit_type_name=False,
122                                is_tuple_like=True)
123
124    if type_kind == rustpp.TYPE_KIND_CSTYLE_VARIANT:
125        return val.type.get_unqualified_type_name()
126
127    if type_kind == rustpp.TYPE_KIND_TUPLE_VARIANT:
128        return print_struct_val(val,
129                                internal_dict,
130                                omit_first_field=True,
131                                omit_type_name=False,
132                                is_tuple_like=True)
133
134    if type_kind == rustpp.TYPE_KIND_SINGLETON_ENUM:
135        return print_val(lldb_val.GetChildAtIndex(0), internal_dict)
136
137    if type_kind == rustpp.TYPE_KIND_PTR:
138        return print_pointer_val(val, internal_dict)
139
140    if type_kind == rustpp.TYPE_KIND_FIXED_SIZE_VEC:
141        return print_fixed_size_vec_val(val, internal_dict)
142
143    if type_kind == rustpp.TYPE_KIND_REGULAR_ENUM:
144        # This is a regular enum, extract the discriminant
145        discriminant_val = rustpp.get_discriminant_value_as_integer(val)
146        return print_val(lldb_val.GetChildAtIndex(discriminant_val), internal_dict)
147
148    if type_kind == rustpp.TYPE_KIND_COMPRESSED_ENUM:
149        encoded_enum_info = rustpp.EncodedEnumInfo(val)
150        if encoded_enum_info.is_null_variant():
151            return encoded_enum_info.get_null_variant_name()
152
153        non_null_val = encoded_enum_info.get_non_null_variant_val()
154        return print_val(non_null_val.get_wrapped_value(), internal_dict)
155
156    # No pretty printer has been found
157    return lldb_val.GetValue()
158
159
160# =---------------------------------------------------------------------------------------
161# Type-Specialized Printing Functions
162# =---------------------------------------------------------------------------------------
163
164def print_struct_val(val, internal_dict, omit_first_field, omit_type_name, is_tuple_like):
165    """
166    Prints a struct, tuple, or tuple struct value with Rust syntax.
167    Ignores any fields before field_start_index.
168    """
169    assert (val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_STRUCT or
170            val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_UNION)
171
172    if omit_type_name:
173        type_name = ""
174    else:
175        type_name = val.type.get_unqualified_type_name()
176
177    if is_tuple_like:
178        template = "%(type_name)s(%(body)s)"
179        separator = ", "
180    else:
181        template = "%(type_name)s {\n%(body)s\n}"
182        separator = ", \n"
183
184    fields = val.type.get_fields()
185
186    def render_child(child_index):
187        this = ""
188        if not is_tuple_like:
189            field_name = fields[child_index].name
190            this += field_name + ": "
191
192        field_val = val.get_child_at_index(child_index)
193
194        if not field_val.get_wrapped_value().IsValid():
195            field = fields[child_index]
196            # LLDB is not good at handling zero-sized values, so we have to help
197            # it a little
198            if field.GetType().GetByteSize() == 0:
199                return this + rustpp.extract_type_name(field.GetType().GetName())
200            else:
201                return this + "<invalid value>"
202
203        return this + print_val(field_val.get_wrapped_value(), internal_dict)
204
205    if omit_first_field:
206        field_start_index = 1
207    else:
208        field_start_index = 0
209
210    body = separator.join([render_child(idx) for idx in range(field_start_index, len(fields))])
211
212    return template % {"type_name": type_name,
213                       "body": body}
214
215
216def print_pointer_val(val, internal_dict):
217    """Prints a pointer value with Rust syntax"""
218    assert val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_PTR
219    sigil = "&"
220    type_name = val.type.get_unqualified_type_name()
221    if type_name and type_name[0:1] in ["&", "*"]:
222        sigil = type_name[0:1]
223
224    return sigil + hex(val.as_integer())
225
226
227def print_fixed_size_vec_val(val, internal_dict):
228    assert val.type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_ARRAY
229    lldb_val = val.get_wrapped_value()
230
231    output = "["
232
233    for i in range(lldb_val.num_children):
234        output += print_val(lldb_val.GetChildAtIndex(i), internal_dict)
235        if i != lldb_val.num_children - 1:
236            output += ", "
237
238    output += "]"
239    return output
240
241
242def print_vec_slice_val(val, internal_dict):
243    (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(val)
244    return "&[%s]" % print_array_of_values(val.get_wrapped_value().GetName(),
245                                           data_ptr,
246                                           length,
247                                           internal_dict)
248
249
250def print_std_vec_val(val, internal_dict):
251    (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(val)
252    return "vec![%s]" % print_array_of_values(val.get_wrapped_value().GetName(),
253                                              data_ptr,
254                                              length,
255                                              internal_dict)
256
257
258def print_str_slice_val(val, internal_dict):
259    (length, data_ptr) = rustpp.extract_length_and_ptr_from_slice(val)
260    return read_utf8_string(data_ptr, length)
261
262
263def print_std_string_val(val, internal_dict):
264    vec = val.get_child_at_index(0)
265    (length, data_ptr, cap) = rustpp.extract_length_ptr_and_cap_from_std_vec(vec)
266    return read_utf8_string(data_ptr, length)
267
268# =-----------------------------------------------------------------------
269# Helper Functions
270# =-----------------------------------------------------------------------
271
272
273def print_array_of_values(array_name, data_ptr_val, length, internal_dict):
274    """Prints a contiguous memory range, interpreting it as values of the
275       pointee-type of data_ptr_val."""
276
277    data_ptr_type = data_ptr_val.type
278    assert data_ptr_type.get_dwarf_type_kind() == rustpp.DWARF_TYPE_CODE_PTR
279
280    element_type = data_ptr_type.get_wrapped_value().GetPointeeType()
281    element_type_size = element_type.GetByteSize()
282
283    start_address = data_ptr_val.as_integer()
284    raw_value = data_ptr_val.get_wrapped_value()
285
286    def render_element(i):
287        address = start_address + i * element_type_size
288        element_val = raw_value.CreateValueFromAddress(array_name + ("[%s]" % i),
289                                                       address,
290                                                       element_type)
291        return print_val(element_val, internal_dict)
292
293    return ', '.join([render_element(i) for i in range(length)])
294
295
296def read_utf8_string(ptr_val, byte_count):
297    if byte_count == 0:
298        return '""'
299    error = lldb.SBError()
300    process = ptr_val.get_wrapped_value().GetProcess()
301    data = process.ReadMemory(ptr_val.as_integer(), byte_count, error)
302    if error.Success():
303        return '"%s"' % data.decode(encoding='UTF-8')
304    else:
305        return '<error: %s>' % error.GetCString()