nim-dagger/tests/nimlldb.py

1382 lines
42 KiB
Python
Raw Normal View History

import lldb
from collections import OrderedDict
from typing import Union
def sbvaluegetitem(self: lldb.SBValue, name: Union[int, str]) -> lldb.SBValue:
if isinstance(name, str):
return self.GetChildMemberWithName(name)
else:
return self.GetChildAtIndex(name)
# Make this easier to work with
lldb.SBValue.__getitem__ = sbvaluegetitem
NIM_IS_V2 = True
def get_nti(value: lldb.SBValue, nim_name=None):
name_split = value.type.name.split("_")
type_nim_name = nim_name or name_split[1]
id_string = name_split[-1].split(" ")[0]
type_info_name = "NTI" + type_nim_name.lower() + "__" + id_string + "_"
nti = value.target.FindFirstGlobalVariable(type_info_name)
if not nti.IsValid():
type_info_name = "NTI" + "__" + id_string + "_"
nti = value.target.FindFirstGlobalVariable(type_info_name)
if not nti.IsValid():
print(f"NimEnumPrinter: lookup global symbol: '{type_info_name}' failed for {value.type.name}.\n")
return type_nim_name, nti
def enum_to_string(value: lldb.SBValue, int_val=None, nim_name=None):
tname = nim_name or value.type.name.split("_")[1]
enum_val = value.signed
if int_val is not None:
enum_val = int_val
default_val = f"{tname}.{str(enum_val)}"
fn_syms = value.target.FindFunctions("reprEnum")
if not fn_syms.GetSize() > 0:
return default_val
fn_sym: lldb.SBSymbolContext = fn_syms.GetContextAtIndex(0)
fn: lldb.SBFunction = fn_sym.function
fn_type: lldb.SBType = fn.type
arg_types: lldb.SBTypeList = fn_type.GetFunctionArgumentTypes()
if arg_types.GetSize() < 2:
return default_val
arg1_type: lldb.SBType = arg_types.GetTypeAtIndex(0)
arg2_type: lldb.SBType = arg_types.GetTypeAtIndex(1)
ty_info_name, nti = get_nti(value, nim_name=tname)
if not nti.IsValid():
return default_val
call = f"{fn.name}(({arg1_type.name}){enum_val}, ({arg2_type.name})" + str(nti.GetLoadAddress()) + ");"
res = executeCommand(call)
if res.error.fail:
return default_val
return f"{tname}.{res.summary[1:-1]}"
def to_string(value: lldb.SBValue):
# For getting NimStringDesc * value
value = value.GetNonSyntheticValue()
# Check if data pointer is Null
if value.type.is_pointer and value.unsigned == 0:
return None
size = int(value["Sup"]["len"].unsigned)
if size == 0:
return ""
if size > 2**14:
return "... (too long) ..."
data = value["data"]
# Check if first element is NULL
base_data_type = value.target.FindFirstType("char")
cast = data.Cast(base_data_type)
if cast.unsigned == 0:
return None
cast = data.Cast(value.target.FindFirstType("char").GetArrayType(size))
return bytearray(cast.data.uint8s).decode("utf-8")
def to_stringV2(value: lldb.SBValue):
# For getting NimStringV2 value
value = value.GetNonSyntheticValue()
data = value["p"]["data"]
# Check if data pointer is Null
if value["p"].unsigned == 0:
return None
size = int(value["len"].signed)
if size == 0:
return ""
if size > 2**14:
return "... (too long) ..."
# Check if first element is NULL
base_data_type = data.type.GetArrayElementType().GetTypedefedType()
cast = data.Cast(base_data_type)
if cast.unsigned == 0:
return None
cast = data.Cast(base_data_type.GetArrayType(size))
return bytearray(cast.data.uint8s).decode("utf-8")
def NimString(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
if NIM_IS_V2:
res = to_stringV2(value)
else:
res = to_string(value)
if res is not None:
return f'"{res}"'
else:
return "nil"
def rope_helper(value: lldb.SBValue) -> str:
value = value.GetNonSyntheticValue()
if value.type.is_pointer and value.unsigned == 0:
return ""
if value["length"].unsigned == 0:
return ""
if NIM_IS_V2:
str_val = to_stringV2(value["data"])
else:
str_val = to_string(value["data"])
if str_val is None:
str_val = ""
return rope_helper(value["left"]) + str_val + rope_helper(value["right"])
def Rope(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
rope_str = rope_helper(value)
if len(rope_str) == 0:
rope_str = "nil"
else:
rope_str = f'"{rope_str}"'
return f"Rope({rope_str})"
def NCSTRING(value: lldb.SBValue, internal_dict=None):
if is_local(value):
if not is_in_scope(value):
return "undefined"
ty = value.Dereference().type
val = value.target.CreateValueFromAddress(
value.name or "temp", lldb.SBAddress(value.unsigned, value.target), ty
).AddressOf()
return val.summary
def ObjectV2(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
orig_value = value.GetNonSyntheticValue()
if orig_value.type.is_pointer and orig_value.unsigned == 0:
return "nil"
custom_summary = get_custom_summary(value)
if custom_summary is not None:
return custom_summary
while orig_value.type.is_pointer:
orig_value = orig_value.Dereference()
if "_" in orig_value.type.name:
obj_name = orig_value.type.name.split("_")[1].replace("colonObjectType", "")
else:
obj_name = orig_value.type.name
num_children = value.num_children
fields = []
for i in range(num_children):
fields.append(f"{value[i].name}: {value[i].summary}")
res = f"{obj_name}(" + ", ".join(fields) + ")"
return res
def Number(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
if value.type.is_pointer and value.signed == 0:
return "nil"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return str(value.signed)
def Float(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return str(value.value)
def UnsignedNumber(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return str(value.unsigned)
def Bool(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return str(value.value)
def CharArray(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return str([f"'{char}'" for char in value.uint8s])
def Array(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
value = value.GetNonSyntheticValue()
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
value = value.GetNonSyntheticValue()
return "[" + ", ".join([value[i].summary for i in range(value.num_children)]) + "]"
def Tuple(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
while value.type.is_pointer:
value = value.Dereference()
num_children = value.num_children
fields = []
for i in range(num_children):
key = value[i].name
val = value[i].summary
if key.startswith("Field"):
fields.append(f"{val}")
else:
fields.append(f"{key}: {val}")
return "(" + ", ".join(fields) + f")"
def is_local(value: lldb.SBValue) -> bool:
line: lldb.SBLineEntry = value.frame.GetLineEntry()
decl: lldb.SBDeclaration = value.GetDeclaration()
if line.file == decl.file and decl.line != 0:
return True
return False
def is_in_scope(value: lldb.SBValue) -> bool:
line: lldb.SBLineEntry = value.frame.GetLineEntry()
decl: lldb.SBDeclaration = value.GetDeclaration()
if is_local(value) and decl.line < line.line:
return True
return False
def Enum(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_value_summary(value)
if custom_summary is not None:
return custom_summary
return enum_to_string(value)
def EnumSet(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
vals = []
max_vals = 7
for child in value.children:
vals.append(child.summary)
if len(vals) > max_vals:
vals.append("...")
break
return "{" + ", ".join(vals) + "}"
def Set(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if custom_summary is not None:
return custom_summary
vals = []
max_vals = 7
for child in value.children:
vals.append(child.value)
if len(vals) > max_vals:
vals.append("...")
break
return "{" + ", ".join(vals) + "}"
def Table(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if custom_summary is not None:
return custom_summary
fields = []
for i in range(value.num_children):
key = value[i].name
val = value[i].summary
fields.append(f"{key}: {val}")
return "Table({" + ", ".join(fields) + "})"
def HashSet(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if custom_summary is not None:
return custom_summary
fields = []
for i in range(value.num_children):
fields.append(f"{value[i].summary}")
return "HashSet({" + ", ".join(fields) + "})"
def StringTable(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
fields = []
for i in range(value.num_children - 1):
key = value[i].name
val = value[i].summary
fields.append(f"{key}: {val}")
mode = value[value.num_children - 1].summary
return "StringTable({" + ", ".join(fields) + f"}}, mode={mode})"
def Sequence(value: lldb.SBValue, internal_dict):
if is_local(value):
if not is_in_scope(value):
return "undefined"
custom_summary = get_custom_summary(value)
if not custom_summary is None:
return custom_summary
return "@[" + ", ".join([value[i].summary for i in range(value.num_children)]) + "]"
class StringChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.data_type: lldb.SBType
if not NIM_IS_V2:
self.data_type = self.value.target.FindFirstType("char")
self.first_element: lldb.SBValue
self.update()
self.count = 0
def num_children(self):
return self.count
def get_child_index(self, name):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
offset = index * self.data_size
return self.first_element.CreateChildAtOffset("[" + str(index) + "]", offset, self.data_type)
def get_data(self) -> lldb.SBValue:
return self.value["p"]["data"] if NIM_IS_V2 else self.value["data"]
def get_len(self) -> int:
if NIM_IS_V2:
if self.value["p"].unsigned == 0:
return 0
size = int(self.value["len"].signed)
if size == 0:
return 0
data = self.value["p"]["data"]
# Check if first element is NULL
base_data_type = data.type.GetArrayElementType().GetTypedefedType()
cast = data.Cast(base_data_type)
if cast.unsigned == 0:
return 0
else:
if self.value.type.is_pointer and self.value.unsigned == 0:
return 0
size = int(self.value["Sup"]["len"].unsigned)
if size == 0:
return 0
data = self.value["data"]
# Check if first element is NULL
base_data_type = self.value.target.FindFirstType("char")
cast = data.Cast(base_data_type)
if cast.unsigned == 0:
return 0
return size
def update(self):
if is_local(self.value):
if not is_in_scope(self.value):
return
data = self.get_data()
size = self.get_len()
self.count = size
self.first_element = data
if NIM_IS_V2:
self.data_type = data.type.GetArrayElementType().GetTypedefedType()
self.data_size = self.data_type.GetByteSize()
def has_children(self):
return bool(self.num_children())
class ArrayChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.data_type: lldb.SBType
self.first_element: lldb.SBValue
self.update()
def num_children(self):
return self.has_children() and self.value.num_children
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
offset = index * self.value[index].GetByteSize()
return self.first_element.CreateChildAtOffset("[" + str(index) + "]", offset, self.data_type)
def update(self):
if not self.has_children():
return
self.first_element = self.value[0]
self.data_type = self.value.type.GetArrayElementType()
def has_children(self):
if is_local(self.value):
if not is_in_scope(self.value):
return False
return bool(self.value.num_children)
class SeqChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.data_type: lldb.SBType
self.first_element: lldb.SBValue
self.data: lldb.SBValue
self.count = 0
self.update()
def num_children(self):
return self.count
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
offset = index * self.data[index].GetByteSize()
return self.first_element.CreateChildAtOffset("[" + str(index) + "]", offset, self.data_type)
def get_data(self) -> lldb.SBValue:
return self.value["p"]["data"] if NIM_IS_V2 else self.value["data"]
def get_len(self) -> lldb.SBValue:
return self.value["len"] if NIM_IS_V2 else self.value["Sup"]["len"]
def update(self):
self.count = 0
if is_local(self.value):
if not is_in_scope(self.value):
return
self.count = self.get_len().unsigned
if not self.has_children():
return
data = self.get_data()
self.data_type = data.type.GetArrayElementType()
self.data = data.Cast(self.data_type.GetArrayType(self.num_children()))
self.first_element = self.data
def has_children(self):
return bool(self.num_children())
class ObjectChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.data_type: lldb.SBType
self.first_element: lldb.SBValue
self.data: lldb.SBValue
self.children: OrderedDict[str, int] = OrderedDict()
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.children)
def get_child_index(self, name: str):
return self.children[name]
def get_child_at_index(self, index):
return self.child_list[index]
def populate_children(self):
self.children.clear()
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
stack = [self.value.GetNonSyntheticValue()]
index = 0
while stack:
cur_val = stack.pop()
if cur_val.type.is_pointer and cur_val.unsigned == 0:
continue
while cur_val.type.is_pointer:
cur_val = cur_val.Dereference()
# Add super objects if they exist
if cur_val.num_children > 0 and cur_val[0].name == "Sup" and cur_val[0].type.name.startswith("tyObject"):
stack.append(cur_val[0])
for child in cur_val.children:
child = child.GetNonSyntheticValue()
if child.name == "Sup":
continue
self.children[child.name] = index
self.child_list.append(child)
index += 1
def update(self):
self.populate_children()
def has_children(self):
return bool(self.num_children())
class HashSetChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
return self.child_list[index]
def get_data(self) -> lldb.SBValue:
return self.value["data"]["p"]["data"] if NIM_IS_V2 else self.value["data"]["data"]
def get_len(self) -> lldb.SBValue:
return self.value["data"]["len"] if NIM_IS_V2 else self.value["data"]["Sup"]["len"]
def update(self):
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
tuple_len = int(self.get_len().unsigned)
tuple = self.get_data()
base_data_type = tuple.type.GetArrayElementType()
cast = tuple.Cast(base_data_type.GetArrayType(tuple_len))
index = 0
for i in range(tuple_len):
el = cast[i]
field0 = int(el[0].unsigned)
if field0 == 0:
continue
key = el[1]
child = key.CreateValueFromAddress(f"[{str(index)}]", key.GetLoadAddress(), key.GetType())
index += 1
self.child_list.append(child)
def has_children(self):
return bool(self.num_children())
class SetCharChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.ty = self.value.target.FindFirstType("char")
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
return self.child_list[index]
def update(self):
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
cur_pos = 0
for child in self.value.children:
child_val = child.signed
if child_val != 0:
temp = child_val
num_bits = 8
while temp != 0:
is_set = temp & 1
if is_set == 1:
data = lldb.SBData.CreateDataFromInt(cur_pos)
child = self.value.synthetic_child_from_data(f"[{len(self.child_list)}]", data, self.ty)
self.child_list.append(child)
temp = temp >> 1
cur_pos += 1
num_bits -= 1
cur_pos += num_bits
else:
cur_pos += 8
def has_children(self):
return bool(self.num_children())
def create_set_children(value: lldb.SBValue, child_type: lldb.SBType, starting_pos: int) -> list[lldb.SBValue]:
child_list: list[lldb.SBValue] = []
cur_pos = starting_pos
if value.num_children > 0:
children = value.children
else:
children = [value]
for child in children:
child_val = child.signed
if child_val != 0:
temp = child_val
num_bits = 8
while temp != 0:
is_set = temp & 1
if is_set == 1:
data = lldb.SBData.CreateDataFromInt(cur_pos)
child = value.synthetic_child_from_data(f"[{len(child_list)}]", data, child_type)
child_list.append(child)
temp = temp >> 1
cur_pos += 1
num_bits -= 1
cur_pos += num_bits
else:
cur_pos += 8
return child_list
class SetIntChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.ty = self.value.target.FindFirstType(f"NI64")
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
return self.child_list[index]
def update(self):
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
bits = self.value.GetByteSize() * 8
starting_pos = -(bits // 2)
self.child_list = create_set_children(self.value, self.ty, starting_pos)
def has_children(self):
return bool(self.num_children())
class SetUIntChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.ty = self.value.target.FindFirstType(f"NU64")
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
return self.child_list[index]
def update(self):
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
self.child_list = create_set_children(self.value, self.ty, starting_pos=0)
def has_children(self):
return bool(self.num_children())
class SetEnumChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.ty = self.value.target.FindFirstType(self.value.type.name.replace("tySet_", ""))
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return int(name.lstrip("[").rstrip("]"))
def get_child_at_index(self, index):
return self.child_list[index]
def update(self):
if is_local(self.value):
if not is_in_scope(self.value):
return
self.child_list = create_set_children(self.value, self.ty, starting_pos=0)
def has_children(self):
return bool(self.num_children())
class TableChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.children: OrderedDict[str, int] = OrderedDict()
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return self.children[name]
def get_child_at_index(self, index):
return self.child_list[index]
def get_data(self) -> lldb.SBValue:
return self.value["data"]["p"]["data"] if NIM_IS_V2 else self.value["data"]["data"]
def get_len(self) -> lldb.SBValue:
return self.value["data"]["len"] if NIM_IS_V2 else self.value["data"]["Sup"]["len"]
def update(self):
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
tuple_len = int(self.get_len().unsigned)
tuple = self.get_data()
base_data_type = tuple.type.GetArrayElementType()
cast = tuple.Cast(base_data_type.GetArrayType(tuple_len))
index = 0
for i in range(tuple_len):
el = cast[i]
field0 = int(el[0].unsigned)
if field0 == 0:
continue
key = el[1]
val = el[2]
key_summary = key.summary
child = self.value.CreateValueFromAddress(key_summary, val.GetLoadAddress(), val.GetType())
self.child_list.append(child)
self.children[key_summary] = index
index += 1
def has_children(self):
return bool(self.num_children())
class StringTableChildrenProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value = value
self.children: OrderedDict[str, int] = OrderedDict()
self.child_list: list[lldb.SBValue] = []
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return self.children[name]
def get_child_at_index(self, index):
return self.child_list[index]
def get_data(self) -> lldb.SBValue:
return self.value["data"]["p"]["data"] if NIM_IS_V2 else self.value["data"]["data"]
def get_len(self) -> lldb.SBValue:
return self.value["data"]["len"] if NIM_IS_V2 else self.value["data"]["Sup"]["len"]
def update(self):
self.children.clear()
self.child_list = []
if is_local(self.value):
if not is_in_scope(self.value):
return
tuple_len = int(self.get_len().unsigned)
tuple = self.get_data()
base_data_type = tuple.type.GetArrayElementType()
cast = tuple.Cast(base_data_type.GetArrayType(tuple_len))
index = 0
for i in range(tuple_len):
el = cast[i]
field0 = int(el[2].unsigned)
if field0 == 0:
continue
key = el[0]
val = el[1]
child = val.CreateValueFromAddress(key.summary, val.GetLoadAddress(), val.GetType())
self.child_list.append(child)
self.children[key.summary] = index
index += 1
self.child_list.append(self.value["mode"])
self.children["mode"] = index
def has_children(self):
return bool(self.num_children())
class LLDBDynamicObjectProvider:
def __init__(self, value: lldb.SBValue, internalDict):
value = value.GetNonSyntheticValue()
self.value: lldb.SBValue = value[0]
self.children: OrderedDict[str, int] = OrderedDict()
self.child_list: list[lldb.SBValue] = []
while self.value.type.is_pointer:
self.value = self.value.Dereference()
self.update()
def num_children(self):
return len(self.child_list)
def get_child_index(self, name: str):
return self.children[name]
def get_child_at_index(self, index):
return self.child_list[index]
def update(self):
self.children.clear()
self.child_list = []
for i, child in enumerate(self.value.children):
name = child.name.strip('"')
new_child = child.CreateValueFromAddress(name, child.GetLoadAddress(), child.GetType())
self.children[name] = i
self.child_list.append(new_child)
def has_children(self):
return bool(self.num_children())
class LLDBBasicObjectProvider:
def __init__(self, value: lldb.SBValue, internalDict):
self.value: lldb.SBValue = value
def num_children(self):
if self.value is not None:
return self.value.num_children
return 0
def get_child_index(self, name: str):
return self.value.GetIndexOfChildWithName(name)
def get_child_at_index(self, index):
return self.value.GetChildAtIndex(index)
def update(self):
pass
def has_children(self):
return self.num_children() > 0
class CustomObjectChildrenProvider:
"""
This children provider handles values returned from lldbDebugSynthetic*
Nim procedures
"""
def __init__(self, value: lldb.SBValue, internalDict):
self.value: lldb.SBValue = get_custom_synthetic(value) or value
if "lldbdynamicobject" in self.value.type.name.lower():
self.provider = LLDBDynamicObjectProvider(self.value, internalDict)
else:
self.provider = LLDBBasicObjectProvider(self.value, internalDict)
def num_children(self):
return self.provider.num_children()
def get_child_index(self, name: str):
return self.provider.get_child_index(name)
def get_child_at_index(self, index):
return self.provider.get_child_at_index(index)
def update(self):
self.provider.update()
def has_children(self):
return self.provider.has_children()
def echo(debugger: lldb.SBDebugger, command: str, result, internal_dict):
debugger.HandleCommand("po " + command)
SUMMARY_FUNCTIONS: dict[str, lldb.SBFunction] = {}
SYNTHETIC_FUNCTIONS: dict[str, lldb.SBFunction] = {}
def get_custom_summary(value: lldb.SBValue) -> Union[str, None]:
"""Get a custom summary if a function exists for it"""
value = value.GetNonSyntheticValue()
if value.GetAddress().GetOffset() == 0:
return None
base_type = get_base_type(value.type)
fn = SUMMARY_FUNCTIONS.get(base_type.name)
if fn is None:
return None
fn_type: lldb.SBType = fn.type
arg_types: lldb.SBTypeList = fn_type.GetFunctionArgumentTypes()
first_type = arg_types.GetTypeAtIndex(0)
while value.type.is_pointer:
value = value.Dereference()
if first_type.is_pointer:
command = f"{fn.name}(({first_type.name})" + str(value.GetLoadAddress()) + ");"
else:
command = f"{fn.name}(*({first_type.GetPointerType().name})" + str(value.GetLoadAddress()) + ");"
res = executeCommand(command)
if res.error.fail:
return None
return res.summary.strip('"')
def get_custom_value_summary(value: lldb.SBValue) -> Union[str, None]:
"""Get a custom summary if a function exists for it"""
fn: lldb.SBFunction = SUMMARY_FUNCTIONS.get(value.type.name)
if fn is None:
return None
command = f"{fn.name}(({value.type.name})" + str(value.signed) + ");"
res = executeCommand(command)
if res.error.fail:
return None
return res.summary.strip('"')
def get_custom_synthetic(value: lldb.SBValue) -> Union[lldb.SBValue, None]:
"""Get a custom synthetic object if a function exists for it"""
value = value.GetNonSyntheticValue()
if value.GetAddress().GetOffset() == 0:
return None
base_type = get_base_type(value.type)
fn = SYNTHETIC_FUNCTIONS.get(base_type.name)
if fn is None:
return None
fn_type: lldb.SBType = fn.type
arg_types: lldb.SBTypeList = fn_type.GetFunctionArgumentTypes()
first_type = arg_types.GetTypeAtIndex(0)
while value.type.is_pointer:
value = value.Dereference()
if first_type.is_pointer:
first_arg = f"({first_type.name}){value.GetLoadAddress()}"
else:
first_arg = f"*({first_type.GetPointerType().name}){value.GetLoadAddress()}"
if arg_types.GetSize() > 1 and fn.GetArgumentName(1) == "Result":
ret_type = arg_types.GetTypeAtIndex(1)
ret_type = get_base_type(ret_type)
command = f"""
{ret_type.name} lldbT;
nimZeroMem((void*)(&lldbT), sizeof({ret_type.name}));
{fn.name}(({first_arg}), (&lldbT));
lldbT;
"""
else:
command = f"{fn.name}({first_arg});"
res = executeCommand(command)
if res.error.fail:
print(res.error)
return None
return res
def get_base_type(ty: lldb.SBType) -> lldb.SBType:
"""Get the base type of the type"""
temp = ty
while temp.IsPointerType():
temp = temp.GetPointeeType()
return temp
def use_base_type(ty: lldb.SBType) -> bool:
types_to_check = [
"NF",
"NF32",
"NF64",
"NI",
"NI8",
"NI16",
"NI32",
"NI64",
"bool",
"NIM_BOOL",
"NU",
"NU8",
"NU16",
"NU32",
"NU64",
]
for type_to_check in types_to_check:
if ty.name.startswith(type_to_check):
return False
return True
def breakpoint_function_wrapper(frame: lldb.SBFrame, bp_loc, internal_dict):
"""This allows function calls to Nim for custom object summaries and synthetic children"""
debugger = lldb.debugger
global SUMMARY_FUNCTIONS
global SYNTHETIC_FUNCTIONS
global NIM_IS_V2
for tname, fn in SYNTHETIC_FUNCTIONS.items():
debugger.HandleCommand(f"type synthetic delete -w nim {tname}")
SUMMARY_FUNCTIONS = {}
SYNTHETIC_FUNCTIONS = {}
target: lldb.SBTarget = debugger.GetSelectedTarget()
NIM_IS_V2 = target.FindFirstType("TNimTypeV2").IsValid()
module = frame.GetSymbolContext(lldb.eSymbolContextModule).module
for sym in module:
if (
not sym.name.startswith("lldbDebugSummary")
and not sym.name.startswith("lldbDebugSynthetic")
and not sym.name.startswith("dollar___")
):
continue
fn_syms: lldb.SBSymbolContextList = target.FindFunctions(sym.name)
if not fn_syms.GetSize() > 0:
continue
fn_sym: lldb.SBSymbolContext = fn_syms.GetContextAtIndex(0)
fn: lldb.SBFunction = fn_sym.function
fn_type: lldb.SBType = fn.type
arg_types: lldb.SBTypeList = fn_type.GetFunctionArgumentTypes()
if arg_types.GetSize() > 1 and fn.GetArgumentName(1) == "Result":
pass # don't continue
elif arg_types.GetSize() != 1:
continue
arg_type: lldb.SBType = arg_types.GetTypeAtIndex(0)
if use_base_type(arg_type):
arg_type = get_base_type(arg_type)
if sym.name.startswith("lldbDebugSummary") or sym.name.startswith("dollar___"):
SUMMARY_FUNCTIONS[arg_type.name] = fn
elif sym.name.startswith("lldbDebugSynthetic"):
SYNTHETIC_FUNCTIONS[arg_type.name] = fn
debugger.HandleCommand(
f"type synthetic add -w nim -l {__name__}.CustomObjectChildrenProvider {arg_type.name}"
)
def executeCommand(command, *args):
debugger = lldb.debugger
process = debugger.GetSelectedTarget().GetProcess()
frame: lldb.SBFrame = process.GetSelectedThread().GetSelectedFrame()
expr_options = lldb.SBExpressionOptions()
expr_options.SetIgnoreBreakpoints(False)
expr_options.SetFetchDynamicValue(lldb.eDynamicCanRunTarget)
expr_options.SetTimeoutInMicroSeconds(30 * 1000 * 1000) # 30 second timeout
expr_options.SetTryAllThreads(True)
expr_options.SetUnwindOnError(False)
expr_options.SetGenerateDebugInfo(True)
expr_options.SetLanguage(lldb.eLanguageTypeC)
expr_options.SetCoerceResultToId(True)
res = frame.EvaluateExpression(command, expr_options)
return res
def __lldb_init_module(debugger, internal_dict):
# fmt: off
print("internal_dict: ", internal_dict.keys())
debugger.HandleCommand(f"breakpoint command add -F {__name__}.breakpoint_function_wrapper --script-type python 1")
debugger.HandleCommand(f"type summary add -w nim -n sequence -F {__name__}.Sequence -x tySequence_+[[:alnum:]]+$")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SeqChildrenProvider -x tySequence_+[[:alnum:]]+$")
debugger.HandleCommand(f"type summary add -w nim -n chararray -F {__name__}.CharArray -x char\s+[\d+]")
debugger.HandleCommand(f"type summary add -w nim -n array -F {__name__}.Array -x tyArray_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.ArrayChildrenProvider -x tyArray_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n string -F {__name__}.NimString NimStringDesc")
debugger.HandleCommand(f"type summary add -w nim -n stringv2 -F {__name__}.NimString -x NimStringV2$")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.StringChildrenProvider -x NimStringV2$")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.StringChildrenProvider -x NimStringDesc$")
debugger.HandleCommand(f"type summary add -w nim -n cstring -F {__name__}.NCSTRING NCSTRING")
debugger.HandleCommand(f"type summary add -w nim -n object -F {__name__}.ObjectV2 -x tyObject_+[[:alnum:]]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.ObjectChildrenProvider -x tyObject_+[[:alnum:]]+_+[[:alnum:]]+$")
debugger.HandleCommand(f"type summary add -w nim -n tframe -F {__name__}.ObjectV2 -x TFrame$")
debugger.HandleCommand(f"type summary add -w nim -n rootobj -F {__name__}.ObjectV2 -x RootObj$")
debugger.HandleCommand(f"type summary add -w nim -n enum -F {__name__}.Enum -x tyEnum_+[[:alnum:]]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n hashset -F {__name__}.HashSet -x tyObject_+HashSet_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.HashSetChildrenProvider -x tyObject_+HashSet_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n rope -F {__name__}.Rope -x tyObject_+Rope[[:alnum:]]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n setuint -F {__name__}.Set -x tySet_+tyInt_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SetIntChildrenProvider -x tySet_+tyInt[0-9]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n setint -F {__name__}.Set -x tySet_+tyInt[0-9]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n setuint2 -F {__name__}.Set -x tySet_+tyUInt[0-9]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SetUIntChildrenProvider -x tySet_+tyUInt[0-9]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SetUIntChildrenProvider -x tySet_+tyInt_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n setenum -F {__name__}.EnumSet -x tySet_+tyEnum_+[[:alnum:]]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SetEnumChildrenProvider -x tySet_+tyEnum_+[[:alnum:]]+_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n setchar -F {__name__}.Set -x tySet_+tyChar_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.SetCharChildrenProvider -x tySet_+tyChar_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n table -F {__name__}.Table -x tyObject_+Table_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.TableChildrenProvider -x tyObject_+Table_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n stringtable -F {__name__}.StringTable -x tyObject_+StringTableObj_+[[:alnum:]]+")
debugger.HandleCommand(f"type synthetic add -w nim -l {__name__}.StringTableChildrenProvider -x tyObject_+StringTableObj_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n tuple2 -F {__name__}.Tuple -x tyObject_+Tuple_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n tuple -F {__name__}.Tuple -x tyTuple_+[[:alnum:]]+")
debugger.HandleCommand(f"type summary add -w nim -n float -F {__name__}.Float NF")
debugger.HandleCommand(f"type summary add -w nim -n float32 -F {__name__}.Float NF32")
debugger.HandleCommand(f"type summary add -w nim -n float64 -F {__name__}.Float NF64")
debugger.HandleCommand(f"type summary add -w nim -n integer -F {__name__}.Number -x NI")
debugger.HandleCommand(f"type summary add -w nim -n integer8 -F {__name__}.Number -x NI8")
debugger.HandleCommand(f"type summary add -w nim -n integer16 -F {__name__}.Number -x NI16")
debugger.HandleCommand(f"type summary add -w nim -n integer32 -F {__name__}.Number -x NI32")
debugger.HandleCommand(f"type summary add -w nim -n integer64 -F {__name__}.Number -x NI64")
debugger.HandleCommand(f"type summary add -w nim -n bool -F {__name__}.Bool -x bool")
debugger.HandleCommand(f"type summary add -w nim -n bool2 -F {__name__}.Bool -x NIM_BOOL")
debugger.HandleCommand(f"type summary add -w nim -n uinteger -F {__name__}.UnsignedNumber -x NU")
debugger.HandleCommand(f"type summary add -w nim -n uinteger8 -F {__name__}.UnsignedNumber -x NU8")
debugger.HandleCommand(f"type summary add -w nim -n uinteger16 -F {__name__}.UnsignedNumber -x NU16")
debugger.HandleCommand(f"type summary add -w nim -n uinteger32 -F {__name__}.UnsignedNumber -x NU32")
debugger.HandleCommand(f"type summary add -w nim -n uinteger64 -F {__name__}.UnsignedNumber -x NU64")
debugger.HandleCommand("type category enable nim")
debugger.HandleCommand(f"command script add -f {__name__}.echo echo")
# fmt: on