Rearrange as a utility class to allow patching XML

Author: elicn

qiling/debugger/gdb/gdb.py

@@ -28,7 +28,7 @@
 from qiling import Qiling
 from qiling.const import QL_ARCH, QL_ENDIAN, QL_OS
 from qiling.debugger import QlDebugger
-from qiling.debugger.gdb import xmlregs
+from qiling.debugger.gdb.xmlregs import QlGdbFeatures
 from qiling.debugger.gdb.utils import QlGdbUtils
 
 # gdb logging prompt
@@ -98,7 +98,8 @@ def __init__(self, ql: Qiling, ip: str = '127.0.01', port: int = 9999):
 
         self.gdb = QlGdbUtils(ql, entry_point, exit_point)
 
-        self.regsmap = xmlregs.load_regsmap(self.ql.arch.type)
+        self.features = QlGdbFeatures(self.ql.arch.type, self.ql.os.type)
+        self.regsmap = self.features.regsmap
 
     def run(self):
         server = GdbSerialConn(self.ip, self.port, self.ql.log)
@@ -451,22 +452,12 @@ def handle_q(subcmd: str) -> Reply:
                 offset, length = (int(p, 16) for p in params.split(','))
 
                 if feature == 'features' and op == 'read':
-                    xfercmd_abspath = os.path.dirname(os.path.abspath(__file__))
-                    xml_folder      = self.ql.arch.type.name.lower()
-                    xfercmd_file    = os.path.join(xfercmd_abspath, 'xml', xml_folder, annex)
-
-                    if self.ql.os.type == QL_OS.WINDOWS:
-                        self.ql.log.info(f'{PROMPT} Qiling does not support XML for this platform yet')
-                        content = ''
-
-                    elif not os.path.exists(xfercmd_file):
-                        self.ql.log.info(f'{PROMPT} XML file not found: "{xfercmd_file}"')
-                        content = ''
+                    if annex == r'target.xml':
+                        content = self.features.tostring()[offset:offset + length]
 
                     else:
-                        with open(xfercmd_file, 'r') as f:
-                            f.seek(offset, os.SEEK_SET)
-                            content = f.read(length)
+                        self.ql.log.info(f'{PROMPT} did not expect "{annex}" here')
+                        content = ''
 
                     return f'{"l" if len(content) < length else "m"}{content}'
 

qiling/debugger/gdb/xmlregs.py

@@ -5,14 +5,14 @@
 
 from typing import Iterator, Mapping, Optional, Sequence, Tuple
 from pathlib import PurePath
+from xml.etree import ElementTree, ElementInclude
 
 from qiling.arch.arm_const import reg_map as arm_regs
 from qiling.arch.arm_const import reg_vfp as arm_regs_vfp
 from qiling.arch.arm64_const import reg_map as arm64_regs
 from qiling.arch.arm64_const import reg_map_v as arm64_regs_v
 from qiling.arch.mips_const import reg_map as mips_regs_gpr
 from qiling.arch.mips_const import reg_map_fpu as mips_regs_fpu
-from qiling.arch.x86_const import reg_map_16 as x86_regs_16
 from qiling.arch.x86_const import reg_map_32 as x86_regs_32
 from qiling.arch.x86_const import reg_map_64 as x86_regs_64
 from qiling.arch.x86_const import reg_map_misc as x86_regs_misc
@@ -21,92 +21,130 @@
 from qiling.arch.x86_const import reg_map_xmm as x86_regs_xmm
 from qiling.arch.x86_const import reg_map_ymm as x86_regs_ymm
 
-from qiling.const import QL_ARCH
+from qiling.const import QL_ARCH, QL_OS
 
 RegEntry = Tuple[Optional[int], int, int]
 
-# define a local dummy function to let us reference this module
-__anchor__ = lambda x: x
+class QlGdbFeatures:
+    def __init__(self, archtype: QL_ARCH, ostype: QL_OS):
+        xmltree = QlGdbFeatures.__load_target_xml(archtype, ostype)
+        regsmap = QlGdbFeatures.__load_regsmap(archtype, xmltree)
 
-def __get_xml_path(archtype: QL_ARCH) -> Tuple[str, PurePath]:
-    import inspect
+        self.xmltree = xmltree
+        self.regsmap = regsmap
 
-    p = PurePath(inspect.getfile(__anchor__))
-    basedir = p.parent / 'xml' / archtype.name.lower()
-    filename = basedir / 'target.xml'
+    def tostring(self) -> str:
+        root = self.xmltree.getroot()
 
-    return str(filename), basedir
+        return ElementTree.tostring(root, encoding='unicode', xml_declaration=True)
 
-def __walk_xml_regs(filename: str, base_url: PurePath) -> Iterator[Tuple[int, str, int]]:
-    from xml.etree import ElementTree, ElementInclude
+    @staticmethod
+    def __get_xml_path(archtype: QL_ARCH) -> Tuple[str, PurePath]:
+        import inspect
 
-    tree = ElementTree.parse(filename)
-    root = tree.getroot()
+        p = PurePath(inspect.getfile(QlGdbFeatures))
+        basedir = p.parent / 'xml' / archtype.name.lower()
+        filename = basedir / 'target.xml'
 
-    # NOTE: this is needed to load xinclude hrefs relative to the main xml file. starting
-    # from python 3.9 ElementInclude.include has an argument for that called 'base_url'.
-    # this is a workaround for earlier python versions such as 3.8
+        return str(filename), basedir
 
-    def my_loader(base: PurePath):
-        def __wrapped(href: str, parse, encoding=None):
-            abshref = base / href
+    @staticmethod
+    def __load_target_xml(archtype: QL_ARCH, ostype: QL_OS) -> ElementTree.ElementTree:
+        filename, base_url = QlGdbFeatures.__get_xml_path(archtype)
 
-            return ElementInclude.default_loader(str(abshref), parse, encoding)
+        tree = ElementTree.parse(filename)
 
-        return __wrapped
+        # NOTE: this is needed to load xinclude hrefs relative to the main xml file. starting
+        # from python 3.9 ElementInclude.include has an argument for that called 'base_url'.
+        # this is a workaround for earlier python versions such as 3.8
 
-    ElementInclude.include(root, loader=my_loader(base_url))
+        # <WORKAROUND>
+        def my_loader(base: PurePath):
+            def __wrapped(href: str, parse, encoding=None):
+                abshref = base / href
 
-    regnum = -1
+                return ElementInclude.default_loader(str(abshref), parse, encoding)
 
-    for reg in root.iter('reg'):
-        # if regnum is not specified, assume it follows the previous one
-        regnum = int(reg.get('regnum', regnum + 1))
+            return __wrapped
+        # </WORKAROUND>
 
-        name = reg.attrib['name']
-        bitsize = reg.attrib['bitsize']
+        # inline all xi:include elements
+        ElementInclude.include(tree.getroot(), loader=my_loader(base_url))
 
-        yield regnum, name, int(bitsize)
+        # patch xml osabi element with the appropriate abi tag
+        osabi = tree.find('osabi')
 
-def load_regsmap(archtype: QL_ARCH) -> Sequence[RegEntry]:
-    """Initialize registers map using available target XML files.
+        if osabi is not None:
+            # NOTE: the 'Windows' abi tag is supported starting from gdb 10.
+            # earlier gdb versions use 'Cygwin' instead
 
-    Args:
-        archtype: target architecture type
+            abitag = {
+                QL_OS.LINUX   : 'GNU/Linux',
+                QL_OS.FREEBSD : 'FreeBSD',
+                QL_OS.MACOS   : 'Darwin',
+                QL_OS.WINDOWS : 'Windows',
+                QL_OS.UEFI    : 'Windows',
+                QL_OS.DOS     : 'Windows',
+                QL_OS.QNX     : 'QNX-Neutrino'
+            }.get(ostype, 'unknown')
 
-    Returns: a list representing registers data
-    """
+            osabi.text = abitag
 
-    # retreive the relevant set of registers; their order of appearance is not
-    # important as it is determined by the info read from the xml files
-    ucregs: Mapping[str, int] = {
-        QL_ARCH.A8086    : dict(**x86_regs_32, **x86_regs_misc, **x86_regs_cr, **x86_regs_st),
-        QL_ARCH.X86      : dict(**x86_regs_32, **x86_regs_misc, **x86_regs_cr, **x86_regs_st, **x86_regs_xmm),
-        QL_ARCH.X8664    : dict(**x86_regs_64, **x86_regs_misc, **x86_regs_cr, **x86_regs_st, **x86_regs_xmm, **x86_regs_ymm),
-        QL_ARCH.ARM      : dict(**arm_regs, **arm_regs_vfp),
-        QL_ARCH.CORTEX_M : arm_regs,
-        QL_ARCH.ARM64    : dict(**arm64_regs, **arm64_regs_v),
-        QL_ARCH.MIPS     : dict(**mips_regs_gpr, **mips_regs_fpu)
-    }[archtype]
+        return tree
 
-    xmlpath = __get_xml_path(archtype)
-    regsinfo = sorted(__walk_xml_regs(*xmlpath))
+    @staticmethod
+    def __walk_xml_regs(xmltree: ElementTree.ElementTree) -> Iterator[Tuple[int, str, int]]:
+        regnum = -1
 
-    # pre-allocate regmap and occupy it with null entries
-    last_regnum = regsinfo[-1][0]
-    regmap: Sequence[RegEntry] = [(None, 0, 0)] * (last_regnum + 1)
+        for reg in xmltree.iter('reg'):
+            # if regnum is not specified, assume it follows the previous one
+            regnum = int(reg.get('regnum', regnum + 1))
 
-    pos = 0
+            name = reg.attrib['name']
+            bitsize = reg.attrib['bitsize']
 
-    for regnum, name, bitsize in sorted(regsinfo):
-        # reg value size in nibbles
-        nibbles = bitsize // 4
+            yield regnum, name, int(bitsize)
 
-        regmap[regnum] = (ucregs.get(name), pos, nibbles)
+    @staticmethod
+    def __load_regsmap(archtype: QL_ARCH, xmltree: ElementTree.ElementTree) -> Sequence[RegEntry]:
+        """Initialize registers map using available target XML files.
 
-        # value position of next reg
-        pos += nibbles
+        Args:
+            archtype: target architecture type
 
-    return regmap
+        Returns: a list representing registers data
+        """
 
-__all__ = ['RegEntry', 'load_regsmap']
+        # retreive the relevant set of registers; their order of appearance is not
+        # important as it is determined by the info read from the xml files
+        ucregs: Mapping[str, int] = {
+            QL_ARCH.A8086    : dict(**x86_regs_32, **x86_regs_misc, **x86_regs_cr, **x86_regs_st),
+            QL_ARCH.X86      : dict(**x86_regs_32, **x86_regs_misc, **x86_regs_cr, **x86_regs_st, **x86_regs_xmm),
+            QL_ARCH.X8664    : dict(**x86_regs_64, **x86_regs_misc, **x86_regs_cr, **x86_regs_st, **x86_regs_xmm, **x86_regs_ymm),
+            QL_ARCH.ARM      : dict(**arm_regs, **arm_regs_vfp),
+            QL_ARCH.CORTEX_M : arm_regs,
+            QL_ARCH.ARM64    : dict(**arm64_regs, **arm64_regs_v),
+            QL_ARCH.MIPS     : dict(**mips_regs_gpr, **mips_regs_fpu)
+        }[archtype]
+
+        regsinfo = sorted(QlGdbFeatures.__walk_xml_regs(xmltree))
+
+        # pre-allocate regmap and occupy it with null entries
+        last_regnum = regsinfo[-1][0]
+        regmap: Sequence[RegEntry] = [(None, 0, 0)] * (last_regnum + 1)
+
+        pos = 0
+
+        for regnum, name, bitsize in sorted(regsinfo):
+            # reg value size in nibbles
+            nibbles = bitsize // 4
+
+            regmap[regnum] = (ucregs.get(name), pos, nibbles)
+
+            # value position of next reg
+            pos += nibbles
+
+        return regmap
+
+
+__all__ = ['RegEntry', 'QlGdbFeatures']