def K(name, enumName=''):
try:
result = gdb.lookup_global_symbol(name).value()
except:
result = gdb.lookup_global_symbol(alt_form_enum(name,
enumName)).value()
return result
def invoke_static(arg):
if arg.type.code == gdb.TYPE_CODE_PTR and arg.type.target(
).name == "NimStringDesc":
return arg
argTypeName = str(arg.type)
for func, arg_typ in DollarPrintFunction.dollar_functions:
# this way of overload resolution cannot deal with type aliases,
# therefore it won't find all overloads.
if arg_typ == argTypeName:
func_value = gdb.lookup_global_symbol(
func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg)
elif arg_typ == argTypeName + " *":
func_value = gdb.lookup_global_symbol(
func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg.address)
printErrorOnce(
argTypeName,
"No suitable Nim $ operator found for type: " + argTypeName + "\n")
return None
def __init__(self):
"""
Internally, everything is kept as gdb.Value
node_num: number of NUMA node
"""
super(Slab, self).__init__("slab", gdb.COMMAND_USER)
self.cpu_num = gdb.lookup_global_symbol("nr_cpu_ids").value()
self.node_num = self._get_node_num()
self._check_slub()
self.arch = self.get_arch()
self.per_cpu_offset = gdb.lookup_global_symbol("__per_cpu_offset").value()
try:
self.memstart_addr = gdb.lookup_global_symbol("memstart_addr").value()
except Exception:
self.memstart_addr = None
self.cache_alloc_bp = KmemCacheAlloc(self)
self.cache_free_bp = KmemCacheFree(self)
self.new_slab_bp = NewSlab(self)
self.discard_slab_bp = DiscardSlab(self)
self.trace_caches = []
self.break_caches = []
self.watch_caches = []
self.slabs_list = []
self.update_breakpoints()
def invoke(self, basevar, cpu=None):
if not (basevar.type.tag and
basevar.type.tag.startswith('static_percpu<')):
raise gdb.GdbError('Not a static_percpu')
if cpu is None:
cpu = gdb.selected_thread().num - 1
else:
cpu = int(cpu)
# Get the key. Unfortunately, G++ optimizes out the second
# template argument, so we have to do this the dumb way.
m = re.search(r'&([^ ,]+_key),', str(basevar.type))
if not m:
raise gdb.GdbError('Failed to parse type string %r' %
str(basevar.type))
key = gdb.lookup_global_symbol(m.group(1))
if key is None:
raise gdb.GdbError('Failed to find per-cpu key %r' % m.group(1))
# Compute the offset
start = gdb.lookup_global_symbol('__percpu_start')
offset = int(key.value().address) - int(start.value().address)
# Get CPU's base
cpubase = gdb.lookup_global_symbol('percpu_offsets').value()[cpu]
# Put together new pointer
return (cpubase + offset).cast(key.type.pointer()).dereference()
def all_traces():
constants = TraceConstants()
inf = gdb.selected_inferior()
trace_log = gdb.lookup_global_symbol('trace_log').value()
max_trace = ulong(gdb.parse_and_eval('max_trace'))
trace_log = inf.read_memory(trace_log.address, max_trace)
trace_page_size = ulong(gdb.parse_and_eval('trace_page_size'))
last = ulong(gdb.lookup_global_symbol('trace_record_last').value()['_M_i'])
last %= max_trace
pivot = align_up(last, trace_page_size)
trace_log = trace_log[pivot:] + trace_log[:pivot]
last += max_trace - pivot
backtrace_len = constants.backtrace_len
i = 0
while i < last:
tp_key, thread, time, cpu, flags = struct.unpack('QQQII', trace_log[i:i+32])
if tp_key == 0:
i = align_up(i + 8, trace_page_size)
continue
tp = gdb.Value(tp_key).cast(gdb.lookup_type('tracepoint_base').pointer())
sig = sig_to_string(ulong(tp['sig'])) # FIXME: cache
i += 32
backtrace = None
if flags & 1:
backtrace = struct.unpack('Q' * backtrace_len, trace_log[i:i+8*backtrace_len])
i += 8 * backtrace_len
size = struct.calcsize(sig)
data = struct.unpack(sig, trace_log[i:i+size])
i += size
i = align_up(i, 8)
yield Trace(tp, thread, time, cpu, data, backtrace=backtrace)
def invoke(self, basevar, cpu=None):
if not (basevar.type.tag
and basevar.type.tag.startswith('static_percpu<')):
raise gdb.GdbError('Not a static_percpu')
if cpu is None:
cpu = gdb.selected_thread().num - 1
else:
cpu = int(cpu)
# Get the key. Unfortunately, G++ optimizes out the second
# template argument, so we have to do this the dumb way.
m = re.search(r'&([^ ,]+_key),', str(basevar.type))
if not m:
raise gdb.GdbError('Failed to parse type string %r' %
str(basevar.type))
key = gdb.lookup_global_symbol(m.group(1))
if key is None:
raise gdb.GdbError('Failed to find per-cpu key %r' % m.group(1))
# Compute the offset
start = gdb.lookup_global_symbol('__percpu_start')
offset = int(key.value().address) - int(start.value().address)
# Get CPU's base
cpubase = gdb.lookup_global_symbol('percpu_offsets').value()[cpu]
# Put together new pointer
return (cpubase + offset).cast(key.type.pointer()).dereference()
def enumNti(typeNimName, idString):
typeInfoName = "NTI" + typeNimName.lower() + "__" + idString + "_"
nti = gdb.lookup_global_symbol(typeInfoName)
if nti is None:
typeInfoName = "NTI" + "__" + idString + "_"
nti = gdb.lookup_global_symbol(typeInfoName)
return (typeInfoName, nti)
def all_traces():
# XXX: needed for GDB to see 'trace_page_size'
gdb.lookup_global_symbol('gdb_trace_function_entry')
inf = gdb.selected_inferior()
trace_log = gdb.lookup_global_symbol('trace_log').value()
if not trace_log:
return
max_trace = ulong(gdb.parse_and_eval('max_trace'))
trace_log = inf.read_memory(trace_log, max_trace)
trace_page_size = ulong(gdb.parse_and_eval('trace_page_size'))
last = ulong(gdb.lookup_global_symbol('trace_record_last').value()['_M_i'])
last %= max_trace
pivot = align_up(last, trace_page_size)
trace_log = trace_log[pivot:] + trace_log[:pivot]
last += max_trace - pivot
tp_ptr = gdb.lookup_type('tracepoint_base').pointer()
backtrace_len = ulong(gdb.parse_and_eval('tracepoint_base::backtrace_len'))
tracepoints = {}
i = 0
while i < last:
tp_key, thread, thread_name, time, cpu, flags = struct.unpack(
'QQ16sQII', trace_log[i:i + 48])
thread_name = thread_name.rstrip('\0')
if tp_key == 0:
i = align_up(i + 8, trace_page_size)
continue
tp = tracepoints.get(tp_key, None)
if not tp:
tp_ref = gdb.Value(tp_key).cast(tp_ptr)
tp = TracePoint(tp_key, str(tp_ref["name"].string()),
sig_to_string(ulong(tp_ref['sig'])),
str(tp_ref["format"].string()))
tracepoints[tp_key] = tp
i += 48
backtrace = None
if flags & 1:
backtrace = struct.unpack('Q' * backtrace_len,
trace_log[i:i + 8 * backtrace_len])
i += 8 * backtrace_len
size = struct.calcsize(tp.signature)
data = struct.unpack(tp.signature, trace_log[i:i + size])
i += size
i = align_up(i, 8)
yield Trace(tp,
thread,
thread_name,
time,
cpu,
data,
backtrace=backtrace)
def setup_tasks(self):
gdb.execute('set print thread-events 0')
init_task = gdb.lookup_global_symbol('init_task')
task_list = init_task.value()['tasks']
runqueues = gdb.lookup_global_symbol('runqueues')
rqs = get_percpu_var(runqueues)
rqscurrs = {long(x["curr"]): k for (k, x) in rqs.items()}
self.pid_to_task_struct = {}
print("Loading tasks...", end='')
sys.stdout.flush()
task_count = 0
tasks = []
for taskg in list_for_each_entry(task_list,
init_task.type,
'tasks',
include_head=True):
tasks.append(taskg)
for task in list_for_each_entry(taskg['thread_group'],
init_task.type, 'thread_group'):
tasks.append(task)
for task in tasks:
cpu = None
regs = None
active = long(task.address) in rqscurrs
if active:
cpu = rqscurrs[long(task.address)]
regs = self.vmcore.attr.cpu[cpu].reg
ltask = LinuxTask(task, active, cpu, regs)
ptid = (LINUX_KERNEL_PID, task['pid'], 0)
try:
thread = gdb.selected_inferior().new_thread(ptid, ltask)
except gdb.error as e:
print("Failed to setup task @{:#x}".format(long(task.address)))
continue
thread.name = task['comm'].string()
self.target.arch.setup_thread_info(thread)
ltask.attach_thread(thread)
ltask.set_get_stack_pointer(self.target.arch.get_stack_pointer)
crash.cache.tasks.cache_task(ltask)
task_count += 1
if task_count % 100 == 0:
print(".", end='')
sys.stdout.flush()
print(" done. ({} tasks total)".format(task_count))
gdb.selected_inferior().executing = False
def children(self):
packed = gdb.lookup_global_symbol('HPHP::ArrayData::kPackedKind') \
.value()
mixed = gdb.lookup_global_symbol('HPHP::ArrayData::kMixedKind') \
.value()
# Only support kPackedKind or kMixedKind
if self.kind == packed or self.kind == mixed:
return self._iterator(self.kind,
self.val['m_data'],
self.val['m_data'] + self.val['m_size'])
return self._iterator(0, 0, 0)
def cpu_foreach():
all_cpus = gdb.lookup_global_symbol("all_cpus").value()
bitsz = gdb.lookup_type("long").sizeof * 8
maxid = gdb.lookup_global_symbol("mp_maxid").value()
cpu = 0
while cpu <= maxid:
upper = cpu >> int(math.log(bitsz, 2))
lower = 1 << (cpu & (bitsz - 1))
if (all_cpus['__bits'][upper] & lower) != 0:
yield cpu
cpu = cpu + 1
def children(self):
packed = gdb.lookup_global_symbol('HPHP::ArrayData::kPackedKind') \
.value()
mixed = gdb.lookup_global_symbol('HPHP::ArrayData::kMixedKind') \
.value()
# Only support kPackedKind or kMixedKind
if self.kind == packed or self.kind == mixed:
data = self.val.address.cast(gdb.lookup_type('char').pointer()) + \
self.val.type.sizeof
pelm = data.cast(gdb.lookup_type('HPHP::HphpArray::Elm').pointer())
return self._iterator(self.kind, pelm, pelm + self.val['m_size'])
return self._iterator(0, 0, 0)
def invoke_static(arg):
for func, arg_typ in DollarPrintFunction.dollar_functions:
if arg.type.name == arg_typ:
func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg)
if arg.type.name + " *" == arg_typ:
func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg.address)
raise ValueError("No suitable Nim $ operator found for type: " + arg.type.name)
def invoke_static(arg):
for func, arg_typ in DollarPrintFunction.dollar_functions:
if arg.type.name == arg_typ:
func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg)
if arg.type.name + " *" == arg_typ:
func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
return func_value(arg.address)
raise ValueError("No suitable Nim $ operator found for type: " + arg.type.name)
def all_traces():
# XXX: needed for GDB to see 'trace_page_size'
gdb.lookup_global_symbol('gdb_trace_function_entry')
inf = gdb.selected_inferior()
trace_log = gdb.lookup_global_symbol('trace_log').value()
if not trace_log:
return
max_trace = ulong(gdb.parse_and_eval('max_trace'))
trace_log = inf.read_memory(trace_log, max_trace)
trace_page_size = ulong(gdb.parse_and_eval('trace_page_size'))
last = ulong(gdb.lookup_global_symbol('trace_record_last').value()['_M_i'])
last %= max_trace
pivot = align_up(last, trace_page_size)
trace_log = concat(trace_log[pivot:], trace_log[:pivot])
last += max_trace - pivot
tp_ptr = gdb.lookup_type('tracepoint_base').pointer()
backtrace_len = ulong(gdb.parse_and_eval('tracepoint_base::backtrace_len'))
tracepoints = {}
i = 0
while i < last:
tp_key, = struct.unpack('Q', trace_log[i:i+8])
if tp_key == 0:
i = align_up(i + 8, trace_page_size)
continue
i += 8
thread, thread_name, time, cpu, flags = struct.unpack('Q16sQII', trace_log[i:i+40])
thread_name = thread_name.partition(b'\0')[0].decode()
i += 40
tp = tracepoints.get(tp_key, None)
if not tp:
tp_ref = gdb.Value(tp_key).cast(tp_ptr)
tp = TracePoint(tp_key, str(tp_ref["name"].string()),
sig_to_string(ulong(tp_ref['sig'])), str(tp_ref["format"].string()))
tracepoints[tp_key] = tp
backtrace = None
if flags & 1:
backtrace = struct.unpack('Q' * backtrace_len, trace_log[i:i+8*backtrace_len])
i += 8 * backtrace_len
size = struct.calcsize(tp.signature)
data = struct.unpack(tp.signature, trace_log[i:i+size])
i += size
i = align_up(i, 8)
yield Trace(tp, thread, thread_name, time, cpu, data, backtrace=backtrace)
def invoke(self, arg, for_tty):
c = str(gdb.lookup_global_symbol('callouts::_callouts').value())
callouts = re.findall('\[([0-9]+)\] = (0x[0-9a-zA-Z]+)', c)
gdb.write("%-5s%-40s%-40s%-30s%-10s\n" %
("id", "addr", "function", "abs time (ns)", "flags"))
# We have a valid callout frame
for desc in callouts:
id = int(desc[0])
addr = desc[1]
callout = gdb.parse_and_eval('(struct callout *)' + addr)
fname = callout['c_fn']
# time
t = int(callout['c_to_ns'])
# flags
CALLOUT_ACTIVE = 0x0002
CALLOUT_PENDING = 0x0004
CALLOUT_COMPLETED = 0x0020
f = int(callout['c_flags'])
flags = ("0x%04x " % f) + \
("A" if (callout['c_flags'] & CALLOUT_ACTIVE) else "") + \
("P" if (callout['c_flags'] & CALLOUT_PENDING) else "") + \
("C" if (callout['c_flags'] & CALLOUT_COMPLETED) else "")
# dispatch time ns ticks callout function
gdb.write("%-5d%-40s%-40s%-30s%-10s\n" %
(id, callout, fname, t, flags))
def __init__(self):
super(Slab, self).__init__("slab", gdb.COMMAND_USER)
self.per_cpu_offset = gdb.lookup_global_symbol(
"__per_cpu_offset").value()
self.memstart_addr = gdb.lookup_global_symbol("memstart_addr").value()
self.cache_alloc_bp = KmemCacheAlloc(self)
self.cache_free_bp = KmemCacheFree(self)
self.new_slab_bp = NewSlab(self)
self.discard_slab_bp = DiscardSlab(self)
self.trace_caches = []
self.break_caches = []
self.watch_caches = []
self.slabs_list = []
self.update_breakpoints()
def initialize(self):
self.d = {}
self.d['FRAMETYPE_MASK'] = (1 << self.jit_value('FRAMETYPE_BITS')) - 1
self.d['FRAMESIZE_SHIFT'] = self.jit_value('FRAMESIZE_SHIFT')
self.d['FRAME_HEADER_SIZE_SHIFT'] = self.jit_value('FRAME_HEADER_SIZE_SHIFT')
self.d['FRAME_HEADER_SIZE_MASK'] = self.jit_value('FRAME_HEADER_SIZE_MASK')
self.compute_frame_info()
commonFrameLayout = gdb.lookup_type('js::jit::CommonFrameLayout')
self.d['typeCommonFrameLayout'] = commonFrameLayout
self.d['typeCommonFrameLayoutPointer'] = commonFrameLayout.pointer()
self.d['per_tls_context'] = gdb.lookup_global_symbol('js::TlsContext')
self.d['void_starstar'] = gdb.lookup_type('void').pointer().pointer()
jitframe = gdb.lookup_type("js::jit::JitFrameLayout")
self.d['jitFrameLayoutPointer'] = jitframe.pointer()
self.d['CalleeToken_Function'] = self.jit_value("CalleeToken_Function")
self.d['CalleeToken_FunctionConstructing'] = self.jit_value(
"CalleeToken_FunctionConstructing")
self.d['CalleeToken_Script'] = self.jit_value("CalleeToken_Script")
self.d['JSFunction'] = gdb.lookup_type("JSFunction").pointer()
self.d['JSScript'] = gdb.lookup_type("JSScript").pointer()
self.d['Value'] = gdb.lookup_type("JS::Value")
self.d['SOURCE_SLOT'] = self.value('js::ScriptSourceObject::SOURCE_SLOT')
self.d['NativeObject'] = gdb.lookup_type("js::NativeObject").pointer()
self.d['HeapSlot'] = gdb.lookup_type("js::HeapSlot").pointer()
self.d['ScriptSource'] = gdb.lookup_type("js::ScriptSource").pointer()
# ProcessExecutableMemory, used to identify if a pc is in the section
# pre-allocated by the JIT.
self.d['MaxCodeBytesPerProcess'] = self.jit_value('MaxCodeBytesPerProcess')
self.d['execMemory'] = gdb.lookup_symbol('::execMemory')[0].value()
def get_current_location():
try:
frame = gdb.selected_frame()
sal = frame.find_sal()
symtab = sal.symtab
if symtab is not None:
filename = symtab.fullname()
else:
filename = None
lineno = sal.line
except gdb.error:
# FIXME: should use the static location as set by list etc.
# No frame - try 'main'.
try:
frame = None
sym = gdb.lookup_global_symbol('main')
lineno = sym.line
symtab = sym.symtab
filename = symtab.fullname()
except gdb.error:
# Perhaps no symbol file.
return (None, None, None, None)
except AttributeError:
return (None, None, None, None)
return (frame, symtab, filename, lineno)
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) > 1:
raise gdb.GdbError("load-trace-dwarf takes 0 or 1 argument.")
target_pc = ptr2uint(argv[0] if len(argv) == 1 else "$rip")
dbg_desc = gdb.lookup_global_symbol("__jit_debug_descriptor")
if not dbg_desc:
raise gdb.GdbError("__jit_debug_descriptor not found")
print("Scanning entries in __jit_debug_descriptor")
i = 0
entry = dbg_desc.value()["first_entry"]
try:
while (entry != 0x0):
i += 1
if self.find_and_load_trace_dwarf(target_pc, entry, i):
return
entry = entry["next_entry"]
except gdb.MemoryError:
print(("WARNING: "
"Traversal of __jit_debug_descriptor aborted "
"(memory access error)"))
print("{} entries scanned, nothing relevant found".format(str(i)))
def setup(fn_name):
fn_full_name = self.prefix + fn_name
print 'setting up breakpoint for', fn_full_name
on_enter_instance = on_enter(fn_name, fn_full_name)
# free() does not need a finishing breakpoint, because it returns a void
# without this the leak detector is unstable, because
# on some systems je_free() has a bunch of cross jumps somewhere:
# anight@dura3:~/projects/test> gdb --batch -ex 'disassemble je_free' ./a.out | grep jmpq | grep -v je_free
# 0x000000000040554c <+428>: jmpq 0x42aaa0 <je_tcache_event_hard>
# 0x00000000004055a3 <+515>: jmpq 0x40f0a0 <je_arena_dalloc_small>
# 0x000000000040564e <+686>: jmpq 0x421240 <je_huge_dalloc>
# 0x000000000040566a <+714>: jmpq 0x425aa0 <je_quarantine>
# 0x00000000004056cb <+811>: jmpq 0x40f2b0 <je_arena_dalloc_large>
#
# Luckily, this does not apply to all other memory functions
if fn_name == 'free':
return
arch = gdb.selected_frame().architecture()
sym = gdb.lookup_global_symbol(fn_full_name,
gdb.SYMBOL_FUNCTIONS_DOMAIN)
block = gdb.block_for_pc(long(sym.value().address))
ptr = block.start
while ptr < block.end:
da = arch.disassemble(ptr)[0]
if da['asm'].rstrip().endswith('retq'):
print 'setting up finish breakpoint for', da
on_result_ready_instance = on_result_ready(
on_enter_instance, '*0x%lx' % da['addr'])
ptr += da['length']
def symbol_address(symbol):
sym = gdb.lookup_global_symbol(symbol)
if sym == None:
sym = gdb.lookup_symbol(symbol)[0]
if sym is not None:
return sym.value().address
return None
def parse(cls, context):
"""
Try to parse the $-analysis.adb source file to extract mapping
information from its GDB helpers directives. Print error messages on
standard output if anything goes wrong, but always return a DebugInfo
instance anyway.
:rtype: DebugInfo
"""
result = cls(context)
# Look for the "$-analysis.adb" file using some symbol that is supposed
# to be defined there.
has_unit_sym = gdb.lookup_global_symbol(
'{}__analysis__implementation__is_null'.format(context.lib_name)
)
if not has_unit_sym:
return result
result.filename = has_unit_sym.symtab.fullname()
with open(result.filename, 'r') as f:
try:
cls._parse_file(result, f)
except ParseError as exc:
print('Error while parsing directives in {}:'.format(
result.filename
))
print(str(exc))
return result
def parse_from_gdb(cls, context: Context) -> DebugInfo:
"""
Try to parse the $-implementation.adb source file that GDB found.
This extracts mapping information from its GDB helpers directives.
Print error messages on standard output if anything goes wrong, but
always return a DebugInfo instance anyway.
"""
import gdb
result = cls(context)
# Look for the "$-implementation.adb" file using some symbol that is
# supposed to be defined there.
has_unit_sym = gdb.lookup_global_symbol(
'{}__implementation__is_null'.format(context.lib_name)
)
if not has_unit_sym:
return result
filename = has_unit_sym.symtab.fullname()
with open(filename, 'r') as f:
result._try_parse(filename, f)
return result
def initialize(self):
self.d = {}
self.d["FRAMETYPE_MASK"] = (1 << self.jit_value("FRAMETYPE_BITS")) - 1
self.d["FRAMESIZE_SHIFT"] = self.jit_value("FRAMESIZE_SHIFT")
self.d["FRAME_HEADER_SIZE_SHIFT"] = self.jit_value("FRAME_HEADER_SIZE_SHIFT")
self.d["FRAME_HEADER_SIZE_MASK"] = self.jit_value("FRAME_HEADER_SIZE_MASK")
self.compute_frame_info()
commonFrameLayout = gdb.lookup_type("js::jit::CommonFrameLayout")
self.d["typeCommonFrameLayout"] = commonFrameLayout
self.d["typeCommonFrameLayoutPointer"] = commonFrameLayout.pointer()
self.d["per_tls_context"] = gdb.lookup_global_symbol("js::TlsContext")
self.d["void_starstar"] = gdb.lookup_type("void").pointer().pointer()
jitframe = gdb.lookup_type("js::jit::JitFrameLayout")
self.d["jitFrameLayoutPointer"] = jitframe.pointer()
self.d["CalleeToken_Function"] = self.jit_value("CalleeToken_Function")
self.d["CalleeToken_FunctionConstructing"] = self.jit_value(
"CalleeToken_FunctionConstructing"
)
self.d["CalleeToken_Script"] = self.jit_value("CalleeToken_Script")
self.d["JSScript"] = gdb.lookup_type("JSScript").pointer()
self.d["Value"] = gdb.lookup_type("JS::Value")
self.d["SOURCE_SLOT"] = self.value("js::ScriptSourceObject::SOURCE_SLOT")
self.d["NativeObject"] = gdb.lookup_type("js::NativeObject").pointer()
self.d["HeapSlot"] = gdb.lookup_type("js::HeapSlot").pointer()
self.d["ScriptSource"] = gdb.lookup_type("js::ScriptSource").pointer()
# ProcessExecutableMemory, used to identify if a pc is in the section
# pre-allocated by the JIT.
self.d["MaxCodeBytesPerProcess"] = self.jit_value("MaxCodeBytesPerProcess")
self.d["execMemory"] = gdb.lookup_symbol("::execMemory")[0].value()
def to_string(self):
if not self.value:
return 'null'
if self.kind == 'primary':
empty_env = gdb.lookup_global_symbol(
self.context.implname('ast_envs__empty_env_record')
)
if self.value == empty_env.value().address:
return '<LexicalEnv empty>'
elif self.node:
return '<LexicalEnv (primary) for {}>'.format(self.node)
else:
return '<LexicalEnv root>'
elif self.kind == 'orphaned':
return '<LexicalEnv (orphaned)>'
elif self.kind == 'grouped':
return '<LexicalEnv (grouped)>'
elif self.kind == 'rebound':
return '<LexicalEnv (rebound)>'
else:
return '<LexicalEnv (corrupted)]'
def register_nim_pretty_printers_for_object(objfile):
nimMainSym = gdb.lookup_global_symbol("NimMain", gdb.SYMBOL_FUNCTIONS_DOMAIN)
if nimMainSym and nimMainSym.symtab.objfile == objfile:
print("set Nim pretty printers for ", objfile.filename)
objfile.type_printers = [NimTypePrinter()]
objfile.pretty_printers = [makematcher(var) for var in list(globals().values()) if hasattr(var, 'pattern')]
def initialize(self):
self.d = {}
self.d['FRAMETYPE_MASK'] = (1 << self.jit_value('FRAMETYPE_BITS')) - 1
self.d['FRAMESIZE_SHIFT'] = self.jit_value('FRAMESIZE_SHIFT')
self.d['FRAME_HEADER_SIZE_SHIFT'] = self.jit_value(
'FRAME_HEADER_SIZE_SHIFT')
self.d['FRAME_HEADER_SIZE_MASK'] = self.jit_value(
'FRAME_HEADER_SIZE_MASK')
self.compute_frame_info()
commonFrameLayout = gdb.lookup_type('js::jit::CommonFrameLayout')
self.d['typeCommonFrameLayout'] = commonFrameLayout
self.d['typeCommonFrameLayoutPointer'] = commonFrameLayout.pointer()
self.d['per_tls_context'] = gdb.lookup_global_symbol('js::TlsContext')
self.d['void_starstar'] = gdb.lookup_type('void').pointer().pointer()
self.d['mod_ExecutableAllocator'] = jsjitExecutableAllocatorCache()
jitframe = gdb.lookup_type("js::jit::JitFrameLayout")
self.d['jitFrameLayoutPointer'] = jitframe.pointer()
self.d['CalleeToken_Function'] = self.jit_value("CalleeToken_Function")
self.d['CalleeToken_FunctionConstructing'] = self.jit_value(
"CalleeToken_FunctionConstructing")
self.d['CalleeToken_Script'] = self.jit_value("CalleeToken_Script")
self.d['JSFunction'] = gdb.lookup_type("JSFunction").pointer()
self.d['JSScript'] = gdb.lookup_type("JSScript").pointer()
self.d['Value'] = gdb.lookup_type("JS::Value")
self.d['SOURCE_SLOT'] = self.value(
'js::ScriptSourceObject::SOURCE_SLOT')
self.d['NativeObject'] = gdb.lookup_type("js::NativeObject").pointer()
self.d['HeapSlot'] = gdb.lookup_type("js::HeapSlot").pointer()
self.d['ScriptSource'] = gdb.lookup_type("js::ScriptSource").pointer()
def iterator(self):
if HashTablePrinter.DELITEM is None:
HashTablePrinter.DELITEM = gdb.lookup_global_symbol('hash_deleted_item').value()
lst = self.val['ht_vec']
for i in xrange(0, self.val['ht_size']):
v = lst[i]
if long(v) != 0 and v != HashTablePrinter.DELITEM:
yield (i, v)
def getTCB(self): list_of_listsnames = ['g_pendingtasks','g_readytorun','g_waitingforsemaphore','g_waitingforsignal','g_inactivetasks'] tcb_list = []; for l in list_of_listsnames: li = gdb.lookup_global_symbol(l) cursor = li.value()['head'] tcb_list = tcb_list + self.find_tcb_list(cursor) return tcb_list
def get_block_tracepoints():
block_tracepoints = set()
for trace_point in intrusive_list(
gdb.lookup_global_symbol("tracepoint_base::tp_list").value()):
ended = get_name_of_ended_func(trace_point['name'].string())
if ended:
block_tracepoints.add(ended)
return block_tracepoints
def lookup_global_function(name):
res = gdb.lookup_global_symbol(name, gdb.SYMBOL_FUNCTIONS_DOMAIN)
if not res or not res.is_function:
raise RuntimeError("Function " + name +
" lookup failed. Please check README")
return res.value()
def setup_jiffies(cls, symbol):
if cls.jiffies_ready:
return
jiffies_sym = gdb.lookup_global_symbol('jiffies_64')
if jiffies_sym:
try:
jiffies = long(jiffies_sym.value())
except gdb.MemoryError:
return False
cls.adjust_jiffies = True
else:
jiffies = long(gdb.lookup_global_symbol('jiffies').value())
cls.adjust_jiffies = False
delayed = get_delayed_lookup(cls, 'jiffies').callback(jiffies)
def __init__(self, val):
self.val = val
match = self.pattern.match(self.val.type.name)
self.typeNimName = match.group(1)
typeInfoName = "NTI_" + match.group(2) + "_"
self.nti = gdb.lookup_global_symbol(typeInfoName)
if self.nti is None:
printErrorOnce(typeInfoName, "NimEnumPrinter: lookup global symbol '" + typeInfoName + " failed for " + self.val.type.name + ".\n")
def invoke(self, arg, from_tty):
reclaimer = gdb.lookup_global_symbol("memory::reclaimer_thread")
waiters = reclaimer.value()["_oom_blocked"]["_waiters"]
waiters_list = intrusive_list(waiters)
gdb.write('waiters:\n')
for w in waiters_list:
t = w["owner"].dereference().cast(thread_type)["_id"]
print(t)
gdb.write("Thread %d waits for %d Bytes\n" % (t, int(w["bytes"])))
def invoke(self, args, from_tty):
heap = gdb.lookup_global_symbol('g_mmheap').value()
nregions = heap['mm_nregions']
region_starts = heap['mm_heapstart']
region_ends = heap['mm_heapend']
print "{} heap(s)".format(nregions)
# walk the heaps
for i in range(0, nregions):
self._print_allocations(region_starts[i], region_ends[i])
