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

#\r
#  Copyright (c) 2011-2012, 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):\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" % filename\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):\r
        self.ec = ec\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\' isnot 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)\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)\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()\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()\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
	2	# Copyright (c) 2011-2012, ARM Limited. All rights reserved.\r
	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
	56	def load_symbol_from_file(ec, filename, address):\r
	57	try:\r
	58	ec.getImageService().addSymbols(filename, address)\r
	59	except:\r
	60	try:\r
	61	# We could get an exception if the symbols are already loaded\r
	62	ec.getImageService().unloadSymbols(filename)\r
	63	ec.getImageService().addSymbols(filename, address)\r
	64	except:\r
65	print "Warning: not possible to load symbols from %s" % filename\r
66	pass\r
67	\r
68	class ArmPlatform:\r
69	def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):\r
70	self.sysmembase = sysmembase\r
71	self.sysmemsize = sysmemsize\r
72	self.fvs = fvs\r
73	\r
74	class ArmPlatformDebugger:\r
75	system_table = None\r
76	firmware_volumes = {}\r
77	\r
78	REGION_TYPE_SYSMEM = 1\r
79	REGION_TYPE_ROM = 2\r
80	REGION_TYPE_FV = 3\r
81	\r
82	def __init__(self, ec, report_log, regions):\r
83	self.ec = ec\r
84	fvs = []\r
85	sysmem_base = None\r
86	sysmem_size = None\r
87	\r
88	if report_log and os.path.isfile(report_log):\r
89	try:\r
90	self.build = build_report.BuildReport(report_log)\r
91	except IOError:\r
92	raise IOError(2, 'Report \'%s\' isnot valid' % report_log)\r
93	\r
94	# Generate list of supported Firmware Volumes\r
95	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:\r
96	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))\r
97	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:\r
98	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))\r
99	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:\r
100	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))\r
101	\r
102	sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)\r
103	sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)\r
104	else:\r
105	for region in regions:\r
106	if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:\r
107	sysmem_base = region[1]\r
108	sysmem_size = region[2]\r
109	elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:\r
110	fvs.append((region[1],region[2]))\r
111	elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:\r
112	for base in xrange(region[1], region[1] + region[2], 0x400000):\r
113	signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))\r
114	if signature == FirmwareVolume.CONST_FV_SIGNATURE:\r
115	fvs.append((base,0))\r
116	else:\r
117	print "Region type '%d' Not Supported" % region[0]\r
118	\r
119	self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)\r
120	\r
121	def in_sysmem(self, addr):\r
122	return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)\r
123	\r
124	def in_fv(self, addr):\r
125	return (self.get_fv_at(addr) != None)\r
126	\r
127	def get_fv_at(self, addr):\r
128	for fv in self.platform.fvs:\r
129	if (fv[0] <= addr) and (addr < fv[0] + fv[1]):\r
130	return fv\r
131	return None\r
132	\r
133	def load_current_symbols(self):\r
134	pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
135	if self.in_fv(pc):\r
136	debug_infos = []\r
137	\r
138	(fv_base, fv_size) = self.get_fv_at(pc)\r
139	\r
140	if self.firmware_volumes.has_key(fv_base) == False:\r
141	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
142	\r
143	stack_frame = self.ec.getTopLevelStackFrame()\r
144	info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF)\r
145	debug_infos.append(info)\r
146	while stack_frame.next() is not None:\r
147	stack_frame = stack_frame.next()\r
148	\r
149	# Stack frame attached to 'PC'\r
150	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
151	\r
152	# Check if the symbols for this stack frame have already been loaded\r
153	found = False\r
154	for debug_info in debug_infos:\r
155	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
156	found = True\r
157	if found == False:\r
158	info = self.firmware_volumes[fv_base].load_symbols_at(pc)\r
159	debug_infos.append(info)\r
160	\r
161	#self.firmware_volumes[fv_base].load_symbols_at(pc)\r
162	elif self.in_sysmem(pc):\r
163	debug_infos = []\r
164	\r
165	if self.system_table is None:\r
166	# Find the System Table\r
167	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
168	\r
169	# Find the Debug Info Table\r
170	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
171	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
172	\r
173	stack_frame = self.ec.getTopLevelStackFrame()\r
174	info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF)\r
175	debug_infos.append(info)\r
176	while stack_frame.next() is not None:\r
177	stack_frame = stack_frame.next()\r
178	\r
179	# Stack frame attached to 'PC'\r
180	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
181	\r
182	# Check if the symbols for this stack frame have already been loaded\r
183	found = False\r
184	for debug_info in debug_infos:\r
185	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
186	found = True\r
187	if found == False:\r
188	info = self.debug_info_table.load_symbols_at(pc)\r
189	debug_infos.append(info)\r
190	\r
191	#self.debug_info_table.load_symbols_at(pc)\r
192	else:\r
193	raise Exception('ArmPlatformDebugger', "Not supported region")\r
194	\r
195	def load_all_symbols(self):\r
196	# Load all the XIP symbols attached to the Firmware Volume\r
197	for (fv_base, fv_size) in self.platform.fvs:\r
198	if self.firmware_volumes.has_key(fv_base) == False:\r
199	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size) \r
200	self.firmware_volumes[fv_base].load_all_symbols()\r
201	\r
202	try:\r
203	# Load all symbols of module loaded into System Memory\r
204	if self.system_table is None:\r
205	# Find the System Table\r
206	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
207	\r
208	\r
209	# Find the Debug Info Table\r
210	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
211	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
212	\r
213	self.debug_info_table.load_all_symbols()\r
214	except:\r
215	# Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet\r
216	print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has been installed yet)"\r
217	pass\r