move marking-related function into a class Marker

Author: ucgJhe

qiling/debugger/qdb/misc.py

@@ -3,7 +3,7 @@
 # Cross Platform and Multi Architecture Advanced Binary Emulation Framework
 #
 
-from typing import Callable, Optional
+from typing import AnyStr, Callable, Optional
 
 import ast
 
@@ -50,17 +50,27 @@ def read_int(s: str) -> int:
     return int(s, 0)
 
 
+def try_read_int(s: AnyStr) -> Optional[int]:
+    """
+    try to read string as integer is possible
+    """
+    try:
+        ret = read_int(s)
+    except:
+        ret = None
+
+    return ret
+
+
 def parse_int(func: Callable) -> Callable:
     """
     function dectorator for parsing argument as integer
     """
     def wrap(qdb, s: str = "") -> int:
         assert type(s) is str
-        try:
-            ret = read_int(s)
-        except:
-            ret = None
+        ret = try_read_int(s)
         return func(qdb, ret)
+
     return wrap
 
 

qiling/debugger/qdb/qdb.py

@@ -11,9 +11,9 @@
 from qiling.const import QL_OS, QL_ARCH, QL_VERBOSE
 from qiling.debugger import QlDebugger
 
-from .utils import setup_context_render, setup_branch_predictor, SnapshotManager, run_qdb_script
+from .utils import setup_context_render, setup_branch_predictor, setup_address_marker, SnapshotManager, run_qdb_script
 from .memory import setup_memory_Manager
-from .misc import parse_int, Breakpoint, TempBreakpoint
+from .misc import parse_int, Breakpoint, TempBreakpoint, try_read_int
 from .const import color
 
 from .utils import QDB_MSG, qdb_print
@@ -34,7 +34,7 @@ def __init__(self, ql: Qiling, init_hook: str = "", rr: bool = False, script: st
         self._saved_reg_dump = None
         self._script = script
         self.bp_list = {}
-        self.mark_list = {}
+        self.marker = setup_address_marker()
 
         self.rr = SnapshotManager(ql) if rr else None
         self.mm = setup_memory_Manager(ql)
@@ -352,54 +352,60 @@ def do_context(self, *args) -> None:
         self.render.context_stack()
         self.render.context_asm()
 
-    def do_jump(self, address, *args) -> None:
+    def do_jump(self, loc: str, *args) -> None:
         """
         seek to where ever valid location you want
         """
 
-        symbol, addr = None, None
-        try:
-            addr = int(address, 0)
-        except:
-            symbol = address
-
-        if symbol:
-            addr = self.mark_list.get(symbol, None)
+        sym = self.marker.get_symbol(loc)
+        addr = sym if sym is not None else try_read_int(loc)
 
+        # check validation of the address to be seeked
         if self.ql.mem.is_mapped(addr, 4):
-            qdb_print(QDB_MSG.INFO, f"seek to 0x{addr:08x} ...")
+            if sym:
+                qdb_print(QDB_MSG.INFO, f"seek to {loc} @ 0x{addr:08x} ...")
+            else:
+                qdb_print(QDB_MSG.INFO, f"seek to 0x{addr:08x} ...")
+
             self.cur_addr = addr
             self.do_context()
 
         else:
             qdb_print(QDB_MSG.ERROR, f"the address to be seeked isn't mapped")
 
-    def do_mark(self, args):
+    def do_mark(self, args=""):
         """
         mark a user specified address as a symbol
         """
 
         args = args.split()
-        if len(args) == 1:
-            try:
-                tmp = int(args[0], 0)
-            except:
-                tmp = args[0]
-
-            if type(tmp) is str:
-                symbol = tmp
-            else:
-                address = tmp
+        if len(args) == 0:
+            loc = self.cur_addr
+            sym_name = self.marker.mark_only_loc(loc)
 
-        else:
-            symbol, address = args
+        elif len(args) == 1:
+            if (loc := try_read_int(args[0])):
+                sym_name = self.marker.mark_only_loc(loc)
 
-        if symbol:
-            addr = self.cur_addr if address is None else int(address, 0)
-            self.mark_list.update({symbol: addr})
-            qdb_print(QDB_MSG.INFO, f"mark symbol '{symbol}' at address: 0x{addr:08x} ...")
+            else:
+                loc = self.cur_addr
+                sym_name = args[0]
+                if (err := self.marker.mark(sym_name, loc)):
+                    qdb_print(QDB_MSG.ERROR, err)
+                    return
+
+        elif len(args) == 2:
+            sym_name, addr = args
+            if (loc := try_read_int(addr)):
+                self.marker.mark(sym_name, loc)
+            else:
+                qdb_print(QDB_MSG.ERROR, f"unable to mark symbol at address: '{addr}'")
+                return
         else:
             qdb_print(QDB_MSG.ERROR, "symbol should not be empty ...")
+            return
+
+        qdb_print(QDB_MSG.INFO, f"mark symbol '{sym_name}' at address: 0x{loc:08x} ...")
 
     def do_show(self, *args) -> None:
         """
@@ -410,7 +416,7 @@ def do_show(self, *args) -> None:
             self.ql.log.info(info_line)
 
         qdb_print(QDB_MSG.INFO, f"Breakpoints: {[hex(addr) for addr in self.bp_list.keys()]}")
-        qdb_print(QDB_MSG.INFO, f"Marked symbol: {[{key:hex(val)} for key,val in self.mark_list.items()]}")
+        qdb_print(QDB_MSG.INFO, f"Marked symbol: {[{key:hex(val)} for key,val in self.marker.mark_list]}")
         if self.rr:
             qdb_print(QDB_MSG.INFO, f"Snapshots: {len([st for st in self.rr.layers if isinstance(st, self.rr.DiffedState)])}")
 

qiling/debugger/qdb/utils.py

@@ -12,7 +12,6 @@
 from qiling.const import QL_ARCH
 
 from .context import Context
-from .misc import read_int
 
 from .render import (
         ContextRenderX86,
@@ -51,6 +50,52 @@ def print_info(msg):
     print(color_coated)
 
 
+def setup_address_marker():
+
+    class Marker:
+        def __init__(self):
+            self._mark_list = {}
+
+        def get_symbol(self, sym):
+            return self._mark_list.get(sym, None)
+
+        @property
+        def mark_list(self):
+            return self._mark_list.items()
+
+        def gen_sym_name(self):
+            """
+            generating symbol name automatically
+            """
+
+            sym_name, idx = "sym0", 0
+            while sym_name in self._mark_list:
+                idx += 1
+                sym_name = f"sym{idx}"
+
+            return sym_name
+
+        def mark_only_loc(self, loc):
+            """
+            mark when location provided only
+            """
+
+            sym_name = self.gen_sym_name()
+            self.mark(sym_name, loc)
+            return sym_name
+
+        def mark(self, sym: str, loc: int):
+            """
+            mark loc as sym
+            """
+
+            if sym not in self.mark_list:
+                self._mark_list.update({sym: loc})
+            else:
+                return f"dumplicated symbol name: {sym} at address: 0x{loc:08x}"
+
+    return Marker()
+
 """
 
     helper functions for setting proper branch predictor and context render depending on different arch