mirror of
https://github.com/rust-lang/rust.git
synced 2026-04-26 13:01:27 +03:00
change RustType from string literals to enum
This commit is contained in:
Walnut
+21
-21
@@ -3,7 +3,7 @@ import gdb.printing
|
||||
import re
|
||||
|
||||
from gdb_providers import *
|
||||
from rust_types import *
|
||||
from rust_types import RustType, classify_struct, classify_union
|
||||
|
||||
|
||||
_gdb_version_matched = re.search("([0-9]+)\\.([0-9]+)", gdb.VERSION)
|
||||
@@ -28,7 +28,7 @@ def classify_rust_type(type):
|
||||
if type_class == gdb.TYPE_CODE_UNION:
|
||||
return classify_union(type.fields())
|
||||
|
||||
return RustType.OTHER
|
||||
return RustType.Other
|
||||
|
||||
|
||||
def check_enum_discriminant(valobj):
|
||||
@@ -85,7 +85,7 @@ class RustPrettyPrinter(gdb.printing.PrettyPrinter):
|
||||
|
||||
def add(self, rust_type, provider):
|
||||
# Just use the rust_type as the name.
|
||||
printer = PrintByRustType(rust_type, provider)
|
||||
printer = PrintByRustType(rust_type.name, provider)
|
||||
self.type_map[rust_type] = printer
|
||||
self.subprinters.append(printer)
|
||||
|
||||
@@ -99,23 +99,23 @@ class RustPrettyPrinter(gdb.printing.PrettyPrinter):
|
||||
printer = RustPrettyPrinter("rust")
|
||||
# use enum provider only for GDB <7.12
|
||||
if gdb_version[0] < 7 or (gdb_version[0] == 7 and gdb_version[1] < 12):
|
||||
printer.add(RustType.ENUM, enum_provider)
|
||||
printer.add(RustType.STD_STRING, StdStringProvider)
|
||||
printer.add(RustType.STD_OS_STRING, StdOsStringProvider)
|
||||
printer.add(RustType.STD_STR, StdStrProvider)
|
||||
printer.add(RustType.STD_SLICE, StdSliceProvider)
|
||||
printer.add(RustType.STD_VEC, StdVecProvider)
|
||||
printer.add(RustType.STD_VEC_DEQUE, StdVecDequeProvider)
|
||||
printer.add(RustType.STD_BTREE_SET, StdBTreeSetProvider)
|
||||
printer.add(RustType.STD_BTREE_MAP, StdBTreeMapProvider)
|
||||
printer.add(RustType.STD_HASH_MAP, hashmap_provider)
|
||||
printer.add(RustType.STD_HASH_SET, hashset_provider)
|
||||
printer.add(RustType.STD_RC, StdRcProvider)
|
||||
printer.add(RustType.STD_ARC, lambda valobj: StdRcProvider(valobj, is_atomic=True))
|
||||
printer.add(RustType.Enum, enum_provider)
|
||||
printer.add(RustType.StdString, StdStringProvider)
|
||||
printer.add(RustType.StdOsString, StdOsStringProvider)
|
||||
printer.add(RustType.StdStr, StdStrProvider)
|
||||
printer.add(RustType.StdSlice, StdSliceProvider)
|
||||
printer.add(RustType.StdVec, StdVecProvider)
|
||||
printer.add(RustType.StdVecDeque, StdVecDequeProvider)
|
||||
printer.add(RustType.StdBTreeSet, StdBTreeSetProvider)
|
||||
printer.add(RustType.StdBTreeMap, StdBTreeMapProvider)
|
||||
printer.add(RustType.StdHashMap, hashmap_provider)
|
||||
printer.add(RustType.StdHashSet, hashset_provider)
|
||||
printer.add(RustType.StdRc, StdRcProvider)
|
||||
printer.add(RustType.StdArc, lambda valobj: StdRcProvider(valobj, is_atomic=True))
|
||||
|
||||
printer.add(RustType.STD_CELL, StdCellProvider)
|
||||
printer.add(RustType.STD_REF, StdRefProvider)
|
||||
printer.add(RustType.STD_REF_MUT, StdRefProvider)
|
||||
printer.add(RustType.STD_REF_CELL, StdRefCellProvider)
|
||||
printer.add(RustType.StdCell, StdCellProvider)
|
||||
printer.add(RustType.StdRef, StdRefProvider)
|
||||
printer.add(RustType.StdRefMut, StdRefProvider)
|
||||
printer.add(RustType.StdRefCell, StdRefCellProvider)
|
||||
|
||||
printer.add(RustType.STD_NONZERO_NUMBER, StdNonZeroNumberProvider)
|
||||
printer.add(RustType.StdNonZeroNumber, StdNonZeroNumberProvider)
|
||||
|
||||
+43
-37
@@ -1,3 +1,6 @@
|
||||
from __future__ import annotations
|
||||
from typing import Dict
|
||||
|
||||
import lldb
|
||||
|
||||
from lldb_providers import *
|
||||
@@ -9,57 +12,60 @@ def is_hashbrown_hashmap(hash_map: lldb.SBValue) -> bool:
|
||||
return len(hash_map.type.fields) == 1
|
||||
|
||||
|
||||
def classify_rust_type(type: lldb.SBType) -> str:
|
||||
def classify_rust_type(type: lldb.SBType) -> RustType:
|
||||
if type.IsPointerType():
|
||||
type = type.GetPointeeType()
|
||||
|
||||
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
|
||||
return RustType.Other
|
||||
|
||||
|
||||
def summary_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> str:
|
||||
"""Returns the summary provider for the given value"""
|
||||
rust_type = classify_rust_type(valobj.GetType())
|
||||
|
||||
if rust_type == RustType.STD_STRING:
|
||||
if rust_type == RustType.StdString:
|
||||
return StdStringSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_OS_STRING:
|
||||
if rust_type == RustType.StdOsString:
|
||||
return StdOsStringSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_STR:
|
||||
if rust_type == RustType.StdStr:
|
||||
return StdStrSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_VEC:
|
||||
if rust_type == RustType.StdVec:
|
||||
return SizeSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_VEC_DEQUE:
|
||||
if rust_type == RustType.StdVecDeque:
|
||||
return SizeSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_SLICE:
|
||||
if rust_type == RustType.StdSlice:
|
||||
return SizeSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_HASH_MAP:
|
||||
if rust_type == RustType.StdHashMap:
|
||||
return SizeSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_HASH_SET:
|
||||
if rust_type == RustType.StdHashSet:
|
||||
return SizeSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_RC:
|
||||
if rust_type == RustType.StdRc:
|
||||
return StdRcSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_ARC:
|
||||
if rust_type == RustType.StdArc:
|
||||
return StdRcSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_REF:
|
||||
if rust_type == RustType.StdRef:
|
||||
return StdRefSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_REF_MUT:
|
||||
if rust_type == RustType.StdRefMut:
|
||||
return StdRefSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_REF_CELL:
|
||||
if rust_type == RustType.StdRefCell:
|
||||
return StdRefSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_NONZERO_NUMBER:
|
||||
if rust_type == RustType.StdNonZeroNumber:
|
||||
return StdNonZeroNumberSummaryProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_PATHBUF:
|
||||
if rust_type == RustType.StdPathBuf:
|
||||
return StdPathBufSummaryProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_PATH:
|
||||
if rust_type == RustType.StdPath:
|
||||
return StdPathSummaryProvider(valobj, _dict)
|
||||
|
||||
return ""
|
||||
@@ -69,22 +75,22 @@ def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
|
||||
"""Returns the synthetic provider for the given value"""
|
||||
rust_type = classify_rust_type(valobj.GetType())
|
||||
|
||||
if rust_type == RustType.STRUCT:
|
||||
if rust_type == RustType.Struct:
|
||||
return StructSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STRUCT_VARIANT:
|
||||
if rust_type == RustType.StructVariant:
|
||||
return StructSyntheticProvider(valobj, _dict, is_variant=True)
|
||||
if rust_type == RustType.TUPLE:
|
||||
if rust_type == RustType.Tuple:
|
||||
return TupleSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.TUPLE_VARIANT:
|
||||
if rust_type == RustType.TupleVariant:
|
||||
return TupleSyntheticProvider(valobj, _dict, is_variant=True)
|
||||
if rust_type == RustType.EMPTY:
|
||||
if rust_type == RustType.Empty:
|
||||
return EmptySyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.REGULAR_ENUM:
|
||||
if rust_type == RustType.RegularEnum:
|
||||
discriminant = valobj.GetChildAtIndex(0).GetChildAtIndex(0).GetValueAsUnsigned()
|
||||
return synthetic_lookup(valobj.GetChildAtIndex(discriminant), _dict)
|
||||
if rust_type == RustType.SINGLETON_ENUM:
|
||||
if rust_type == RustType.SingletonEnum:
|
||||
return synthetic_lookup(valobj.GetChildAtIndex(0), _dict)
|
||||
if rust_type == RustType.ENUM:
|
||||
if rust_type == RustType.Enum:
|
||||
# this little trick lets us treat `synthetic_lookup` as a "recognizer function" for the enum
|
||||
# summary providers, reducing the number of lookups we have to do. This is a huge time save
|
||||
# because there's no way (via type name) to recognize sum-type enums on `*-gnu` targets. The
|
||||
@@ -106,37 +112,37 @@ def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
|
||||
)
|
||||
|
||||
return ClangEncodedEnumProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_VEC:
|
||||
if rust_type == RustType.StdVec:
|
||||
return StdVecSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_VEC_DEQUE:
|
||||
if rust_type == RustType.StdVecDeque:
|
||||
return StdVecDequeSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_SLICE or rust_type == RustType.STD_STR:
|
||||
if rust_type == RustType.StdSlice or rust_type == RustType.StdStr:
|
||||
return StdSliceSyntheticProvider(valobj, _dict)
|
||||
|
||||
if rust_type == RustType.STD_HASH_MAP:
|
||||
if rust_type == RustType.StdHashMap:
|
||||
if is_hashbrown_hashmap(valobj):
|
||||
return StdHashMapSyntheticProvider(valobj, _dict)
|
||||
else:
|
||||
return StdOldHashMapSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_HASH_SET:
|
||||
if rust_type == RustType.StdHashSet:
|
||||
hash_map = valobj.GetChildAtIndex(0)
|
||||
if is_hashbrown_hashmap(hash_map):
|
||||
return StdHashMapSyntheticProvider(valobj, _dict, show_values=False)
|
||||
else:
|
||||
return StdOldHashMapSyntheticProvider(hash_map, _dict, show_values=False)
|
||||
|
||||
if rust_type == RustType.STD_RC:
|
||||
if rust_type == RustType.StdRc:
|
||||
return StdRcSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_ARC:
|
||||
if rust_type == RustType.StdArc:
|
||||
return StdRcSyntheticProvider(valobj, _dict, is_atomic=True)
|
||||
|
||||
if rust_type == RustType.STD_CELL:
|
||||
if rust_type == RustType.StdCell:
|
||||
return StdCellSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_REF:
|
||||
if rust_type == RustType.StdRef:
|
||||
return StdRefSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_REF_MUT:
|
||||
if rust_type == RustType.StdRefMut:
|
||||
return StdRefSyntheticProvider(valobj, _dict)
|
||||
if rust_type == RustType.STD_REF_CELL:
|
||||
if rust_type == RustType.StdRefCell:
|
||||
return StdRefSyntheticProvider(valobj, _dict, is_cell=True)
|
||||
|
||||
return DefaultSyntheticProvider(valobj, _dict)
|
||||
|
||||
@@ -256,7 +256,7 @@ def vec_to_string(vec: SBValue) -> str:
|
||||
)
|
||||
|
||||
|
||||
def StdStringSummaryProvider(valobj, dict):
|
||||
def StdStringSummaryProvider(valobj: SBValue, dict: LLDBOpaque):
|
||||
inner_vec = (
|
||||
valobj.GetNonSyntheticValue()
|
||||
.GetChildMemberWithName("vec")
|
||||
|
||||
+63
-62
@@ -1,40 +1,41 @@
|
||||
from enum import Enum
|
||||
from typing import List
|
||||
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"
|
||||
class RustType(Enum):
|
||||
Other = 0
|
||||
Struct = 1
|
||||
Tuple = 2
|
||||
CStyleVariant = 3
|
||||
TupleVariant = 4
|
||||
StructVariant = 5
|
||||
Enum = 6
|
||||
Empty = 7
|
||||
SingletonEnum = 8
|
||||
RegularEnum = 9
|
||||
CompressedEnum = 10
|
||||
RegularUnion = 11
|
||||
|
||||
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_NONZERO_NUMBER = "StdNonZeroNumber"
|
||||
STD_PATH = "StdPath"
|
||||
STD_PATHBUF = "StdPathBuf"
|
||||
StdString = 12
|
||||
StdOsString = 13
|
||||
StdStr = 14
|
||||
StdSlice = 15
|
||||
StdVec = 16
|
||||
StdVecDeque = 17
|
||||
StdBTreeSet = 18
|
||||
StdBTreeMap = 19
|
||||
StdHashMap = 20
|
||||
StdHashSet = 21
|
||||
StdRc = 22
|
||||
StdArc = 23
|
||||
StdCell = 24
|
||||
StdRef = 25
|
||||
StdRefMut = 26
|
||||
StdRefCell = 27
|
||||
StdNonZeroNumber = 28
|
||||
StdPath = 29
|
||||
StdPathBuf = 30
|
||||
|
||||
|
||||
STD_STRING_REGEX = re.compile(r"^(alloc::([a-z_]+::)+)String$")
|
||||
@@ -64,25 +65,25 @@ ENUM_DISR_FIELD_NAME = "<<variant>>"
|
||||
ENUM_LLDB_ENCODED_VARIANTS = "$variants$"
|
||||
|
||||
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,
|
||||
RustType.STD_NONZERO_NUMBER: STD_NONZERO_NUMBER_REGEX,
|
||||
RustType.STD_PATHBUF: STD_PATHBUF_REGEX,
|
||||
RustType.STD_PATH: STD_PATH_REGEX,
|
||||
RustType.StdString: STD_STRING_REGEX,
|
||||
RustType.StdOsString: STD_OS_STRING_REGEX,
|
||||
RustType.StdStr: STD_STR_REGEX,
|
||||
RustType.StdSlice: STD_SLICE_REGEX,
|
||||
RustType.StdVec: STD_VEC_REGEX,
|
||||
RustType.StdVecDeque: STD_VEC_DEQUE_REGEX,
|
||||
RustType.StdHashMap: STD_HASH_MAP_REGEX,
|
||||
RustType.StdHashSet: STD_HASH_SET_REGEX,
|
||||
RustType.StdBTreeSet: STD_BTREE_SET_REGEX,
|
||||
RustType.StdBTreeMap: STD_BTREE_MAP_REGEX,
|
||||
RustType.StdRc: STD_RC_REGEX,
|
||||
RustType.StdArc: STD_ARC_REGEX,
|
||||
RustType.StdRef: STD_REF_REGEX,
|
||||
RustType.StdRefMut: STD_REF_MUT_REGEX,
|
||||
RustType.StdRefCell: STD_REF_CELL_REGEX,
|
||||
RustType.StdCell: STD_CELL_REGEX,
|
||||
RustType.StdNonZeroNumber: STD_NONZERO_NUMBER_REGEX,
|
||||
RustType.StdPath: STD_PATH_REGEX,
|
||||
RustType.StdPathBuf: STD_PATHBUF_REGEX,
|
||||
}
|
||||
|
||||
|
||||
@@ -90,9 +91,9 @@ def is_tuple_fields(fields: List) -> bool:
|
||||
return all(TUPLE_ITEM_REGEX.match(str(field.name)) for field in fields)
|
||||
|
||||
|
||||
def classify_struct(name: str, fields: List) -> str:
|
||||
def classify_struct(name: str, fields: List) -> RustType:
|
||||
if len(fields) == 0:
|
||||
return RustType.EMPTY
|
||||
return RustType.Empty
|
||||
|
||||
for ty, regex in STD_TYPE_TO_REGEX.items():
|
||||
if regex.match(name):
|
||||
@@ -103,26 +104,26 @@ def classify_struct(name: str, fields: List) -> str:
|
||||
fields[0].name == ENUM_DISR_FIELD_NAME
|
||||
or fields[0].name == ENUM_LLDB_ENCODED_VARIANTS
|
||||
):
|
||||
return RustType.ENUM
|
||||
return RustType.Enum
|
||||
|
||||
if is_tuple_fields(fields):
|
||||
return RustType.TUPLE
|
||||
return RustType.Tuple
|
||||
|
||||
return RustType.STRUCT
|
||||
return RustType.Struct
|
||||
|
||||
|
||||
def classify_union(fields: List) -> str:
|
||||
def classify_union(fields: List) -> RustType:
|
||||
if len(fields) == 0:
|
||||
return RustType.EMPTY
|
||||
return RustType.Empty
|
||||
|
||||
first_variant_name = fields[0].name
|
||||
if first_variant_name is None:
|
||||
if len(fields) == 1:
|
||||
return RustType.SINGLETON_ENUM
|
||||
return RustType.SingletonEnum
|
||||
else:
|
||||
return RustType.REGULAR_ENUM
|
||||
return RustType.RegularEnum
|
||||
elif first_variant_name.startswith(ENCODED_ENUM_PREFIX):
|
||||
assert len(fields) == 1
|
||||
return RustType.COMPRESSED_ENUM
|
||||
return RustType.CompressedEnum
|
||||
else:
|
||||
return RustType.REGULAR_UNION
|
||||
return RustType.RegularEnum
|
||||
|
||||
Reference in New Issue
Block a user