9c6054d29d
In #188242, we replaced `PointerUnion`'s `PointerIntPair` storage with `PunnedPointer<void*>`. The old formatters relied on the PIP synthetic provider (LLDB) / `get_pointer_int_pair helper` (GDB) which no longer work. Instead, read raw bytes from `PunnedPointer` and compute the active tag from template argument type alignments -- the same fixed-width encoding the C++ implementation uses. When template arg enumeration is truncated (e.g., function-local types in GDB), the formatters fall back to showing a tag-stripped `void*` instead of silently misdecoding. Alternatives that didn't work out: - Adding a C++ helper (`getActiveMemberIdx`) callable from Python: gets optimized out even with `__attribute__((used, noinline))`, and expression evaluation fails for synthetic children. - Using `isa`/`dyn_cast` checks from Python: requires expression evaluation, which does not work for local types or synthetic children without a frame context. Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
618 lines
20 KiB
Python
618 lines
20 KiB
Python
"""
|
|
LLDB Formatters for LLVM data types.
|
|
|
|
Load into LLDB with 'command script import /path/to/lldbDataFormatters.py'
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import collections
|
|
from typing import Literal, Optional
|
|
import lldb
|
|
|
|
|
|
def __lldb_init_module(debugger: lldb.SBDebugger, internal_dict) -> None:
|
|
debugger.HandleCommand("type category define -e llvm -l c++")
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.SmallVectorSynthProvider "
|
|
'-x "^llvm::SmallVectorImpl<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
'-e -s "size=${svar%#}" '
|
|
'-x "^llvm::SmallVectorImpl<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.SmallVectorSynthProvider "
|
|
'-x "^llvm::SmallVector<.+,.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
'-e -s "size=${svar%#}" '
|
|
'-x "^llvm::SmallVector<.+,.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.ArrayRefSynthProvider "
|
|
'-x "^llvm::ArrayRef<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
'-e -s "size=${svar%#}" '
|
|
'-x "^llvm::ArrayRef<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
f"-F {__name__}.SmallStringSummaryProvider "
|
|
'-x "^llvm::SmallString<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
f"-F {__name__}.StringRefSummaryProvider "
|
|
"llvm::StringRef"
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
f"-F {__name__}.ConstStringSummaryProvider "
|
|
"lldb_private::ConstString"
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.PointerIntPairSynthProvider "
|
|
'-x "^llvm::PointerIntPair<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.PointerUnionSynthProvider "
|
|
'-x "^llvm::PointerUnion<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
f"-e -F {__name__}.DenseMapSummary "
|
|
'-x "^llvm::DenseMap<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.DenseMapSynthetic "
|
|
'-x "^llvm::DenseMap<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.DenseSetSynthetic "
|
|
'-x "^llvm::DenseSet<.+>$"'
|
|
)
|
|
|
|
debugger.HandleCommand(
|
|
"type synthetic add -w llvm "
|
|
f"-l {__name__}.ExpectedSynthetic "
|
|
'-x "^llvm::Expected<.+>$"'
|
|
)
|
|
debugger.HandleCommand(
|
|
"type summary add -w llvm "
|
|
f"-F {__name__}.SmallBitVectorSummary "
|
|
"llvm::SmallBitVector"
|
|
)
|
|
|
|
|
|
# Pretty printer for llvm::SmallVector/llvm::SmallVectorImpl
|
|
class SmallVectorSynthProvider:
|
|
valobj: lldb.SBValue
|
|
begin: lldb.SBValue
|
|
size: lldb.SBValue
|
|
data_type: lldb.SBType
|
|
type_size: int
|
|
|
|
def __init__(self, valobj, internal_dict) -> None:
|
|
self.valobj = valobj
|
|
self.update() # initialize this provider
|
|
|
|
def num_children(self) -> int:
|
|
return self.size.GetValueAsUnsigned(0)
|
|
|
|
def get_child_index(self, name):
|
|
try:
|
|
return int(name.lstrip("[").rstrip("]"))
|
|
except:
|
|
return -1
|
|
|
|
def get_child_at_index(self, index) -> Optional[lldb.SBValue]:
|
|
# Do bounds checking.
|
|
if index < 0:
|
|
return None
|
|
if index >= self.num_children():
|
|
return None
|
|
|
|
offset = index * self.type_size
|
|
return self.begin.CreateChildAtOffset(
|
|
"[" + str(index) + "]", offset, self.data_type
|
|
)
|
|
|
|
def update(self):
|
|
self.begin = self.valobj.GetChildMemberWithName("BeginX")
|
|
self.size = self.valobj.GetChildMemberWithName("Size")
|
|
the_type = self.valobj.GetType()
|
|
# If this is a reference type we have to dereference it to get to the
|
|
# template parameter.
|
|
if the_type.IsReferenceType():
|
|
the_type = the_type.GetDereferencedType()
|
|
|
|
if the_type.IsPointerType():
|
|
the_type = the_type.GetPointeeType()
|
|
|
|
self.data_type = the_type.GetTemplateArgumentType(0)
|
|
self.type_size = self.data_type.GetByteSize()
|
|
assert self.type_size != 0
|
|
|
|
|
|
class ArrayRefSynthProvider:
|
|
"""Provider for llvm::ArrayRef"""
|
|
|
|
valobj: lldb.SBValue
|
|
data: lldb.SBValue
|
|
length: int
|
|
data_type: lldb.SBType
|
|
type_size: int
|
|
|
|
def __init__(self, valobj: lldb.SBValue, internal_dict) -> None:
|
|
self.valobj = valobj
|
|
self.update() # initialize this provider
|
|
|
|
def num_children(self) -> int:
|
|
return self.length
|
|
|
|
def get_child_index(self, name):
|
|
try:
|
|
return int(name.lstrip("[").rstrip("]"))
|
|
except:
|
|
return -1
|
|
|
|
def get_child_at_index(self, index) -> Optional[lldb.SBValue]:
|
|
if index < 0 or index >= self.num_children():
|
|
return None
|
|
offset = index * self.type_size
|
|
return self.data.CreateChildAtOffset(
|
|
"[" + str(index) + "]", offset, self.data_type
|
|
)
|
|
|
|
def update(self):
|
|
self.data = self.valobj.GetChildMemberWithName("Data")
|
|
length_obj = self.valobj.GetChildMemberWithName("Length")
|
|
self.length = length_obj.GetValueAsUnsigned(0)
|
|
self.data_type = self.data.GetType().GetPointeeType()
|
|
self.type_size = self.data_type.GetByteSize()
|
|
assert self.type_size != 0
|
|
|
|
|
|
def SmallStringSummaryProvider(valobj: lldb.SBValue, internal_dict) -> str:
|
|
# The underlying SmallVector base class is the first child.
|
|
vector = valobj.GetChildAtIndex(0)
|
|
num_elements = vector.GetNumChildren()
|
|
res = '"'
|
|
for i in range(num_elements):
|
|
c = vector.GetChildAtIndex(i)
|
|
if c:
|
|
res += chr(c.GetValueAsUnsigned())
|
|
res += '"'
|
|
return res
|
|
|
|
|
|
def StringRefSummaryProvider(valobj: lldb.SBValue, internal_dict) -> str:
|
|
data_pointer = valobj.GetChildMemberWithName("Data")
|
|
length = valobj.GetChildMemberWithName("Length").unsigned
|
|
if data_pointer.unsigned == 0 or length == 0:
|
|
return '""'
|
|
|
|
data = data_pointer.deref
|
|
# StringRef may be uninitialized with length exceeding available memory,
|
|
# potentially causing bad_alloc exceptions. Limit the length to max string summary setting.
|
|
limit_obj = valobj.target.debugger.GetSetting("target.max-string-summary-length")
|
|
if limit_obj:
|
|
length = min(length, limit_obj.GetUnsignedIntegerValue())
|
|
# Get a char[N] type, from the underlying char type.
|
|
array_type = data.type.GetArrayType(length)
|
|
# Cast the char* string data to a char[N] array.
|
|
char_array = data.Cast(array_type)
|
|
# Use the builtin summary for its support of max-string-summary-length and
|
|
# display of non-printable bytes.
|
|
return char_array.summary
|
|
|
|
|
|
def ConstStringSummaryProvider(valobj: lldb.SBValue, internal_dict) -> str:
|
|
if valobj.GetNumChildren() == 1:
|
|
return valobj.GetChildAtIndex(0).GetSummary()
|
|
return ""
|
|
|
|
|
|
class PointerIntPairSynthProvider:
|
|
valobj: lldb.SBValue
|
|
byteorder: Literal["big", "little"]
|
|
ptr_size: int
|
|
value: lldb.SBValue
|
|
pointer_valobj: Optional[lldb.SBValue]
|
|
int_valobj: Optional[lldb.SBValue]
|
|
|
|
def __init__(self, valobj: lldb.SBValue, internal_dict) -> None:
|
|
self.valobj = valobj
|
|
self.update()
|
|
|
|
def num_children(self) -> int:
|
|
return 2
|
|
|
|
def get_child_index(self, name: str) -> int:
|
|
if name == "Pointer":
|
|
return 0
|
|
if name == "Int":
|
|
return 1
|
|
return -1
|
|
|
|
def _get_raw_value(self) -> Optional[bytes]:
|
|
data: lldb.SBData = self.value.GetData()
|
|
error = lldb.SBError()
|
|
raw_bytes = data.ReadRawData(error, 0, self.ptr_size)
|
|
if error.Fail():
|
|
return None
|
|
|
|
return raw_bytes
|
|
|
|
def _get_pointer(
|
|
self, pointer_bit_mask: int, pointer_ty: lldb.SBType
|
|
) -> Optional[lldb.SBValue]:
|
|
raw_bytes = self._get_raw_value()
|
|
if raw_bytes is None:
|
|
return
|
|
|
|
unmasked_pointer = int.from_bytes(raw_bytes, self.byteorder)
|
|
pointer_value = unmasked_pointer & pointer_bit_mask
|
|
|
|
data = lldb.SBData()
|
|
data.SetDataFromUInt64Array([pointer_value])
|
|
return self.valobj.CreateValueFromData("Pointer", data, pointer_ty)
|
|
|
|
def _get_int(
|
|
self, int_shift: int, int_mask: int, int_ty: lldb.SBType
|
|
) -> Optional[lldb.SBValue]:
|
|
raw_bytes = self._get_raw_value()
|
|
if raw_bytes is None:
|
|
return
|
|
|
|
unmasked_pointer = int.from_bytes(raw_bytes, self.byteorder)
|
|
int_value = (unmasked_pointer >> int_shift) & int_mask
|
|
|
|
data = lldb.SBData()
|
|
data.SetDataFromUInt64Array([int_value])
|
|
return self.valobj.CreateValueFromData("Int", data, int_ty)
|
|
|
|
def get_child_at_index(self, index) -> Optional[lldb.SBValue]:
|
|
if index == 0:
|
|
return self.pointer_valobj
|
|
if index == 1:
|
|
return self.int_valobj
|
|
return None
|
|
|
|
def update(self):
|
|
self.byteorder = (
|
|
"big"
|
|
if self.valobj.target.GetByteOrder() == lldb.eByteOrderBig
|
|
else "little"
|
|
)
|
|
self.ptr_size = self.valobj.target.GetAddressByteSize()
|
|
self.value: lldb.SBValue = self.valobj.GetChildMemberWithName("Value")
|
|
if not self.value:
|
|
return
|
|
|
|
valobj_type = self.valobj.GetType()
|
|
|
|
pointer_ty: lldb.SBType = valobj_type.GetTemplateArgumentType(0)
|
|
if not pointer_ty:
|
|
return
|
|
|
|
int_ty: lldb.SBType = valobj_type.GetTemplateArgumentType(2)
|
|
if not int_ty:
|
|
return
|
|
|
|
pointer_info = valobj_type.GetTemplateArgumentType(4)
|
|
if not pointer_info:
|
|
return
|
|
|
|
mask_and_shift_constants = pointer_info.FindDirectNestedType(
|
|
"MaskAndShiftConstants"
|
|
).GetEnumMembers()
|
|
|
|
# FIXME: SBAPI should provide a way to retrieve an enum member
|
|
# by name.
|
|
pointer_bit_mask: lldb.SBTypeEnumMember = (
|
|
mask_and_shift_constants.GetTypeEnumMemberAtIndex(0)
|
|
)
|
|
if pointer_bit_mask.name != "PointerBitMask":
|
|
return
|
|
|
|
int_shift: lldb.SBTypeEnumMember = (
|
|
mask_and_shift_constants.GetTypeEnumMemberAtIndex(1)
|
|
)
|
|
if int_shift.name != "IntShift":
|
|
return
|
|
|
|
int_mask: lldb.SBTypeEnumMember = (
|
|
mask_and_shift_constants.GetTypeEnumMemberAtIndex(2)
|
|
)
|
|
if int_mask.name != "IntMask":
|
|
return
|
|
|
|
self.pointer_valobj = self._get_pointer(
|
|
pointer_bit_mask.GetValueAsUnsigned(), pointer_ty
|
|
)
|
|
self.int_valobj = self._get_int(
|
|
int_shift.GetValueAsUnsigned(), int_mask.GetValueAsUnsigned(), int_ty
|
|
)
|
|
|
|
|
|
class PointerUnionSynthProvider:
|
|
valobj: lldb.SBValue
|
|
pointer_valobj: lldb.SBValue
|
|
|
|
def __init__(self, valobj: lldb.SBValue, internal_dict) -> None:
|
|
self.valobj = valobj
|
|
self.update()
|
|
|
|
def num_children(self) -> int:
|
|
return 1
|
|
|
|
def get_child_index(self, name: str) -> int:
|
|
if name == "Pointer":
|
|
return 0
|
|
return -1
|
|
|
|
def get_child_at_index(self, index: int) -> Optional[lldb.SBValue]:
|
|
if index != 0:
|
|
return None
|
|
|
|
return self.pointer_valobj
|
|
|
|
@staticmethod
|
|
def _get_low_bits_for_type(ty: lldb.SBType) -> int:
|
|
"""Return NumLowBitsAvailable for a pointer type (from pointee byte alignment)."""
|
|
pointee = ty.GetPointeeType()
|
|
if pointee.IsValid():
|
|
align = pointee.GetByteAlign()
|
|
return align.bit_length() - 1 if align > 0 else 0
|
|
return 0
|
|
|
|
def _make_pointer_value(self, name, pointer, ty):
|
|
"""Create an SBValue for a pointer, using proper byte order and address size."""
|
|
data = lldb.SBData.CreateDataFromUInt64Array(
|
|
self.valobj.target.GetByteOrder(),
|
|
self.valobj.process.GetAddressByteSize(),
|
|
[pointer],
|
|
)
|
|
return self.valobj.CreateValueFromData(name, data, ty)
|
|
|
|
def update(self):
|
|
self.pointer_valobj = None
|
|
|
|
valobj_type = self.valobj.GetType()
|
|
num_args = valobj_type.GetNumberOfTemplateArguments()
|
|
if num_args == 0:
|
|
return
|
|
|
|
# Read the raw uintptr_t from PunnedPointer<void*>.
|
|
val: lldb.SBValue = self.valobj.GetChildMemberWithName("Val")
|
|
if not val:
|
|
return
|
|
byteorder = (
|
|
"big"
|
|
if self.valobj.target.GetByteOrder() == lldb.eByteOrderBig
|
|
else "little"
|
|
)
|
|
raw_bytes = val.GetData().uint8s
|
|
if not raw_bytes:
|
|
return
|
|
raw_value = int.from_bytes(raw_bytes, byteorder)
|
|
|
|
# Compute tag from type alignments (fixed-width encoding).
|
|
tag_bits = (num_args - 1).bit_length()
|
|
min_low_bits = min(
|
|
self._get_low_bits_for_type(valobj_type.GetTemplateArgumentType(i))
|
|
for i in range(num_args)
|
|
)
|
|
if tag_bits > min_low_bits:
|
|
return self._set_raw_pointer(raw_value, min_low_bits)
|
|
tag_shift = min_low_bits - tag_bits
|
|
tag_mask = (1 << tag_bits) - 1
|
|
active_tag = (raw_value >> tag_shift) & tag_mask
|
|
|
|
if active_tag >= num_args:
|
|
return self._set_raw_pointer(raw_value, min_low_bits)
|
|
|
|
active_type: lldb.SBType = valobj_type.GetTemplateArgumentType(active_tag)
|
|
if not active_type:
|
|
return self._set_raw_pointer(raw_value, min_low_bits)
|
|
|
|
# Clear the active type's low bits to recover the pointer.
|
|
low_bits = self._get_low_bits_for_type(active_type)
|
|
pointer = raw_value & ~((1 << low_bits) - 1)
|
|
|
|
self.pointer_valobj = self._make_pointer_value("Pointer", pointer, active_type)
|
|
|
|
def _set_raw_pointer(self, raw_value, min_low_bits):
|
|
"""Fallback: strip tag bits and show as void* when active type is unknown."""
|
|
pointer = raw_value & ~((1 << min_low_bits) - 1)
|
|
void_ptr_ty = self.valobj.target.FindFirstType("void").GetPointerType()
|
|
if void_ptr_ty.IsValid():
|
|
self.pointer_valobj = self._make_pointer_value(
|
|
"Pointer", pointer, void_ptr_ty
|
|
)
|
|
|
|
|
|
def DenseMapSummary(valobj: lldb.SBValue, _) -> str:
|
|
raw_value = valobj.GetNonSyntheticValue()
|
|
num_entries = raw_value.GetChildMemberWithName("NumEntries").unsigned
|
|
num_tombstones = raw_value.GetChildMemberWithName("NumTombstones").unsigned
|
|
|
|
summary = f"size={num_entries}"
|
|
if num_tombstones == 1:
|
|
# The heuristic to identify valid entries does not handle the case of a
|
|
# single tombstone. The summary calls attention to this.
|
|
summary = f"tombstones=1, {summary}"
|
|
return summary
|
|
|
|
|
|
class DenseMapSynthetic:
|
|
valobj: lldb.SBValue
|
|
|
|
# The indexes into `Buckets` that contain valid map entries.
|
|
child_buckets: list[int]
|
|
|
|
def __init__(self, valobj: lldb.SBValue, _) -> None:
|
|
self.valobj = valobj
|
|
|
|
def num_children(self) -> int:
|
|
return len(self.child_buckets)
|
|
|
|
def get_child_at_index(self, child_index: int) -> lldb.SBValue:
|
|
bucket_index = self.child_buckets[child_index]
|
|
entry = self.valobj.GetValueForExpressionPath(f".Buckets[{bucket_index}]")
|
|
|
|
# By default, DenseMap instances use DenseMapPair to hold key-value
|
|
# entries. When the entry is a DenseMapPair, unwrap it to expose the
|
|
# children as simple std::pair values.
|
|
#
|
|
# This entry type is customizable (a template parameter). For other
|
|
# types, expose the entry type as is.
|
|
if entry.type.name.startswith("llvm::detail::DenseMapPair<"):
|
|
entry = entry.GetChildAtIndex(0)
|
|
|
|
return entry.Clone(f"[{child_index}]")
|
|
|
|
def update(self):
|
|
self.child_buckets = []
|
|
|
|
num_entries = self.valobj.GetChildMemberWithName("NumEntries").unsigned
|
|
if num_entries == 0:
|
|
return
|
|
|
|
buckets = self.valobj.GetChildMemberWithName("Buckets")
|
|
num_buckets = self.valobj.GetChildMemberWithName("NumBuckets").unsigned
|
|
|
|
# Bucket entries contain one of the following:
|
|
# 1. Valid key-value
|
|
# 2. Empty key
|
|
# 3. Tombstone key (a deleted entry)
|
|
#
|
|
# NumBuckets is always greater than NumEntries. The empty key, and
|
|
# potentially the tombstone key, will occur multiple times. A key that
|
|
# is repeated is either the empty key or the tombstone key.
|
|
|
|
# For each key, collect a list of buckets it appears in.
|
|
key_buckets: dict[str, list[int]] = collections.defaultdict(list)
|
|
for index in range(num_buckets):
|
|
bucket = buckets.GetValueForExpressionPath(f"[{index}]")
|
|
key = bucket.GetChildAtIndex(0)
|
|
key_buckets[str(key.data)].append(index)
|
|
|
|
# Heuristic: This is not a multi-map, any repeated (non-unique) keys are
|
|
# either the the empty key or the tombstone key. Populate child_buckets
|
|
# with the indexes of entries containing unique keys.
|
|
for indexes in key_buckets.values():
|
|
if len(indexes) == 1:
|
|
self.child_buckets.append(indexes[0])
|
|
|
|
|
|
class DenseSetSynthetic:
|
|
valobj: lldb.SBValue
|
|
map: lldb.SBValue
|
|
|
|
def __init__(self, valobj: lldb.SBValue, _) -> None:
|
|
self.valobj = valobj
|
|
|
|
def num_children(self) -> int:
|
|
return self.map.num_children
|
|
|
|
def get_child_at_index(self, idx: int) -> lldb.SBValue:
|
|
map_entry = self.map.child[idx]
|
|
set_entry = map_entry.GetChildAtIndex(0)
|
|
return set_entry.Clone(f"[{idx}]")
|
|
|
|
def update(self):
|
|
raw_map = self.valobj.GetChildMemberWithName("TheMap")
|
|
self.map = raw_map.GetSyntheticValue()
|
|
|
|
|
|
class ExpectedSynthetic:
|
|
# The llvm::Expected<T> value.
|
|
expected: lldb.SBValue
|
|
# The stored success value or error value.
|
|
stored_value: lldb.SBValue
|
|
|
|
def __init__(self, valobj: lldb.SBValue, _) -> None:
|
|
self.expected = valobj
|
|
|
|
def update(self) -> None:
|
|
has_error = self.expected.GetChildMemberWithName("HasError").unsigned
|
|
if not has_error:
|
|
name = "value"
|
|
member = "TStorage"
|
|
else:
|
|
name = "error"
|
|
member = "ErrorStorage"
|
|
# Anonymous union.
|
|
union = self.expected.child[0]
|
|
storage = union.GetChildMemberWithName(member)
|
|
# For reference types, storage is std::reference_wrapper<T>, so we
|
|
# unwrap to get T. For non-reference types, storage is T directly.
|
|
# Use GetCanonicalType() to resolve the typedef to the underlying type.
|
|
canonical_type_name = storage.type.GetCanonicalType().name
|
|
if "reference_wrapper<" in canonical_type_name:
|
|
# reference_wrapper<T> stores a T* pointer to the referenced value.
|
|
# Get the first child (the pointer member) and dereference it.
|
|
ptr_member = storage.GetChildAtIndex(0)
|
|
if ptr_member and ptr_member.IsValid() and ptr_member.type.IsPointerType():
|
|
self.stored_value = ptr_member.Dereference().Clone(name)
|
|
else:
|
|
# Fallback: just use storage as-is.
|
|
self.stored_value = storage.Clone(name)
|
|
else:
|
|
self.stored_value = storage.Clone(name)
|
|
|
|
def num_children(self) -> int:
|
|
return 1
|
|
|
|
def get_child_index(self, name: str) -> int:
|
|
if name == self.stored_value.name:
|
|
return 0
|
|
# Allow dereferencing for values, not errors.
|
|
if name == "$$dereference$$" and self.stored_value.name == "value":
|
|
return 0
|
|
return -1
|
|
|
|
def get_child_at_index(self, idx: int) -> lldb.SBValue:
|
|
if idx == 0:
|
|
return self.stored_value
|
|
return lldb.SBValue()
|
|
|
|
|
|
def SmallBitVectorSummary(valobj, _) -> str:
|
|
underlyingValue = valobj.GetChildMemberWithName("X").unsigned
|
|
numBaseBits = valobj.target.addr_size * 8
|
|
smallNumRawBits = numBaseBits - 1
|
|
smallNumSizeBits = None
|
|
if numBaseBits == 32:
|
|
smallNumSizeBits = 5
|
|
elif numBaseBits == 64:
|
|
smallNumSizeBits = 6
|
|
else:
|
|
smallNumSizeBits = smallNumRawBits
|
|
smallNumDataBits = smallNumRawBits - smallNumSizeBits
|
|
|
|
# If our underlying value is not small, print we can not dump large values.
|
|
isSmallMask = 1
|
|
if underlyingValue & isSmallMask == 0:
|
|
return "<can not read large SmallBitVector>"
|
|
|
|
smallRawBits = underlyingValue >> 1
|
|
smallSize = smallRawBits >> smallNumDataBits
|
|
bits = smallRawBits & ((1 << (smallSize + 1)) - 1)
|
|
# format `bits` in binary (b), with 0 padding, of width `smallSize`, and left aligned (>)
|
|
return f"[{bits:0>{smallSize}b}]"
|