def iter_def(self, inpipe): if not inpipe: yield from (as_voidptr(gdb.Value(ele)) for ele in self.called_funcs_class.hypothetical_stack) return for _ in inpipe: yield from (as_voidptr(gdb.Value(ele)) for ele in self.called_funcs_class.hypothetical_stack)
def iter_def(self, inpipe): for symbol in search_symbols(self.func_regexp, self.file_regexp, self.include_dynlibs): # TODO For some very strange reason, assigning a symbol.value() # this to a convenience variable ends up with the convenience # variable set to NULL. # Hence passing this across as a voidptr. yield as_voidptr(symbol.value())
def iter_def(self, inpipe): if not inpipe: self.__add_addr(eval_uint(self.start_expr), 0) yield from self.__iter_helper() return # Deal with each given function (and all their descendants) in turn. for element in inpipe: type(self).hypothetical_stack = [] self.__add_addr( int(as_voidptr(self.eval_command(element, self.start_expr))), 0) yield from self.__iter_helper()
def __iter_helper(self): ''' Iterate over all instructions in a function, put each `call` instruction on a stack. Continue until no more functions are found, or until `maxdepth` is exceeded. Skip any recursion by ignoring any functions already in the hypothetical stack we have built up. ''' while self.func_stack: func_addr, depth = self.func_stack.pop() if self.maxdepth >= 0 and depth > self.maxdepth: continue # If func_dis is None no debugging info was found for this function # and the user required filtering by filename (which we don't know # without debugging info) -- hence ignore this. func_dis, _, fname = function_disassembly(func_addr, self.arch, self.dont_fallback) if not func_dis or not re.match(self.file_regexp, '' if not fname else fname): continue # Store the current value in the hypothetical_stack for someone # else to query - remember to set the class attribute. type(self).hypothetical_stack[depth:] = [func_addr] yield as_voidptr(gdb.Value(func_addr)) # Go backwards through the list so that we pop off elements in the # order they will be called. for val in func_dis[::-1]: new_addr = self.__func_addr(val) self.__add_addr(new_addr, depth + 1)
def iter_helper(self, start, end, count): start, end, count = (int(as_voidptr(x)) for x in (start, end, count)) for instruction in self.disass(start, end, count): temp = gdb.Value(instruction['addr']) yield as_voidptr(temp)
def iter_def(self, inpipe): for filename in self.filenames: with open(filename, 'r') as infile: for line in infile: yield as_voidptr(gdb.Value(int(line, base=16)))