[mirror_edk2.git] / ArmPlatformPkg / Scripts / Ds5 / edk2_debugger.py

#\r
#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.\r
#\r
#  SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
\r
import os\r
\r
import firmware_volume\r
import build_report\r
import system_table\r
\r
# Reload external classes\r
reload(firmware_volume)\r
reload(build_report)\r
reload(system_table)\r
\r
def readMem32(executionContext, address):\r
    bytes = executionContext.getMemoryService().read(address, 4, 32)\r
    return struct.unpack('<I',bytes)[0]\r
\r
def dump_fv(ec, fv_base, fv_size):\r
    fv = firmware_volume.FirmwareVolume(ec,\r
                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),\r
                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))\r
\r
    ffs = fv.get_next_ffs()\r
    while ffs != None:\r
        print "# %s" % ffs\r
\r
        section = ffs.get_next_section()\r
        while section != None:\r
            print "\t%s" % section\r
            try:\r
                print "\t\t- %s" % section.get_debug_filepath()\r
            except Exception:\r
                pass\r
            section = ffs.get_next_section(section)\r
\r
        ffs = fv.get_next_ffs(ffs)\r
\r
def dump_system_table(ec, mem_base, mem_size):\r
    st = system_table.SystemTable(ec, mem_base, mem_size)\r
\r
    debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
\r
    debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)\r
    debug_info_table.dump()\r
\r
def load_symbol_from_file(ec, filename, address, verbose = False):\r
    if verbose:\r
        print "Add symbols of %s at 0x%x" % (filename, address)\r
\r
    try:\r
        ec.getImageService().addSymbols(filename, address)\r
    except:\r
        try:\r
            # We could get an exception if the symbols are already loaded\r
            ec.getImageService().unloadSymbols(filename)\r
            ec.getImageService().addSymbols(filename, address)\r
        except:\r
            print "Warning: not possible to load symbols from %s at 0x%x" % (filename, address)\r
\r
def is_aarch64(ec):\r
    success = True\r
    try:\r
        # Try to access a Aarch64 specific register\r
        ec.getRegisterService().getValue('X0')\r
    except:\r
        success = False\r
    return success\r
\r
class ArmPlatform:\r
    def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):\r
        self.sysmembase = sysmembase\r
        self.sysmemsize = sysmemsize\r
        self.fvs = fvs\r
\r
class ArmPlatformDebugger:\r
    system_table = None\r
    firmware_volumes = {}\r
\r
    REGION_TYPE_SYSMEM = 1\r
    REGION_TYPE_ROM    = 2\r
    REGION_TYPE_FV     = 3\r
\r
    def __init__(self, ec, report_log, regions, verbose = False):\r
        self.ec = ec\r
        self.verbose = verbose\r
        fvs = []\r
        sysmem_base = None\r
        sysmem_size = None\r
\r
        if report_log and os.path.isfile(report_log):\r
            try:\r
                self.build = build_report.BuildReport(report_log)\r
            except IOError:\r
                raise IOError(2, 'Report \'%s\' is not valid' % report_log)\r
\r
            # Generate list of supported Firmware Volumes\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))\r
\r
            sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)\r
            sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)\r
        else:\r
            for region in regions:\r
                if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:\r
                    sysmem_base = region[1]\r
                    sysmem_size = region[2]\r
                elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:\r
                    fvs.append((region[1],region[2]))\r
                elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:\r
                    for base in xrange(region[1], region[1] + region[2], 0x400000):\r
                        signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))\r
                        if signature == FirmwareVolume.CONST_FV_SIGNATURE:\r
                            fvs.append((base,0))\r
                else:\r
                    print "Region type '%d' Not Supported" % region[0]\r
\r
        self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)\r
\r
    def in_sysmem(self, addr):\r
        return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)\r
\r
    def in_fv(self, addr):\r
        return (self.get_fv_at(addr) != None)\r
\r
    def get_fv_at(self, addr):\r
        for fv in self.platform.fvs:\r
            if (fv[0] <= addr) and (addr < fv[0] + fv[1]):\r
                return fv\r
        return None\r
\r
    def load_current_symbols(self):\r
        pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
        if self.in_fv(pc):\r
            debug_infos = []\r
\r
            (fv_base, fv_size) = self.get_fv_at(pc)\r
\r
            if self.firmware_volumes.has_key(fv_base) == False:\r
                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
\r
            stack_frame = self.ec.getTopLevelStackFrame()\r
            info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
            debug_infos.append(info)\r
            while stack_frame.next() is not None:\r
                stack_frame = stack_frame.next()\r
\r
                # Stack frame attached to 'PC'\r
                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
\r
                # Check if the symbols for this stack frame have already been loaded\r
                found = False\r
                for debug_info in debug_infos:\r
                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
                        found = True\r
                if found == False:\r
                    info = self.firmware_volumes[fv_base].load_symbols_at(pc)\r
                    debug_infos.append(info)\r
\r
            #self.firmware_volumes[fv_base].load_symbols_at(pc)\r
        elif self.in_sysmem(pc):\r
            debug_infos = []\r
\r
            if self.system_table is None:\r
                # Find the System Table\r
                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
\r
                # Find the Debug Info Table\r
                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
\r
            stack_frame = self.ec.getTopLevelStackFrame()\r
            info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
            debug_infos.append(info)\r
            while stack_frame.next() is not None:\r
                stack_frame = stack_frame.next()\r
\r
                # Stack frame attached to 'PC'\r
                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
\r
                # Check if the symbols for this stack frame have already been loaded\r
                found = False\r
                for debug_info in debug_infos:\r
                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
                        found = True\r
                if found == False:\r
                    try:\r
                        info = self.debug_info_table.load_symbols_at(pc)\r
                        debug_infos.append(info)\r
                    except:\r
                        pass\r
\r
            #self.debug_info_table.load_symbols_at(pc)\r
        else:\r
            raise Exception('ArmPlatformDebugger', "Not supported region")\r
\r
    def load_all_symbols(self):\r
        # Load all the XIP symbols attached to the Firmware Volume\r
        for (fv_base, fv_size) in self.platform.fvs:\r
            if self.firmware_volumes.has_key(fv_base) == False:\r
                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
            self.firmware_volumes[fv_base].load_all_symbols(self.verbose)\r
\r
        try:\r
            # Load all symbols of module loaded into System Memory\r
            if self.system_table is None:\r
                # Find the System Table\r
                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
\r
\r
                # Find the Debug Info Table\r
                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
\r
            self.debug_info_table.load_all_symbols(self.verbose)\r
        except:\r
            # Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet\r
            print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has not been installed yet)"\r
Commit	Line	Data
1e57a462	1	#\r
72efe027	2	# Copyright (c) 2011-2013, ARM Limited. All rights reserved.\r
1e57a462	3	#\r
f4dfad05	4	# SPDX-License-Identifier: BSD-2-Clause-Patent\r
1e57a462	5	#\r
	6	\r
	7	import os\r
	8	\r
	9	import firmware_volume\r
	10	import build_report\r
	11	import system_table\r
	12	\r
	13	# Reload external classes\r
	14	reload(firmware_volume)\r
	15	reload(build_report)\r
	16	reload(system_table)\r
	17	\r
	18	def readMem32(executionContext, address):\r
	19	bytes = executionContext.getMemoryService().read(address, 4, 32)\r
	20	return struct.unpack('<I',bytes)[0]\r
	21	\r
	22	def dump_fv(ec, fv_base, fv_size):\r
	23	fv = firmware_volume.FirmwareVolume(ec,\r
	24	int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),\r
	25	int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))\r
3402aac7	26	\r
1e57a462	27	ffs = fv.get_next_ffs()\r
3402aac7	28	while ffs != None:\r
1e57a462	29	print "# %s" % ffs\r
3402aac7	30	\r
1e57a462	31	section = ffs.get_next_section()\r
	32	while section != None:\r
	33	print "\t%s" % section\r
	34	try:\r
	35	print "\t\t- %s" % section.get_debug_filepath()\r
	36	except Exception:\r
	37	pass\r
	38	section = ffs.get_next_section(section)\r
3402aac7	39	\r
1e57a462	40	ffs = fv.get_next_ffs(ffs)\r
	41	\r
	42	def dump_system_table(ec, mem_base, mem_size):\r
	43	st = system_table.SystemTable(ec, mem_base, mem_size)\r
3402aac7	44	\r
1e57a462	45	debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
3402aac7	46	\r
1e57a462	47	debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)\r
	48	debug_info_table.dump()\r
	49	\r
72efe027	50	def load_symbol_from_file(ec, filename, address, verbose = False):\r
	51	if verbose:\r
	52	print "Add symbols of %s at 0x%x" % (filename, address)\r
3402aac7	53	\r
1e57a462	54	try:\r
	55	ec.getImageService().addSymbols(filename, address)\r
	56	except:\r
	57	try:\r
	58	# We could get an exception if the symbols are already loaded\r
	59	ec.getImageService().unloadSymbols(filename)\r
	60	ec.getImageService().addSymbols(filename, address)\r
	61	except:\r
72efe027	62	print "Warning: not possible to load symbols from %s at 0x%x" % (filename, address)\r
e3d495e1 HL	63	\r
	64	def is_aarch64(ec):\r
	65	success = True\r
	66	try:\r
	67	# Try to access a Aarch64 specific register\r
	68	ec.getRegisterService().getValue('X0')\r
	69	except:\r
	70	success = False\r
	71	return success\r
1e57a462	72	\r
	73	class ArmPlatform:\r
	74	def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):\r
	75	self.sysmembase = sysmembase\r
	76	self.sysmemsize = sysmemsize\r
	77	self.fvs = fvs\r
3402aac7	78	\r
1e57a462	79	class ArmPlatformDebugger:\r
	80	system_table = None\r
	81	firmware_volumes = {}\r
3402aac7	82	\r
1e57a462	83	REGION_TYPE_SYSMEM = 1\r
	84	REGION_TYPE_ROM = 2\r
	85	REGION_TYPE_FV = 3\r
3402aac7	86	\r
72efe027	87	def __init__(self, ec, report_log, regions, verbose = False):\r
1e57a462	88	self.ec = ec\r
72efe027	89	self.verbose = verbose\r
1e57a462	90	fvs = []\r
	91	sysmem_base = None\r
	92	sysmem_size = None\r
3402aac7	93	\r
1e57a462	94	if report_log and os.path.isfile(report_log):\r
	95	try:\r
	96	self.build = build_report.BuildReport(report_log)\r
	97	except IOError:\r
72efe027	98	raise IOError(2, 'Report \'%s\' is not valid' % report_log)\r
3402aac7	99	\r
1e57a462	100	# Generate list of supported Firmware Volumes\r
	101	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:\r
	102	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))\r
	103	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:\r
	104	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))\r
	105	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:\r
	106	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))\r
3402aac7	107	\r
1e57a462	108	sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)\r
	109	sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)\r
	110	else:\r
	111	for region in regions:\r
	112	if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:\r
	113	sysmem_base = region[1]\r
	114	sysmem_size = region[2]\r
	115	elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:\r
	116	fvs.append((region[1],region[2]))\r
	117	elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:\r
	118	for base in xrange(region[1], region[1] + region[2], 0x400000):\r
	119	signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))\r
	120	if signature == FirmwareVolume.CONST_FV_SIGNATURE:\r
	121	fvs.append((base,0))\r
	122	else:\r
	123	print "Region type '%d' Not Supported" % region[0]\r
3402aac7	124	\r
1e57a462	125	self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)\r
3402aac7	126	\r
1e57a462	127	def in_sysmem(self, addr):\r
	128	return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)\r
	129	\r
	130	def in_fv(self, addr):\r
	131	return (self.get_fv_at(addr) != None)\r
	132	\r
	133	def get_fv_at(self, addr):\r
	134	for fv in self.platform.fvs:\r
	135	if (fv[0] <= addr) and (addr < fv[0] + fv[1]):\r
	136	return fv\r
	137	return None\r
	138	\r
	139	def load_current_symbols(self):\r
	140	pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
	141	if self.in_fv(pc):\r
	142	debug_infos = []\r
3402aac7	143	\r
1e57a462	144	(fv_base, fv_size) = self.get_fv_at(pc)\r
3402aac7	145	\r
1e57a462	146	if self.firmware_volumes.has_key(fv_base) == False:\r
1e57a462	147	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
3402aac7	148	\r
1e57a462	149	stack_frame = self.ec.getTopLevelStackFrame()\r
72efe027	150	info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
1e57a462	151	debug_infos.append(info)\r
	152	while stack_frame.next() is not None:\r
	153	stack_frame = stack_frame.next()\r
3402aac7	154	\r
1e57a462	155	# Stack frame attached to 'PC'\r
1e57a462	156	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
3402aac7	157	\r
1e57a462	158	# Check if the symbols for this stack frame have already been loaded\r
	159	found = False\r
	160	for debug_info in debug_infos:\r
	161	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
	162	found = True\r
	163	if found == False:\r
	164	info = self.firmware_volumes[fv_base].load_symbols_at(pc)\r
	165	debug_infos.append(info)\r
3402aac7	166	\r
1e57a462	167	#self.firmware_volumes[fv_base].load_symbols_at(pc)\r
	168	elif self.in_sysmem(pc):\r
	169	debug_infos = []\r
3402aac7	170	\r
1e57a462	171	if self.system_table is None:\r
	172	# Find the System Table\r
	173	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
3402aac7	174	\r
1e57a462	175	# Find the Debug Info Table\r
	176	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
	177	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
3402aac7	178	\r
1e57a462	179	stack_frame = self.ec.getTopLevelStackFrame()\r
72efe027	180	info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
1e57a462	181	debug_infos.append(info)\r
	182	while stack_frame.next() is not None:\r
	183	stack_frame = stack_frame.next()\r
3402aac7	184	\r
1e57a462	185	# Stack frame attached to 'PC'\r
1e57a462	186	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
3402aac7	187	\r
1e57a462	188	# Check if the symbols for this stack frame have already been loaded\r
	189	found = False\r
	190	for debug_info in debug_infos:\r
	191	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
	192	found = True\r
	193	if found == False:\r
e3d495e1 HL	194	try:\r
	195	info = self.debug_info_table.load_symbols_at(pc)\r
	196	debug_infos.append(info)\r
	197	except:\r
	198	pass\r
3402aac7	199	\r
1e57a462	200	#self.debug_info_table.load_symbols_at(pc)\r
	201	else:\r
	202	raise Exception('ArmPlatformDebugger', "Not supported region")\r
3402aac7	203	\r
1e57a462	204	def load_all_symbols(self):\r
	205	# Load all the XIP symbols attached to the Firmware Volume\r
	206	for (fv_base, fv_size) in self.platform.fvs:\r
	207	if self.firmware_volumes.has_key(fv_base) == False:\r
3402aac7	208	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
72efe027	209	self.firmware_volumes[fv_base].load_all_symbols(self.verbose)\r
1e57a462	210	\r
	211	try:\r
	212	# Load all symbols of module loaded into System Memory\r
	213	if self.system_table is None:\r
	214	# Find the System Table\r
	215	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
3402aac7 RC	216	\r
3402aac7 RC	217	\r
1e57a462	218	# Find the Debug Info Table\r
	219	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
	220	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
3402aac7	221	\r
72efe027	222	self.debug_info_table.load_all_symbols(self.verbose)\r
1e57a462	223	except:\r
1e57a462	224	# Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet\r
daa6cd87	225	print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has not been installed yet)"\r