ArmPlatformPkg/Scripts/Ds5/edk2_debugger.py

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