2014-07-30 08:56:42 -05:00
|
|
|
# Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
# file at the top-level directory of this distribution and at
|
|
|
|
# http://rust-lang.org/COPYRIGHT.
|
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
# option. This file may not be copied, modified, or distributed
|
|
|
|
# except according to those terms.
|
|
|
|
|
|
|
|
import gdb
|
|
|
|
|
|
|
|
#===============================================================================
|
|
|
|
# GDB Pretty Printing Module for Rust
|
|
|
|
#===============================================================================
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
def register_printers(objfile):
|
2015-01-27 01:50:24 -06:00
|
|
|
"Registers Rust pretty printers for the given objfile"
|
|
|
|
objfile.pretty_printers.append(rust_pretty_printer_lookup_function)
|
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
def rust_pretty_printer_lookup_function(val):
|
2015-01-27 01:50:24 -06:00
|
|
|
"Returns the correct Rust pretty printer for the given value if there is one"
|
|
|
|
type_code = val.type.code
|
|
|
|
|
|
|
|
if type_code == gdb.TYPE_CODE_STRUCT:
|
|
|
|
struct_kind = classify_struct(val.type)
|
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
if struct_kind == STRUCT_KIND_SLICE:
|
|
|
|
return RustSlicePrinter(val)
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if struct_kind == STRUCT_KIND_STR_SLICE:
|
|
|
|
return RustStringSlicePrinter(val)
|
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
if struct_kind == STRUCT_KIND_STD_VEC:
|
|
|
|
return RustStdVecPrinter(val)
|
|
|
|
|
|
|
|
if struct_kind == STRUCT_KIND_STD_STRING:
|
|
|
|
return RustStdStringPrinter(val)
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if struct_kind == STRUCT_KIND_TUPLE:
|
|
|
|
return RustTuplePrinter(val)
|
|
|
|
|
|
|
|
if struct_kind == STRUCT_KIND_TUPLE_STRUCT:
|
|
|
|
return RustTupleStructPrinter(val, False)
|
|
|
|
|
|
|
|
if struct_kind == STRUCT_KIND_CSTYLE_VARIANT:
|
|
|
|
return RustCStyleEnumPrinter(val[get_field_at_index(val, 0)])
|
|
|
|
|
|
|
|
if struct_kind == STRUCT_KIND_TUPLE_VARIANT:
|
|
|
|
return RustTupleStructPrinter(val, True)
|
|
|
|
|
|
|
|
if struct_kind == STRUCT_KIND_STRUCT_VARIANT:
|
|
|
|
return RustStructPrinter(val, True)
|
|
|
|
|
|
|
|
return RustStructPrinter(val, False)
|
|
|
|
|
|
|
|
# Enum handling
|
|
|
|
if type_code == gdb.TYPE_CODE_UNION:
|
|
|
|
enum_members = list(val.type.fields())
|
|
|
|
enum_member_count = len(enum_members)
|
|
|
|
|
|
|
|
if enum_member_count == 0:
|
|
|
|
return RustStructPrinter(val, False)
|
|
|
|
|
|
|
|
if enum_member_count == 1:
|
|
|
|
first_variant_name = enum_members[0].name
|
|
|
|
if first_variant_name is None:
|
|
|
|
# This is a singleton enum
|
|
|
|
return rust_pretty_printer_lookup_function(val[enum_members[0]])
|
|
|
|
else:
|
|
|
|
assert first_variant_name.startswith("RUST$ENCODED$ENUM$")
|
|
|
|
# This is a space-optimized enum.
|
|
|
|
# This means this enum has only two states, and Rust uses one
|
|
|
|
# of the fields somewhere in the struct to determine which of
|
|
|
|
# the two states it's in. The location of the field is encoded
|
|
|
|
# in the name as something like
|
|
|
|
# RUST$ENCODED$ENUM$(num$)*name_of_zero_state
|
|
|
|
last_separator_index = first_variant_name.rfind("$")
|
|
|
|
start_index = len("RUST$ENCODED$ENUM$")
|
|
|
|
disr_field_indices = first_variant_name[start_index:last_separator_index].split("$")
|
|
|
|
disr_field_indices = [int(index) for index in disr_field_indices]
|
|
|
|
|
|
|
|
sole_variant_val = val[enum_members[0]]
|
|
|
|
discriminant = sole_variant_val
|
|
|
|
for disr_field_index in disr_field_indices:
|
|
|
|
disr_field = get_field_at_index(discriminant, disr_field_index)
|
|
|
|
discriminant = discriminant[disr_field]
|
|
|
|
|
|
|
|
# If the discriminant field is a fat pointer we have to consider the
|
|
|
|
# first word as the true discriminant
|
|
|
|
if discriminant.type.code == gdb.TYPE_CODE_STRUCT:
|
|
|
|
discriminant = discriminant[get_field_at_index(discriminant, 0)]
|
|
|
|
|
|
|
|
if discriminant == 0:
|
|
|
|
null_variant_name = first_variant_name[last_separator_index + 1:]
|
|
|
|
return IdentityPrinter(null_variant_name)
|
|
|
|
|
|
|
|
return rust_pretty_printer_lookup_function(sole_variant_val)
|
|
|
|
|
|
|
|
# This is a regular enum, extract the discriminant
|
|
|
|
discriminant_name, discriminant_val = extract_discriminant_value(val)
|
|
|
|
return rust_pretty_printer_lookup_function(val[enum_members[discriminant_val]])
|
|
|
|
|
|
|
|
# No pretty printer has been found
|
|
|
|
return None
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
#=------------------------------------------------------------------------------
|
|
|
|
# Pretty Printer Classes
|
|
|
|
#=------------------------------------------------------------------------------
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
class RustStructPrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, val, hide_first_field):
|
|
|
|
self.val = val
|
|
|
|
self.hide_first_field = hide_first_field
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
return self.val.type.tag
|
|
|
|
|
|
|
|
def children(self):
|
|
|
|
cs = []
|
|
|
|
for field in self.val.type.fields():
|
|
|
|
field_name = field.name
|
|
|
|
# Normally the field name is used as a key to access the field
|
|
|
|
# value, because that's also supported in older versions of GDB...
|
|
|
|
field_key = field_name
|
|
|
|
if field_name is None:
|
|
|
|
field_name = ""
|
|
|
|
# ... but for fields without a name (as in tuples), we have to
|
|
|
|
# fall back to the newer method of using the field object
|
|
|
|
# directly as key. In older versions of GDB, this will just
|
|
|
|
# fail.
|
|
|
|
field_key = field
|
|
|
|
name_value_tuple = (field_name, self.val[field_key])
|
|
|
|
cs.append(name_value_tuple)
|
|
|
|
|
|
|
|
if self.hide_first_field:
|
|
|
|
cs = cs[1:]
|
|
|
|
|
|
|
|
return cs
|
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
class RustTuplePrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, val):
|
|
|
|
self.val = val
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
def to_string(self):
|
|
|
|
return None
|
|
|
|
|
|
|
|
def children(self):
|
|
|
|
cs = []
|
|
|
|
for field in self.val.type.fields():
|
|
|
|
cs.append(("", self.val[field]))
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
return cs
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
def display_hint(self):
|
|
|
|
return "array"
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
|
|
|
|
class RustTupleStructPrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, val, hide_first_field):
|
|
|
|
self.val = val
|
|
|
|
self.hide_first_field = hide_first_field
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
def to_string(self):
|
|
|
|
return self.val.type.tag
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
def children(self):
|
|
|
|
cs = []
|
|
|
|
for field in self.val.type.fields():
|
|
|
|
cs.append(("", self.val[field]))
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if self.hide_first_field:
|
|
|
|
cs = cs[1:]
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
return cs
|
|
|
|
|
|
|
|
def display_hint(self):
|
|
|
|
return "array"
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
class RustSlicePrinter:
|
|
|
|
def __init__(self, val):
|
|
|
|
self.val = val
|
|
|
|
|
|
|
|
def display_hint(self):
|
|
|
|
return "array"
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
length = int(self.val["length"])
|
|
|
|
return self.val.type.tag + ("(len: %i)" % length)
|
|
|
|
|
|
|
|
def children(self):
|
|
|
|
cs = []
|
|
|
|
length = int(self.val["length"])
|
|
|
|
data_ptr = self.val["data_ptr"]
|
|
|
|
assert data_ptr.type.code == gdb.TYPE_CODE_PTR
|
|
|
|
pointee_type = data_ptr.type.target()
|
|
|
|
|
|
|
|
for index in range(0, length):
|
|
|
|
cs.append((str(index), (data_ptr + index).dereference()))
|
|
|
|
|
|
|
|
return cs
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
class RustStringSlicePrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, val):
|
|
|
|
self.val = val
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
slice_byte_len = self.val["length"]
|
|
|
|
return '"%s"' % self.val["data_ptr"].string(encoding="utf-8", length=slice_byte_len)
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
class RustStdVecPrinter:
|
|
|
|
def __init__(self, val):
|
|
|
|
self.val = val
|
|
|
|
|
|
|
|
def display_hint(self):
|
|
|
|
return "array"
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
length = int(self.val["len"])
|
|
|
|
cap = int(self.val["cap"])
|
|
|
|
return self.val.type.tag + ("(len: %i, cap: %i)" % (length, cap))
|
|
|
|
|
|
|
|
def children(self):
|
|
|
|
cs = []
|
|
|
|
(length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val)
|
|
|
|
pointee_type = data_ptr.type.target()
|
|
|
|
|
|
|
|
for index in range(0, length):
|
|
|
|
cs.append((str(index), (data_ptr + index).dereference()))
|
|
|
|
return cs
|
|
|
|
|
|
|
|
class RustStdStringPrinter:
|
|
|
|
def __init__(self, val):
|
|
|
|
self.val = val
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
(length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val["vec"])
|
|
|
|
return '"%s"' % data_ptr.string(encoding="utf-8", length=length)
|
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
class RustCStyleEnumPrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, val):
|
|
|
|
assert val.type.code == gdb.TYPE_CODE_ENUM
|
|
|
|
self.val = val
|
|
|
|
|
|
|
|
def to_string(self):
|
|
|
|
return str(self.val)
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
|
|
|
|
class IdentityPrinter:
|
2015-01-27 01:50:24 -06:00
|
|
|
def __init__(self, string):
|
|
|
|
self.string = string
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
def to_string(self):
|
|
|
|
return self.string
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
STRUCT_KIND_REGULAR_STRUCT = 0
|
|
|
|
STRUCT_KIND_TUPLE_STRUCT = 1
|
|
|
|
STRUCT_KIND_TUPLE = 2
|
|
|
|
STRUCT_KIND_TUPLE_VARIANT = 3
|
|
|
|
STRUCT_KIND_STRUCT_VARIANT = 4
|
|
|
|
STRUCT_KIND_CSTYLE_VARIANT = 5
|
2015-03-12 11:05:44 -05:00
|
|
|
STRUCT_KIND_SLICE = 6
|
|
|
|
STRUCT_KIND_STR_SLICE = 7
|
|
|
|
STRUCT_KIND_STD_VEC = 8
|
|
|
|
STRUCT_KIND_STD_STRING = 9
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
def classify_struct(type):
|
2015-03-12 11:05:44 -05:00
|
|
|
# print("\nclassify_struct: tag=%s\n" % type.tag)
|
2015-01-27 01:50:24 -06:00
|
|
|
if type.tag == "&str":
|
|
|
|
return STRUCT_KIND_STR_SLICE
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
if type.tag.startswith("&[") and type.tag.endswith("]"):
|
|
|
|
return STRUCT_KIND_SLICE
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
fields = list(type.fields())
|
|
|
|
field_count = len(fields)
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if field_count == 0:
|
|
|
|
return STRUCT_KIND_REGULAR_STRUCT
|
|
|
|
|
2015-03-12 11:05:44 -05:00
|
|
|
if (field_count == 3 and
|
|
|
|
fields[0].name == "ptr" and
|
|
|
|
fields[1].name == "len" and
|
|
|
|
fields[2].name == "cap" and
|
|
|
|
type.tag.startswith("Vec<")):
|
|
|
|
return STRUCT_KIND_STD_VEC
|
|
|
|
|
|
|
|
if (field_count == 1 and
|
|
|
|
fields[0].name == "vec" and
|
|
|
|
type.tag == "String"):
|
|
|
|
return STRUCT_KIND_STD_STRING
|
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if fields[0].name == "RUST$ENUM$DISR":
|
|
|
|
if field_count == 1:
|
|
|
|
return STRUCT_KIND_CSTYLE_VARIANT
|
|
|
|
elif fields[1].name is None:
|
|
|
|
return STRUCT_KIND_TUPLE_VARIANT
|
|
|
|
else:
|
|
|
|
return STRUCT_KIND_STRUCT_VARIANT
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
if fields[0].name is None:
|
|
|
|
if type.tag.startswith("("):
|
|
|
|
return STRUCT_KIND_TUPLE
|
|
|
|
else:
|
|
|
|
return STRUCT_KIND_TUPLE_STRUCT
|
2014-07-30 08:56:42 -05:00
|
|
|
|
2015-01-27 01:50:24 -06:00
|
|
|
return STRUCT_KIND_REGULAR_STRUCT
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
|
|
|
|
def extract_discriminant_value(enum_val):
|
2015-01-27 01:50:24 -06:00
|
|
|
assert enum_val.type.code == gdb.TYPE_CODE_UNION
|
|
|
|
for variant_descriptor in enum_val.type.fields():
|
|
|
|
variant_val = enum_val[variant_descriptor]
|
|
|
|
for field in variant_val.type.fields():
|
|
|
|
return (field.name, int(variant_val[field]))
|
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
def first_field(val):
|
2015-01-27 01:50:24 -06:00
|
|
|
for field in val.type.fields():
|
|
|
|
return field
|
|
|
|
|
2014-07-30 08:56:42 -05:00
|
|
|
|
|
|
|
def get_field_at_index(val, index):
|
2015-01-27 01:50:24 -06:00
|
|
|
i = 0
|
|
|
|
for field in val.type.fields():
|
|
|
|
if i == index:
|
|
|
|
return field
|
|
|
|
i += 1
|
|
|
|
return None
|
2015-03-12 11:05:44 -05:00
|
|
|
|
|
|
|
def extract_length_and_data_ptr_from_std_vec(vec_val):
|
|
|
|
length = int(vec_val["len"])
|
|
|
|
vec_ptr_val = vec_val["ptr"]
|
|
|
|
unique_ptr_val = vec_ptr_val[first_field(vec_ptr_val)]
|
|
|
|
data_ptr = unique_ptr_val[first_field(unique_ptr_val)]
|
|
|
|
assert data_ptr.type.code == gdb.TYPE_CODE_PTR
|
|
|
|
return (length, data_ptr)
|