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

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