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 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 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])