From 9e6cf99c62f5754db6ed10715678ede8db608f27 Mon Sep 17 00:00:00 2001
From: pompolic <pompolic@special-circumstanc.es>
Date: Wed, 27 Apr 2022 20:09:34 +0200
Subject: [PATCH] Remove TopLevelParse from parser-name-instrumentation
It has been moved to top-level-parse.py
---
gdb-port/parser-name-instrumentation-gdb.py | 171 --------------------
1 file changed, 171 deletions(-)
diff --git a/gdb-port/parser-name-instrumentation-gdb.py b/gdb-port/parser-name-instrumentation-gdb.py
index 95bcbcb..c142441 100644
--- a/gdb-port/parser-name-instrumentation-gdb.py
+++ b/gdb-port/parser-name-instrumentation-gdb.py
@@ -126,177 +126,6 @@ class ParserStack:
# This corresponds to the ParserStack above. TopLevelParse keeps track of all these.
# Subsequent h_do_parse()s with the same parser state are considered to belong to the same parse
-class TopLevelParse:
- def __init__(self):
- self.parser_stacks = []
- self.parser_objs = {}
- self.unclaimed_mem_use = 0
- # Holds 32 characters starting at state->input_stream[index], used by the GUI
- self.current_input_chunk = ''
- self.current_parser_env = ''
- # We save/push in perform_lowlevel_parse, but this is used to display them ahead of time
- self.h_do_parse_parser = None
- self.vt_types = None
- self.parser_decombinator = None
-
- def init_parser(self):
- self.vt_types = VTTypes()
- self.parser_decombinator = ParserDecombinator(self.vt_types)
-
- # Called from h_packrat_parse()'s handler, where the parse state and arena get initialized
- def enter_h_packrat_parse(self, parser):
- # TODO: add a parser stack or something?
- parser_stack = ParserStack(None, None)
- self.parser_stacks.append(parser_stack)
- return 0
-
- # TODO: arena parameter is useless
- def enter_h_do_parse(self, parse_state, arena, parser):
- parser_stack = self.peek_parserstack()
- try:
- parser_obj = self.parser_objs[parser]
- except KeyError:
- parser_obj = Parser(None, parser)
- self.parser_objs[parser] = parser_obj
- self.h_do_parse_parser = parser_obj # TODO: current_parser_env should be set here instead too
- if parser_stack.parse_state is None and parser_stack.parse_state != parse_state:
- self.first_h_do_parse_after_packrat_parse(parse_state, arena)
-
- # Called from h_do_parse()'s handler, at which point we know the addresses of the state and arena
- def first_h_do_parse_after_packrat_parse(self, parse_state, arena):
- parser_stack = self.peek_parserstack()
- parser_stack.set_state(parse_state)
-
- # Popping the stack of stack of parsers
- def return_from_h_packrat_parse(self):
- old_stack = self.parser_stacks.pop()
- if old_stack.depth() > 0:
- print("Warning: parser stack not empty but parse is successful?")
-
- # Memoize the parser object for this particular address, then push it on the stack
- # Returns the parser object we just initalized (or the one already existing)
- #TODO: memoize_parser method
- def enter_perform_lowlevel_parse(self, parser_addr):
- try:
- parser_obj = self.parser_objs[parser_addr]
- except KeyError:
- # Create a parser object with no name and the address of the parser
- parser_obj = Parser(None, parser_addr)
- self.parser_objs[parser_addr] = parser_obj
-
- parser_stack = self.peek_parserstack()
- parser_stack.push(parser_obj)
- if self.parser_decombinator:
- p_env = self.parser_decombinator.decompose_parser(parser_obj, self)
- self.set_parser_env(type(p_env).__name__ + " - " + str(p_env)) # TODO: pass this as data structure to frontend
- return parser_obj
-
- def return_from_perform_lowlevel_parse(self):
- parser_stack = self.peek_parserstack()
- parser_obj = parser_stack.pop()
- # debug print here
-
- def enter_h_arena_malloc_raw(self, alloc_size):
- parser_obj = self.peek_parser()
- parser_stack = self.peek_parserstack()
- # This is probably the slowest part of the code, or maybe the overhead adds up over many calls to h_arena_malloc_raw()
- if parser_obj is not None:
- # Caveat: parser_stack is assumed not to be None if we could get a parser_obj
- parser_obj.add_mem_use(parser_stack.parse_state, alloc_size)
- elif parser_stack is not None:
- #print("Allocation of " + str(alloc_size) + " bytes without a parser on the stack. (Happens before first call perform_lowlevel_parse to or after return from that call)")
- parser_stack.unclaimed_mem_use += alloc_size
- else:
- #print("Allocation of " + str(alloc_size) + " bytes without a parser stack. (This happens before and after parse)")
- self.unclaimed_mem_use += alloc_size
-
- def parse_virtual(self, parser_name):
- parser_obj = self.peek_parser()
- if parser_obj.name is None:
- parser_obj.name_parser(parser_name)
- #else:
- #print("Warning: parser already named! This is a bug. old name: %s, new name: %s" % (parser_obj.name, parser_name))
-
- def peek_parserstack(self):
- try:
- retval = self.parser_stacks[-1]
- except IndexError:
- retval = None
- return retval
-
- def peek_parser(self):
- try:
- retval = self.peek_parserstack().peek()
- except AttributeError:
- # print("Parser stack of stacks empty!")
- retval = None
-
- # retval will also be None when parser stack is empty (while parser stack of stacks isn't)
- return retval
-
- def parser_by_address(self, parser_addr):
- try:
- return self.parser_objs[int(parser_addr)]
- except KeyError:
- print("Parser with address " + str(hex(parser_addr)) + " not found!")
-
- def parsers_by_name(self, parser_name):
- results = [v for k,v in self.parser_objs.items() if v.name == parser_name]
- if len(results) > 0:
- return results
- else:
- return None
-
- def set_input_chunk(self, chunk):
- self.input_chunk = chunk
-
- def get_input_chunk(self):
- return self.input_chunk
-
- def set_parser_env(self, parser_env):
- self.current_parser_env = parser_env
-
- def get_parser_env(self):
- return self.current_parser_env
-
- def add_or_get_parser(self, parser_addr):
- try:
- parser_obj = self.parser_objs[int(parser_addr)]
- except KeyError:
- # Create a parser object with no name and the address of the parser
- parser_obj = Parser(None, int(parser_addr))
- self.parser_objs[int(parser_addr)] = parser_obj
-
- return parser_obj
-
- def get_parser_top_per_arena_mem(self):
- return sorted(self.parser_objs.values(), key=Parser.get_arenamax, reverse=True)[0]
-
- def get_parser_top_total_arena_mem(self):
- return sorted(self.parser_objs.values(), key=Parser.get_arenasum, reverse=True)[0]
-
- def get_avg_mem_use_per_arena(self):
- avg_mem_use = {}
- arena_counts = {}
- # Accumulate byte counts and counts of parsers using that arena
- for p in self.parser_objs.values():
- for arena,mem in p.bytes_used.items():
- if arena in arena_counts.keys():
- arena_counts[arena] += 1
- else:
- arena_counts[arena] = 1
-
- if arena in avg_mem_use.keys():
- avg_mem_use[arena] += mem
- else:
- avg_mem_use[arena] = mem
-
- averages = {arena: mem/arena_counts[arena] for arena,mem in avg_mem_use.items()}
-
- return averages
-
- # TODO: get_avg_mem_use_all_arenas, get_total_mem_use
-
print(": Initializing TopLevelParse")
top_level_parse = TopLevelParse()
# Approach 1: load the application, set breakpoints, execute stack commands on breakpoint hit, continue
--
GitLab