mirror of https://github.com/rust-lang/rust
459 lines
15 KiB
Python
459 lines
15 KiB
Python
from sys import version_info
|
|
|
|
import gdb
|
|
|
|
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
|
|
# BACKCOMPAT: rust 1.60
|
|
# https://github.com/rust-lang/rust/commit/2a91eeac1a2d27dd3de1bf55515d765da20fd86f
|
|
ptr = unique_or_nonnull["pointer"]
|
|
return ptr if ptr.type.code == gdb.TYPE_CODE_PTR else ptr[ptr.type.fields()[0]]
|
|
|
|
|
|
# GDB 14 has a tag class that indicates that extension methods are ok
|
|
# to call. Use of this tag only requires that printers hide local
|
|
# attributes and methods by prefixing them with "_".
|
|
if hasattr(gdb, 'ValuePrinter'):
|
|
printer_base = gdb.ValuePrinter
|
|
else:
|
|
printer_base = object
|
|
|
|
|
|
class EnumProvider(printer_base):
|
|
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(printer_base):
|
|
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(printer_base):
|
|
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(printer_base):
|
|
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"
|
|
|
|
def _enumerate_array_elements(element_ptrs):
|
|
for (i, element_ptr) in enumerate(element_ptrs):
|
|
key = "[{}]".format(i)
|
|
element = element_ptr.dereference()
|
|
|
|
try:
|
|
# rust-lang/rust#64343: passing deref expr to `str` allows
|
|
# catching exception on garbage pointer
|
|
str(element)
|
|
except RuntimeError:
|
|
yield key, "inaccessible"
|
|
|
|
break
|
|
|
|
yield key, element
|
|
|
|
class StdSliceProvider(printer_base):
|
|
def __init__(self, valobj):
|
|
self._valobj = valobj
|
|
self._length = int(valobj["length"])
|
|
self._data_ptr = valobj["data_ptr"]
|
|
|
|
def to_string(self):
|
|
return "{}(size={})".format(self._valobj.type, self._length)
|
|
|
|
def children(self):
|
|
return _enumerate_array_elements(
|
|
self._data_ptr + index for index in xrange(self._length)
|
|
)
|
|
|
|
@staticmethod
|
|
def display_hint():
|
|
return "array"
|
|
|
|
class StdVecProvider(printer_base):
|
|
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):
|
|
return _enumerate_array_elements(
|
|
self._data_ptr + index for index in xrange(self._length)
|
|
)
|
|
|
|
@staticmethod
|
|
def display_hint():
|
|
return "array"
|
|
|
|
|
|
class StdVecDequeProvider(printer_base):
|
|
def __init__(self, valobj):
|
|
self._valobj = valobj
|
|
self._head = int(valobj["head"])
|
|
self._size = int(valobj["len"])
|
|
# BACKCOMPAT: rust 1.75
|
|
cap = valobj["buf"]["cap"]
|
|
if cap.type.code != gdb.TYPE_CODE_INT:
|
|
cap = cap[ZERO_FIELD]
|
|
self._cap = int(cap)
|
|
self._data_ptr = unwrap_unique_or_non_null(valobj["buf"]["ptr"])
|
|
|
|
def to_string(self):
|
|
return "VecDeque(size={})".format(self._size)
|
|
|
|
def children(self):
|
|
return _enumerate_array_elements(
|
|
(self._data_ptr + ((self._head + index) % self._cap)) for index in xrange(self._size)
|
|
)
|
|
|
|
@staticmethod
|
|
def display_hint():
|
|
return "array"
|
|
|
|
|
|
class StdRcProvider(printer_base):
|
|
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(printer_base):
|
|
def __init__(self, valobj):
|
|
self._value = valobj["value"]["value"]
|
|
|
|
def to_string(self):
|
|
return "Cell"
|
|
|
|
def children(self):
|
|
yield "value", self._value
|
|
|
|
|
|
class StdRefProvider(printer_base):
|
|
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(printer_base):
|
|
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
|
|
|
|
|
|
class StdNonZeroNumberProvider(printer_base):
|
|
def __init__(self, valobj):
|
|
fields = valobj.type.fields()
|
|
assert len(fields) == 1
|
|
field = list(fields)[0]
|
|
|
|
inner_valobj = valobj[field.name]
|
|
|
|
inner_fields = inner_valobj.type.fields()
|
|
assert len(inner_fields) == 1
|
|
inner_field = list(inner_fields)[0]
|
|
|
|
self._value = str(inner_valobj[inner_field.name])
|
|
|
|
def to_string(self):
|
|
return self._value
|
|
|
|
|
|
# Yields children (in a provider's sense of the word) for a BTreeMap.
|
|
def children_of_btree_map(map):
|
|
# Yields each key/value pair in the node and in any child nodes.
|
|
def children_of_node(node_ptr, height):
|
|
def cast_to_internal(node):
|
|
internal_type_name = node.type.target().name.replace("LeafNode", "InternalNode", 1)
|
|
internal_type = gdb.lookup_type(internal_type_name)
|
|
return node.cast(internal_type.pointer())
|
|
|
|
if node_ptr.type.name.startswith("alloc::collections::btree::node::BoxedNode<"):
|
|
# BACKCOMPAT: rust 1.49
|
|
node_ptr = node_ptr["ptr"]
|
|
node_ptr = unwrap_unique_or_non_null(node_ptr)
|
|
leaf = node_ptr.dereference()
|
|
keys = leaf["keys"]
|
|
vals = leaf["vals"]
|
|
edges = cast_to_internal(node_ptr)["edges"] if height > 0 else None
|
|
length = leaf["len"]
|
|
|
|
for i in xrange(0, length + 1):
|
|
if height > 0:
|
|
child_ptr = edges[i]["value"]["value"]
|
|
for child in children_of_node(child_ptr, height - 1):
|
|
yield child
|
|
if i < length:
|
|
# Avoid "Cannot perform pointer math on incomplete type" on zero-sized arrays.
|
|
key_type_size = keys.type.sizeof
|
|
val_type_size = vals.type.sizeof
|
|
key = keys[i]["value"]["value"] if key_type_size > 0 else gdb.parse_and_eval("()")
|
|
val = vals[i]["value"]["value"] if val_type_size > 0 else gdb.parse_and_eval("()")
|
|
yield key, val
|
|
|
|
if map["length"] > 0:
|
|
root = map["root"]
|
|
if root.type.name.startswith("core::option::Option<"):
|
|
root = root.cast(gdb.lookup_type(root.type.name[21:-1]))
|
|
node_ptr = root["node"]
|
|
height = root["height"]
|
|
for child in children_of_node(node_ptr, height):
|
|
yield child
|
|
|
|
|
|
class StdBTreeSetProvider(printer_base):
|
|
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"]
|
|
for i, (child, _) in enumerate(children_of_btree_map(inner_map)):
|
|
yield "[{}]".format(i), child
|
|
|
|
@staticmethod
|
|
def display_hint():
|
|
return "array"
|
|
|
|
|
|
class StdBTreeMapProvider(printer_base):
|
|
def __init__(self, valobj):
|
|
self._valobj = valobj
|
|
|
|
def to_string(self):
|
|
return "BTreeMap(size={})".format(self._valobj["length"])
|
|
|
|
def children(self):
|
|
for i, (key, val) in enumerate(children_of_btree_map(self._valobj)):
|
|
yield "key{}".format(i), key
|
|
yield "val{}".format(i), val
|
|
|
|
@staticmethod
|
|
def display_hint():
|
|
return "map"
|
|
|
|
|
|
# BACKCOMPAT: rust 1.35
|
|
class StdOldHashMapProvider(printer_base):
|
|
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(printer_base):
|
|
def __init__(self, valobj, show_values=True):
|
|
self._valobj = valobj
|
|
self._show_values = show_values
|
|
|
|
table = self._table()
|
|
table_inner = table["table"]
|
|
capacity = int(table_inner["bucket_mask"]) + 1
|
|
ctrl = table_inner["ctrl"]["pointer"]
|
|
|
|
self._size = int(table_inner["items"])
|
|
self._pair_type = table.type.template_argument(0).strip_typedefs()
|
|
|
|
self._new_layout = not table_inner.type.has_key("data")
|
|
if self._new_layout:
|
|
self._data_ptr = ctrl.cast(self._pair_type.pointer())
|
|
else:
|
|
self._data_ptr = table_inner["data"]["pointer"]
|
|
|
|
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 _table(self):
|
|
if self._show_values:
|
|
hashbrown_hashmap = self._valobj["base"]
|
|
elif self._valobj.type.fields()[0].name == "map":
|
|
# BACKCOMPAT: rust 1.47
|
|
# HashSet wraps std::collections::HashMap, which wraps hashbrown::HashMap
|
|
hashbrown_hashmap = self._valobj["map"]["base"]
|
|
else:
|
|
# HashSet wraps hashbrown::HashSet, which wraps hashbrown::HashMap
|
|
hashbrown_hashmap = self._valobj["base"]["map"]
|
|
return hashbrown_hashmap["table"]
|
|
|
|
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]
|
|
if self._new_layout:
|
|
idx = -(idx + 1)
|
|
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"
|