mirror of
https://github.com/bytecodealliance/wasm-micro-runtime.git
synced 2025-05-07 04:06:16 +00:00
747 lines
26 KiB
Python
747 lines
26 KiB
Python
'''
|
|
Copyright (c) 2016 Vadim Chugunov
|
|
SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
'''
|
|
|
|
from __future__ import print_function, division
|
|
import sys
|
|
import logging
|
|
import lldb
|
|
import weakref
|
|
|
|
if sys.version_info[0] == 2:
|
|
# python2-based LLDB accepts utf8-encoded ascii strings only.
|
|
def to_lldb_str(s): return s.encode('utf8', 'backslashreplace') if isinstance(s, unicode) else s
|
|
range = xrange
|
|
else:
|
|
to_lldb_str = str
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
module = sys.modules[__name__]
|
|
rust_category = None
|
|
|
|
|
|
def initialize_category(debugger, internal_dict):
|
|
global module, rust_category
|
|
|
|
rust_category = debugger.CreateCategory('Rust')
|
|
# rust_category.AddLanguage(lldb.eLanguageTypeRust)
|
|
rust_category.SetEnabled(True)
|
|
|
|
attach_summary_to_type(tuple_summary_provider, r'^\(.*\)$', True)
|
|
attach_synthetic_to_type(MsvcTupleSynthProvider, r'^tuple\$?<.+>$',
|
|
True) # *-windows-msvc uses this name since 1.47
|
|
|
|
attach_synthetic_to_type(StrSliceSynthProvider, '&str')
|
|
attach_synthetic_to_type(StrSliceSynthProvider, 'str*')
|
|
attach_synthetic_to_type(StrSliceSynthProvider, 'str') # *-windows-msvc uses this name since 1.5?
|
|
|
|
attach_synthetic_to_type(StdStringSynthProvider, '^(collections|alloc)::string::String$', True)
|
|
attach_synthetic_to_type(StdVectorSynthProvider, r'^(collections|alloc)::vec::Vec<.+>$', True)
|
|
attach_synthetic_to_type(StdVecDequeSynthProvider,
|
|
r'^(collections|alloc::collections)::vec_deque::VecDeque<.+>$', True)
|
|
|
|
attach_synthetic_to_type(MsvcEnumSynthProvider, r'^enum\$<.+>$', True)
|
|
attach_synthetic_to_type(MsvcEnum2SynthProvider, r'^enum2\$<.+>$', True)
|
|
|
|
attach_synthetic_to_type(SliceSynthProvider, r'^&(mut *)?\[.*\]$', True)
|
|
attach_synthetic_to_type(MsvcSliceSynthProvider, r'^(mut *)?slice\$?<.+>.*$', True)
|
|
|
|
attach_synthetic_to_type(StdCStringSynthProvider, '^(std|alloc)::ffi::c_str::CString$', True)
|
|
attach_synthetic_to_type(StdCStrSynthProvider, '^&?(std|core)::ffi::c_str::CStr$', True)
|
|
|
|
attach_synthetic_to_type(StdOsStringSynthProvider, 'std::ffi::os_str::OsString')
|
|
attach_synthetic_to_type(StdOsStrSynthProvider, '^&?std::ffi::os_str::OsStr', True)
|
|
|
|
attach_synthetic_to_type(StdPathBufSynthProvider, 'std::path::PathBuf')
|
|
attach_synthetic_to_type(StdPathSynthProvider, '^&?std::path::Path', True)
|
|
|
|
attach_synthetic_to_type(StdRcSynthProvider, r'^alloc::rc::Rc<.+>$', True)
|
|
attach_synthetic_to_type(StdRcSynthProvider, r'^alloc::rc::Weak<.+>$', True)
|
|
attach_synthetic_to_type(StdArcSynthProvider, r'^alloc::(sync|arc)::Arc<.+>$', True)
|
|
attach_synthetic_to_type(StdArcSynthProvider, r'^alloc::(sync|arc)::Weak<.+>$', True)
|
|
attach_synthetic_to_type(StdMutexSynthProvider, r'^std::sync::mutex::Mutex<.+>$', True)
|
|
|
|
attach_synthetic_to_type(StdCellSynthProvider, r'^core::cell::Cell<.+>$', True)
|
|
attach_synthetic_to_type(StdRefCellSynthProvider, r'^core::cell::RefCell<.+>$', True)
|
|
attach_synthetic_to_type(StdRefCellBorrowSynthProvider, r'^core::cell::Ref<.+>$', True)
|
|
attach_synthetic_to_type(StdRefCellBorrowSynthProvider, r'^core::cell::RefMut<.+>$', True)
|
|
|
|
attach_synthetic_to_type(StdHashMapSynthProvider, r'^std::collections::hash::map::HashMap<.+>$', True)
|
|
attach_synthetic_to_type(StdHashSetSynthProvider, r'^std::collections::hash::set::HashSet<.+>$', True)
|
|
|
|
attach_synthetic_to_type(GenericEnumSynthProvider, r'^core::option::Option<.+>$', True)
|
|
attach_synthetic_to_type(GenericEnumSynthProvider, r'^core::result::Result<.+>$', True)
|
|
attach_synthetic_to_type(GenericEnumSynthProvider, r'^alloc::borrow::Cow<.+>$', True)
|
|
|
|
if 'rust' in internal_dict.get('source_languages', []):
|
|
lldb.SBDebugger.SetInternalVariable('target.process.thread.step-avoid-regexp',
|
|
'^<?(std|core|alloc)::', debugger.GetInstanceName())
|
|
|
|
|
|
def attach_synthetic_to_type(synth_class, type_name, is_regex=False):
|
|
global module, rust_category
|
|
# log.debug('attaching synthetic %s to "%s", is_regex=%s', synth_class.__name__, type_name, is_regex)
|
|
synth = lldb.SBTypeSynthetic.CreateWithClassName(__name__ + '.' + synth_class.__name__)
|
|
synth.SetOptions(lldb.eTypeOptionCascade)
|
|
rust_category.AddTypeSynthetic(lldb.SBTypeNameSpecifier(type_name, is_regex), synth)
|
|
|
|
def summary_fn(valobj, dict): return get_synth_summary(synth_class, valobj, dict)
|
|
# LLDB accesses summary fn's by name, so we need to create a unique one.
|
|
summary_fn.__name__ = '_get_synth_summary_' + synth_class.__name__
|
|
setattr(module, summary_fn.__name__, summary_fn)
|
|
attach_summary_to_type(summary_fn, type_name, is_regex)
|
|
|
|
|
|
def attach_summary_to_type(summary_fn, type_name, is_regex=False):
|
|
global module, rust_category
|
|
# log.debug('attaching summary %s to "%s", is_regex=%s', summary_fn.__name__, type_name, is_regex)
|
|
summary = lldb.SBTypeSummary.CreateWithFunctionName(__name__ + '.' + summary_fn.__name__)
|
|
summary.SetOptions(lldb.eTypeOptionCascade)
|
|
rust_category.AddTypeSummary(lldb.SBTypeNameSpecifier(type_name, is_regex), summary)
|
|
|
|
|
|
# 'get_summary' is annoyingly not a part of the standard LLDB synth provider API.
|
|
# This trick allows us to share data extraction logic between synth providers and their sibling summary providers.
|
|
def get_synth_summary(synth_class, valobj, dict):
|
|
try:
|
|
obj_id = valobj.GetIndexOfChildWithName('$$object-id$$')
|
|
summary = RustSynthProvider.synth_by_id[obj_id].get_summary()
|
|
return to_lldb_str(summary)
|
|
except Exception as e:
|
|
log.exception('%s', e)
|
|
raise
|
|
|
|
|
|
# Chained GetChildMemberWithName lookups
|
|
def gcm(valobj, *chain):
|
|
for name in chain:
|
|
valobj = valobj.GetChildMemberWithName(name)
|
|
return valobj
|
|
|
|
|
|
# Get a pointer out of core::ptr::Unique<T>
|
|
def read_unique_ptr(valobj):
|
|
pointer = valobj.GetChildMemberWithName('pointer')
|
|
if pointer.TypeIsPointerType(): # Between 1.33 and 1.63 pointer was just *const T
|
|
return pointer
|
|
return pointer.GetChildAtIndex(0)
|
|
|
|
|
|
def string_from_ptr(pointer, length):
|
|
if length <= 0:
|
|
return u''
|
|
error = lldb.SBError()
|
|
process = pointer.GetProcess()
|
|
data = process.ReadMemory(pointer.GetValueAsUnsigned(), length, error)
|
|
if error.Success():
|
|
return data.decode('utf8', 'replace')
|
|
else:
|
|
log.error('ReadMemory error: %s', error.GetCString())
|
|
|
|
|
|
def get_template_params(type_name):
|
|
params = []
|
|
level = 0
|
|
start = 0
|
|
for i, c in enumerate(type_name):
|
|
if c == '<':
|
|
level += 1
|
|
if level == 1:
|
|
start = i + 1
|
|
elif c == '>':
|
|
level -= 1
|
|
if level == 0:
|
|
params.append(type_name[start:i].strip())
|
|
elif c == ',' and level == 1:
|
|
params.append(type_name[start:i].strip())
|
|
start = i + 1
|
|
return params
|
|
|
|
|
|
def obj_summary(valobj, unavailable='{...}'):
|
|
summary = valobj.GetSummary()
|
|
if summary is not None:
|
|
return summary
|
|
summary = valobj.GetValue()
|
|
if summary is not None:
|
|
return summary
|
|
return unavailable
|
|
|
|
|
|
def sequence_summary(children, maxsize=32):
|
|
s = ''
|
|
for child in children:
|
|
if len(s) > 0:
|
|
s += ', '
|
|
s += obj_summary(child)
|
|
if len(s) > maxsize:
|
|
s += ', ...'
|
|
break
|
|
return s
|
|
|
|
|
|
def tuple_summary(obj, skip_first=0):
|
|
fields = [obj_summary(obj.GetChildAtIndex(i)) for i in range(skip_first, obj.GetNumChildren())]
|
|
return '(%s)' % ', '.join(fields)
|
|
|
|
|
|
# ----- Summaries -----
|
|
|
|
def tuple_summary_provider(valobj, dict={}):
|
|
return tuple_summary(valobj)
|
|
|
|
|
|
# ----- Synth providers ------
|
|
|
|
|
|
class RustSynthProvider(object):
|
|
synth_by_id = weakref.WeakValueDictionary()
|
|
next_id = 0
|
|
|
|
def __init__(self, valobj, dict={}):
|
|
self.valobj = valobj
|
|
self.obj_id = RustSynthProvider.next_id
|
|
RustSynthProvider.synth_by_id[self.obj_id] = self
|
|
RustSynthProvider.next_id += 1
|
|
|
|
def update(self):
|
|
return True
|
|
|
|
def has_children(self):
|
|
return False
|
|
|
|
def num_children(self):
|
|
return 0
|
|
|
|
def get_child_at_index(self, index):
|
|
return None
|
|
|
|
def get_child_index(self, name):
|
|
if name == '$$object-id$$':
|
|
return self.obj_id
|
|
|
|
try:
|
|
return self.get_index_of_child(name)
|
|
except Exception as e:
|
|
log.exception('%s', e)
|
|
raise
|
|
|
|
def get_summary(self):
|
|
return None
|
|
|
|
|
|
class ArrayLikeSynthProvider(RustSynthProvider):
|
|
'''Base class for providers that represent array-like objects'''
|
|
|
|
def update(self):
|
|
self.ptr, self.len = self.ptr_and_len(self.valobj) # type: ignore
|
|
self.item_type = self.ptr.GetType().GetPointeeType()
|
|
self.item_size = self.item_type.GetByteSize()
|
|
|
|
def ptr_and_len(self, obj):
|
|
pass # abstract
|
|
|
|
def num_children(self):
|
|
return self.len
|
|
|
|
def has_children(self):
|
|
return True
|
|
|
|
def get_child_at_index(self, index):
|
|
try:
|
|
if not 0 <= index < self.len:
|
|
return None
|
|
offset = index * self.item_size
|
|
return self.ptr.CreateChildAtOffset('[%s]' % index, offset, self.item_type)
|
|
except Exception as e:
|
|
log.exception('%s', e)
|
|
raise
|
|
|
|
def get_index_of_child(self, name):
|
|
return int(name.lstrip('[').rstrip(']'))
|
|
|
|
def get_summary(self):
|
|
return '(%d)' % (self.len,)
|
|
|
|
|
|
class StdVectorSynthProvider(ArrayLikeSynthProvider):
|
|
def ptr_and_len(self, vec):
|
|
return (
|
|
read_unique_ptr(gcm(vec, 'buf', 'ptr')),
|
|
gcm(vec, 'len').GetValueAsUnsigned()
|
|
)
|
|
|
|
def get_summary(self):
|
|
return '(%d) vec![%s]' % (self.len, sequence_summary((self.get_child_at_index(i) for i in range(self.len))))
|
|
|
|
|
|
class StdVecDequeSynthProvider(RustSynthProvider):
|
|
def update(self):
|
|
self.ptr = read_unique_ptr(gcm(self.valobj, 'buf', 'ptr'))
|
|
self.cap = gcm(self.valobj, 'buf', 'cap').GetValueAsUnsigned()
|
|
|
|
head = gcm(self.valobj, 'head').GetValueAsUnsigned()
|
|
|
|
# rust 1.67 changed from a head, tail implementation to a head, length impl
|
|
# https://github.com/rust-lang/rust/pull/102991
|
|
vd_len = gcm(self.valobj, 'len')
|
|
if vd_len.IsValid():
|
|
self.len = vd_len.GetValueAsUnsigned()
|
|
self.startptr = head
|
|
else:
|
|
tail = gcm(self.valobj, 'tail').GetValueAsUnsigned()
|
|
self.len = head - tail
|
|
self.startptr = tail
|
|
|
|
self.item_type = self.ptr.GetType().GetPointeeType()
|
|
self.item_size = self.item_type.GetByteSize()
|
|
|
|
def num_children(self):
|
|
return self.len
|
|
|
|
def has_children(self):
|
|
return True
|
|
|
|
def get_child_at_index(self, index):
|
|
try:
|
|
if not 0 <= index < self.num_children():
|
|
return None
|
|
offset = ((self.startptr + index) % self.cap) * self.item_size
|
|
return self.ptr.CreateChildAtOffset('[%s]' % index, offset, self.item_type)
|
|
except Exception as e:
|
|
log.exception('%s', e)
|
|
raise
|
|
|
|
def get_index_of_child(self, name):
|
|
return int(name.lstrip('[').rstrip(']'))
|
|
|
|
def get_summary(self):
|
|
return '(%d) VecDeque[%s]' % (self.num_children(), sequence_summary((self.get_child_at_index(i) for i in range(self.num_children()))))
|
|
|
|
##################################################################################################################
|
|
|
|
|
|
class SliceSynthProvider(ArrayLikeSynthProvider):
|
|
def ptr_and_len(self, vec):
|
|
return (
|
|
gcm(vec, 'data_ptr'),
|
|
gcm(vec, 'length').GetValueAsUnsigned()
|
|
)
|
|
|
|
def get_summary(self):
|
|
return '(%d) &[%s]' % (self.len, sequence_summary((self.get_child_at_index(i) for i in range(self.len))))
|
|
|
|
|
|
class MsvcSliceSynthProvider(SliceSynthProvider):
|
|
def get_type_name(self):
|
|
tparams = get_template_params(self.valobj.GetTypeName())
|
|
return '&[' + tparams[0] + ']'
|
|
|
|
|
|
# Base class for *String providers
|
|
class StringLikeSynthProvider(ArrayLikeSynthProvider):
|
|
def get_child_at_index(self, index):
|
|
ch = ArrayLikeSynthProvider.get_child_at_index(self, index)
|
|
ch.SetFormat(lldb.eFormatChar)
|
|
return ch
|
|
|
|
def get_summary(self):
|
|
# Limit string length to 1000 characters to cope with uninitialized values whose
|
|
# length field contains garbage.
|
|
strval = string_from_ptr(self.ptr, min(self.len, 1000))
|
|
if strval == None:
|
|
return None
|
|
if self.len > 1000:
|
|
strval += u'...'
|
|
return u'"%s"' % strval
|
|
|
|
|
|
class StrSliceSynthProvider(StringLikeSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
return (
|
|
gcm(valobj, 'data_ptr'),
|
|
gcm(valobj, 'length').GetValueAsUnsigned()
|
|
)
|
|
|
|
|
|
class StdStringSynthProvider(StringLikeSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
vec = gcm(valobj, 'vec')
|
|
return (
|
|
read_unique_ptr(gcm(vec, 'buf', 'ptr')),
|
|
gcm(vec, 'len').GetValueAsUnsigned()
|
|
)
|
|
|
|
|
|
class StdCStringSynthProvider(StringLikeSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
vec = gcm(valobj, 'inner')
|
|
return (
|
|
gcm(vec, 'data_ptr'),
|
|
gcm(vec, 'length').GetValueAsUnsigned() - 1
|
|
)
|
|
|
|
|
|
class StdOsStringSynthProvider(StringLikeSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
vec = gcm(valobj, 'inner', 'inner')
|
|
tmp = gcm(vec, 'bytes') # Windows OSString has an extra layer
|
|
if tmp.IsValid():
|
|
vec = tmp
|
|
return (
|
|
read_unique_ptr(gcm(vec, 'buf', 'ptr')),
|
|
gcm(vec, 'len').GetValueAsUnsigned()
|
|
)
|
|
|
|
|
|
class FFISliceSynthProvider(StringLikeSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
process = valobj.GetProcess()
|
|
slice_ptr = valobj.GetLoadAddress()
|
|
data_ptr_type = valobj.GetTarget().GetBasicType(lldb.eBasicTypeChar).GetPointerType()
|
|
# Unsized slice objects have incomplete debug info, so here we just assume standard slice
|
|
# reference layout: [<pointer to data>, <data size>]
|
|
error = lldb.SBError()
|
|
pointer = valobj.CreateValueFromAddress('data', slice_ptr, data_ptr_type)
|
|
length = process.ReadPointerFromMemory(slice_ptr + process.GetAddressByteSize(), error)
|
|
return pointer, length
|
|
|
|
|
|
class StdCStrSynthProvider(FFISliceSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
ptr, len = FFISliceSynthProvider.ptr_and_len(self, valobj)
|
|
return (ptr, len-1) # drop terminaing '\0'
|
|
|
|
|
|
class StdOsStrSynthProvider(FFISliceSynthProvider):
|
|
pass
|
|
|
|
|
|
class StdPathBufSynthProvider(StdOsStringSynthProvider):
|
|
def ptr_and_len(self, valobj):
|
|
return StdOsStringSynthProvider.ptr_and_len(self, gcm(valobj, 'inner'))
|
|
|
|
|
|
class StdPathSynthProvider(FFISliceSynthProvider):
|
|
pass
|
|
|
|
##################################################################################################################
|
|
|
|
|
|
class DerefSynthProvider(RustSynthProvider):
|
|
deref = lldb.SBValue()
|
|
|
|
def has_children(self):
|
|
return self.deref.MightHaveChildren()
|
|
|
|
def num_children(self):
|
|
return self.deref.GetNumChildren()
|
|
|
|
def get_child_at_index(self, index):
|
|
return self.deref.GetChildAtIndex(index)
|
|
|
|
def get_index_of_child(self, name):
|
|
return self.deref.GetIndexOfChildWithName(name)
|
|
|
|
def get_summary(self):
|
|
return obj_summary(self.deref)
|
|
|
|
# Base for Rc and Arc
|
|
|
|
|
|
class StdRefCountedSynthProvider(DerefSynthProvider):
|
|
weak = 0
|
|
strong = 0
|
|
|
|
def get_summary(self):
|
|
if self.weak != 0:
|
|
s = '(refs:%d,weak:%d) ' % (self.strong, self.weak)
|
|
else:
|
|
s = '(refs:%d) ' % self.strong
|
|
if self.strong > 0:
|
|
s += obj_summary(self.deref)
|
|
else:
|
|
s += '<disposed>'
|
|
return s
|
|
|
|
|
|
class StdRcSynthProvider(StdRefCountedSynthProvider):
|
|
def update(self):
|
|
inner = read_unique_ptr(gcm(self.valobj, 'ptr'))
|
|
self.strong = gcm(inner, 'strong', 'value', 'value').GetValueAsUnsigned()
|
|
self.weak = gcm(inner, 'weak', 'value', 'value').GetValueAsUnsigned()
|
|
if self.strong > 0:
|
|
self.deref = gcm(inner, 'value')
|
|
self.weak -= 1 # There's an implicit weak reference communally owned by all the strong pointers
|
|
else:
|
|
self.deref = lldb.SBValue()
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
|
|
class StdArcSynthProvider(StdRefCountedSynthProvider):
|
|
def update(self):
|
|
inner = read_unique_ptr(gcm(self.valobj, 'ptr'))
|
|
self.strong = gcm(inner, 'strong', 'v', 'value').GetValueAsUnsigned()
|
|
self.weak = gcm(inner, 'weak', 'v', 'value').GetValueAsUnsigned()
|
|
if self.strong > 0:
|
|
self.deref = gcm(inner, 'data')
|
|
self.weak -= 1 # There's an implicit weak reference communally owned by all the strong pointers
|
|
else:
|
|
self.deref = lldb.SBValue()
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
|
|
class StdMutexSynthProvider(DerefSynthProvider):
|
|
def update(self):
|
|
self.deref = gcm(self.valobj, 'data', 'value')
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
|
|
class StdCellSynthProvider(DerefSynthProvider):
|
|
def update(self):
|
|
self.deref = gcm(self.valobj, 'value', 'value')
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
|
|
class StdRefCellSynthProvider(DerefSynthProvider):
|
|
def update(self):
|
|
self.deref = gcm(self.valobj, 'value', 'value')
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
def get_summary(self):
|
|
borrow = gcm(self.valobj, 'borrow', 'value', 'value').GetValueAsSigned()
|
|
s = ''
|
|
if borrow < 0:
|
|
s = '(borrowed:mut) '
|
|
elif borrow > 0:
|
|
s = '(borrowed:%d) ' % borrow
|
|
return s + obj_summary(self.deref)
|
|
|
|
|
|
class StdRefCellBorrowSynthProvider(DerefSynthProvider):
|
|
def update(self):
|
|
self.deref = gcm(self.valobj, 'value', 'pointer').Dereference()
|
|
self.deref.SetPreferSyntheticValue(True)
|
|
|
|
##################################################################################################################
|
|
|
|
|
|
class EnumSynthProvider(RustSynthProvider):
|
|
variant = lldb.SBValue()
|
|
summary = ''
|
|
skip_first = 0
|
|
|
|
def has_children(self):
|
|
return self.variant.MightHaveChildren()
|
|
|
|
def num_children(self):
|
|
return self.variant.GetNumChildren() - self.skip_first
|
|
|
|
def get_child_at_index(self, index):
|
|
return self.variant.GetChildAtIndex(index + self.skip_first)
|
|
|
|
def get_index_of_child(self, name):
|
|
return self.variant.GetIndexOfChildWithName(name) - self.skip_first
|
|
|
|
def get_summary(self):
|
|
return self.summary
|
|
|
|
|
|
class GenericEnumSynthProvider(EnumSynthProvider):
|
|
def update(self):
|
|
dyn_type_name = self.valobj.GetTypeName()
|
|
variant_name = dyn_type_name[dyn_type_name.rfind(':')+1:]
|
|
self.variant = self.valobj
|
|
|
|
if self.variant.IsValid() and self.variant.GetNumChildren() > self.skip_first:
|
|
if self.variant.GetChildAtIndex(self.skip_first).GetName() in ['0', '__0']:
|
|
self.summary = variant_name + tuple_summary(self.variant)
|
|
else:
|
|
self.summary = variant_name + '{...}'
|
|
else:
|
|
self.summary = variant_name
|
|
|
|
|
|
class MsvcTupleSynthProvider(RustSynthProvider):
|
|
def update(self):
|
|
tparams = get_template_params(self.valobj.GetTypeName())
|
|
self.type_name = '(' + ', '.join(tparams) + ')'
|
|
|
|
def has_children(self):
|
|
return self.valobj.MightHaveChildren()
|
|
|
|
def num_children(self):
|
|
return self.valobj.GetNumChildren()
|
|
|
|
def get_child_at_index(self, index):
|
|
child = self.valobj.GetChildAtIndex(index)
|
|
return child.CreateChildAtOffset(str(index), 0, child.GetType())
|
|
|
|
def get_index_of_child(self, name):
|
|
return str(name)
|
|
|
|
def get_summary(self):
|
|
return tuple_summary(self.valobj)
|
|
|
|
def get_type_name(self):
|
|
return self.type_name
|
|
|
|
|
|
class MsvcEnumSynthProvider(EnumSynthProvider):
|
|
is_tuple_variant = False
|
|
|
|
def update(self):
|
|
tparams = get_template_params(self.valobj.GetTypeName())
|
|
if len(tparams) == 1: # Regular enum
|
|
discr = gcm(self.valobj, 'discriminant')
|
|
self.variant = gcm(self.valobj, 'variant' + str(discr.GetValueAsUnsigned()))
|
|
variant_name = discr.GetValue()
|
|
else: # Niche enum
|
|
dataful_min = int(tparams[1])
|
|
dataful_max = int(tparams[2])
|
|
dataful_var = tparams[3]
|
|
discr = gcm(self.valobj, 'discriminant')
|
|
if dataful_min <= discr.GetValueAsUnsigned() <= dataful_max:
|
|
self.variant = gcm(self.valobj, 'dataful_variant')
|
|
variant_name = dataful_var
|
|
else:
|
|
variant_name = discr.GetValue()
|
|
|
|
self.type_name = tparams[0]
|
|
|
|
if self.variant.IsValid() and self.variant.GetNumChildren() > self.skip_first:
|
|
if self.variant.GetChildAtIndex(self.skip_first).GetName() == '__0':
|
|
self.is_tuple_variant = True
|
|
self.summary = variant_name + tuple_summary(self.variant, skip_first=self.skip_first)
|
|
else:
|
|
self.summary = variant_name + '{...}'
|
|
else:
|
|
self.summary = variant_name
|
|
|
|
def get_child_at_index(self, index):
|
|
child = self.variant.GetChildAtIndex(index + self.skip_first)
|
|
if self.is_tuple_variant:
|
|
return child.CreateChildAtOffset(str(index), 0, child.GetType())
|
|
else:
|
|
return child
|
|
|
|
def get_index_of_child(self, name):
|
|
if self.is_tuple_variant:
|
|
return int(name)
|
|
else:
|
|
return self.variant.GetIndexOfChildWithName(name) - self.skip_first
|
|
|
|
def get_type_name(self):
|
|
return self.type_name
|
|
|
|
|
|
class MsvcEnum2SynthProvider(EnumSynthProvider):
|
|
is_tuple_variant = False
|
|
|
|
def update(self):
|
|
tparams = get_template_params(self.valobj.GetTypeName())
|
|
self.type_name = tparams[0]
|
|
|
|
def get_child_at_index(self, index):
|
|
return self.valobj.GetChildAtIndex(index)
|
|
|
|
def get_index_of_child(self, name):
|
|
return self.valobj.GetChildIndex(name)
|
|
|
|
def get_type_name(self):
|
|
return self.type_name
|
|
|
|
|
|
##################################################################################################################
|
|
|
|
|
|
class StdHashMapSynthProvider(RustSynthProvider):
|
|
def update(self):
|
|
self.initialize_table(gcm(self.valobj, 'base', 'table'))
|
|
|
|
def initialize_table(self, table):
|
|
assert table.IsValid()
|
|
|
|
if table.type.GetNumberOfTemplateArguments() > 0:
|
|
item_ty = table.type.GetTemplateArgumentType(0)
|
|
else: # we must be on windows-msvc - try to look up item type by name
|
|
table_ty_name = table.GetType().GetName() # "hashbrown::raw::RawTable<ITEM_TY>"
|
|
item_ty_name = get_template_params(table_ty_name)[0]
|
|
item_ty = table.GetTarget().FindTypes(item_ty_name).GetTypeAtIndex(0)
|
|
|
|
if item_ty.IsTypedefType():
|
|
item_ty = item_ty.GetTypedefedType()
|
|
|
|
inner_table = table.GetChildMemberWithName('table')
|
|
if inner_table.IsValid():
|
|
self.initialize_hashbrown_v2(inner_table, item_ty) # 1.52 <= std_version
|
|
else:
|
|
if not table.GetChildMemberWithName('data'):
|
|
self.initialize_hashbrown_v2(table, item_ty) # ? <= std_version < 1.52
|
|
else:
|
|
self.initialize_hashbrown_v1(table, item_ty) # 1.36 <= std_version < ?
|
|
|
|
def initialize_hashbrown_v2(self, table, item_ty):
|
|
self.num_buckets = gcm(table, 'bucket_mask').GetValueAsUnsigned() + 1
|
|
ctrl_ptr = gcm(table, 'ctrl', 'pointer')
|
|
ctrl = ctrl_ptr.GetPointeeData(0, self.num_buckets)
|
|
# Buckets are located above `ctrl`, in reverse order.
|
|
start_addr = ctrl_ptr.GetValueAsUnsigned() - item_ty.GetByteSize() * self.num_buckets
|
|
buckets_ty = item_ty.GetArrayType(self.num_buckets)
|
|
self.buckets = self.valobj.CreateValueFromAddress('data', start_addr, buckets_ty)
|
|
error = lldb.SBError()
|
|
self.valid_indices = []
|
|
for i in range(self.num_buckets):
|
|
if ctrl.GetUnsignedInt8(error, i) & 0x80 == 0:
|
|
self.valid_indices.append(self.num_buckets - 1 - i)
|
|
|
|
def initialize_hashbrown_v1(self, table, item_ty):
|
|
self.num_buckets = gcm(table, 'bucket_mask').GetValueAsUnsigned() + 1
|
|
ctrl_ptr = gcm(table, 'ctrl', 'pointer')
|
|
ctrl = ctrl_ptr.GetPointeeData(0, self.num_buckets)
|
|
buckets_ty = item_ty.GetArrayType(self.num_buckets)
|
|
self.buckets = gcm(table, 'data', 'pointer').Dereference().Cast(buckets_ty)
|
|
error = lldb.SBError()
|
|
self.valid_indices = []
|
|
for i in range(self.num_buckets):
|
|
if ctrl.GetUnsignedInt8(error, i) & 0x80 == 0:
|
|
self.valid_indices.append(i)
|
|
|
|
def has_children(self):
|
|
return True
|
|
|
|
def num_children(self):
|
|
return len(self.valid_indices)
|
|
|
|
def get_child_at_index(self, index):
|
|
bucket_idx = self.valid_indices[index]
|
|
item = self.buckets.GetChildAtIndex(bucket_idx)
|
|
return item.CreateChildAtOffset('[%d]' % index, 0, item.GetType())
|
|
|
|
def get_index_of_child(self, name):
|
|
return int(name.lstrip('[').rstrip(']'))
|
|
|
|
def get_summary(self):
|
|
return 'size=%d, capacity=%d' % (self.num_children(), self.num_buckets)
|
|
|
|
|
|
class StdHashSetSynthProvider(StdHashMapSynthProvider):
|
|
def update(self):
|
|
table = gcm(self.valobj, 'base', 'map', 'table') # std_version >= 1.48
|
|
if not table.IsValid():
|
|
table = gcm(self.valobj, 'map', 'base', 'table') # std_version < 1.48
|
|
self.initialize_table(table)
|
|
|
|
def get_child_at_index(self, index):
|
|
bucket_idx = self.valid_indices[index]
|
|
item = self.buckets.GetChildAtIndex(bucket_idx).GetChildAtIndex(0)
|
|
return item.CreateChildAtOffset('[%d]' % index, 0, item.GetType())
|
|
|
|
##################################################################################################################
|
|
|
|
|
|
def __lldb_init_module(debugger_obj, internal_dict):
|
|
log.info('Initializing')
|
|
initialize_category(debugger_obj, internal_dict) |