| #!/usr/bin/python |
| |
| # |
| # Copyright 2014 Apple Inc. All righes reserved. |
| # |
| # This program and the accompanying materials |
| # are licensed and made available under the terms and conditions of the BSD License |
| # which accompanies this distribution. The full text of the license may be found at |
| # http://opensource.org/licenses/bsd-license.php. |
| # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. |
| # |
| |
| import lldb |
| import os |
| import uuid |
| import string |
| import commands |
| import optparse |
| import shlex |
| |
| guid_dict = {} |
| |
| |
| def EFI_GUID_TypeSummary (valobj,internal_dict): |
| """ Type summary for EFI GUID, print C Name if known |
| """ |
| # typedef struct { |
| # UINT32 Data1; |
| # UINT16 Data2; |
| # UINT16 Data3; |
| # UINT8 Data4[8]; |
| # } EFI_GUID; |
| SBError = lldb.SBError() |
| |
| data1_val = valobj.GetChildMemberWithName('Data1') |
| data1 = data1_val.GetValueAsUnsigned(0) |
| data2_val = valobj.GetChildMemberWithName('Data2') |
| data2 = data2_val.GetValueAsUnsigned(0) |
| data3_val = valobj.GetChildMemberWithName('Data3') |
| data3 = data3_val.GetValueAsUnsigned(0) |
| str = "%x-%x-%x-" % (data1, data2, data3) |
| |
| data4_val = valobj.GetChildMemberWithName('Data4') |
| for i in range (data4_val.num_children): |
| if i == 2: |
| str +='-' |
| str += "%02x" % data4_val.GetChildAtIndex(i).data.GetUnsignedInt8(SBError, 0) |
| |
| return guid_dict.get (str.upper(), '') |
| |
| |
| |
| EFI_STATUS_Dict = { |
| (0x8000000000000000 | 1): "Load Error", |
| (0x8000000000000000 | 2): "Invalid Parameter", |
| (0x8000000000000000 | 3): "Unsupported", |
| (0x8000000000000000 | 4): "Bad Buffer Size", |
| (0x8000000000000000 | 5): "Buffer Too Small", |
| (0x8000000000000000 | 6): "Not Ready", |
| (0x8000000000000000 | 7): "Device Error", |
| (0x8000000000000000 | 8): "Write Protected", |
| (0x8000000000000000 | 9): "Out of Resources", |
| (0x8000000000000000 | 10): "Volume Corrupt", |
| (0x8000000000000000 | 11): "Volume Full", |
| (0x8000000000000000 | 12): "No Media", |
| (0x8000000000000000 | 13): "Media changed", |
| (0x8000000000000000 | 14): "Not Found", |
| (0x8000000000000000 | 15): "Access Denied", |
| (0x8000000000000000 | 16): "No Response", |
| (0x8000000000000000 | 17): "No mapping", |
| (0x8000000000000000 | 18): "Time out", |
| (0x8000000000000000 | 19): "Not started", |
| (0x8000000000000000 | 20): "Already started", |
| (0x8000000000000000 | 21): "Aborted", |
| (0x8000000000000000 | 22): "ICMP Error", |
| (0x8000000000000000 | 23): "TFTP Error", |
| (0x8000000000000000 | 24): "Protocol Error", |
| |
| 0 : "Success", |
| 1 : "Warning Unknown Glyph", |
| 2 : "Warning Delete Failure", |
| 3 : "Warning Write Failure", |
| 4 : "Warning Buffer Too Small", |
| |
| (0x80000000 | 1): "Load Error", |
| (0x80000000 | 2): "Invalid Parameter", |
| (0x80000000 | 3): "Unsupported", |
| (0x80000000 | 4): "Bad Buffer Size", |
| (0x80000000 | 5): "Buffer Too Small", |
| (0x80000000 | 6): "Not Ready", |
| (0x80000000 | 7): "Device Error", |
| (0x80000000 | 8): "Write Protected", |
| (0x80000000 | 9): "Out of Resources", |
| (0x80000000 | 10): "Volume Corrupt", |
| (0x80000000 | 11): "Volume Full", |
| (0x80000000 | 12): "No Media", |
| (0x80000000 | 13): "Media changed", |
| (0x80000000 | 14): "Not Found", |
| (0x80000000 | 15): "Access Denied", |
| (0x80000000 | 16): "No Response", |
| (0x80000000 | 17): "No mapping", |
| (0x80000000 | 18): "Time out", |
| (0x80000000 | 19): "Not started", |
| (0x80000000 | 20): "Already started", |
| (0x80000000 | 21): "Aborted", |
| (0x80000000 | 22): "ICMP Error", |
| (0x80000000 | 23): "TFTP Error", |
| (0x80000000 | 24): "Protocol Error", |
| } |
| |
| def EFI_STATUS_TypeSummary (valobj,internal_dict): |
| # |
| # Return summary string for EFI_STATUS from dictionary |
| # |
| Status = valobj.GetValueAsUnsigned(0) |
| return EFI_STATUS_Dict.get (Status, '') |
| |
| |
| def EFI_TPL_TypeSummary (valobj,internal_dict): |
| # |
| # Return TPL values |
| # |
| |
| if valobj.TypeIsPointerType(): |
| return "" |
| |
| Tpl = valobj.GetValueAsUnsigned(0) |
| if Tpl < 4: |
| Str = "%d" % Tpl |
| elif Tpl == 6: |
| Str = "TPL_DRIVER (Obsolete Concept in edk2)" |
| elif Tpl < 8: |
| Str = "TPL_APPLICATION" |
| if Tpl - 4 > 0: |
| Str += " + " + "%d" % (Tpl - 4) |
| elif Tpl < 16: |
| Str = "TPL_CALLBACK" |
| if Tpl - 8 > 0: |
| Str += " + " + "%d" % (Tpl - 4) |
| elif Tpl < 31: |
| Str = "TPL_NOTIFY" |
| if Tpl - 16 > 0: |
| Str += " + " + "%d" % (Tpl - 4) |
| elif Tpl == 31: |
| Str = "TPL_HIGH_LEVEL" |
| else: |
| Str = "Invalid TPL" |
| |
| return Str |
| |
| |
| def CHAR16_TypeSummary (valobj,internal_dict): |
| # |
| # Display EFI CHAR16 'unsigned short' as string |
| # |
| SBError = lldb.SBError() |
| Str = '' |
| if valobj.TypeIsPointerType(): |
| if valobj.GetValueAsUnsigned () == 0: |
| return "NULL" |
| |
| # CHAR16 * max string size 1024 |
| for i in range (1024): |
| Char = valobj.GetPointeeData(i,1).GetUnsignedInt16(SBError, 0) |
| if SBError.fail or Char == 0: |
| break |
| Str += unichr (Char) |
| Str = 'L"' + Str + '"' |
| return Str.encode ('utf-8', 'replace') |
| |
| if valobj.num_children == 0: |
| # CHAR16 |
| if chr (valobj.unsigned) in string.printable: |
| Str = "L'" + unichr (valobj.unsigned) + "'" |
| return Str.encode ('utf-8', 'replace') |
| else: |
| # CHAR16 [] |
| for i in range (valobj.num_children): |
| Char = valobj.GetChildAtIndex(i).data.GetUnsignedInt16(SBError, 0) |
| if Char == 0: |
| break |
| Str += unichr (Char) |
| Str = 'L"' + Str + '"' |
| return Str.encode ('utf-8', 'replace') |
| |
| return Str |
| |
| def CHAR8_TypeSummary (valobj,internal_dict): |
| # |
| # Display EFI CHAR8 'signed char' as string |
| # unichr() is used as a junk string can produce an error message like this: |
| # UnicodeEncodeError: 'ascii' codec can't encode character u'\x90' in position 1: ordinal not in range(128) |
| # |
| SBError = lldb.SBError() |
| Str = '' |
| if valobj.TypeIsPointerType(): |
| if valobj.GetValueAsUnsigned () == 0: |
| return "NULL" |
| |
| # CHAR8 * max string size 1024 |
| for i in range (1024): |
| Char = valobj.GetPointeeData(i,1).GetUnsignedInt8(SBError, 0) |
| if SBError.fail or Char == 0: |
| break |
| Str += unichr (Char) |
| Str = '"' + Str + '"' |
| return Str.encode ('utf-8', 'replace') |
| |
| if valobj.num_children == 0: |
| # CHAR8 |
| if chr (valobj.unsigned) in string.printable: |
| Str = '"' + unichr (valobj.unsigned) + '"' |
| return Str.encode ('utf-8', 'replace') |
| else: |
| # CHAR8 [] |
| for i in range (valobj.num_children): |
| Char = valobj.GetChildAtIndex(i).data.GetUnsignedInt8(SBError, 0) |
| if Char == 0: |
| break |
| Str += unichr (Char) |
| Str = '"' + Str + '"' |
| return Str.encode ('utf-8', 'replace') |
| |
| return Str |
| |
| device_path_dict = { |
| (0x01, 0x01): "PCI_DEVICE_PATH", |
| (0x01, 0x02): "PCCARD_DEVICE_PATH", |
| (0x01, 0x03): "MEMMAP_DEVICE_PATH", |
| (0x01, 0x04): "VENDOR_DEVICE_PATH", |
| (0x01, 0x05): "CONTROLLER_DEVICE_PATH", |
| (0x02, 0x01): "ACPI_HID_DEVICE_PATH", |
| (0x02, 0x02): "ACPI_EXTENDED_HID_DEVICE_PATH", |
| (0x02, 0x03): "ACPI_ADR_DEVICE_PATH", |
| (0x03, 0x01): "ATAPI_DEVICE_PATH", |
| (0x03, 0x12): "SATA_DEVICE_PATH", |
| (0x03, 0x02): "SCSI_DEVICE_PATH", |
| (0x03, 0x03): "FIBRECHANNEL_DEVICE_PATH", |
| (0x03, 0x04): "F1394_DEVICE_PATH", |
| (0x03, 0x05): "USB_DEVICE_PATH", |
| (0x03, 0x0f): "USB_CLASS_DEVICE_PATH", |
| (0x03, 0x10): "FW_SBP2_UNIT_LUN_DEVICE_PATH", |
| (0x03, 0x11): "DEVICE_LOGICAL_UNIT_DEVICE_PATH", |
| (0x03, 0x06): "I2O_DEVICE_PATH", |
| (0x03, 0x0b): "MAC_ADDR_DEVICE_PATH", |
| (0x03, 0x0c): "IPv4_DEVICE_PATH", |
| (0x03, 0x09): "INFINIBAND_DEVICE_PATH", |
| (0x03, 0x0e): "UART_DEVICE_PATH", |
| (0x03, 0x0a): "VENDOR_DEVICE_PATH", |
| (0x03, 0x13): "ISCSI_DEVICE_PATH", |
| (0x04, 0x01): "HARDDRIVE_DEVICE_PATH", |
| (0x04, 0x02): "CDROM_DEVICE_PATH", |
| (0x04, 0x03): "VENDOR_DEVICE_PATH", |
| (0x04, 0x04): "FILEPATH_DEVICE_PATH", |
| (0x04, 0x05): "MEDIA_PROTOCOL_DEVICE_PATH", |
| (0x05, 0x01): "BBS_BBS_DEVICE_PATH", |
| (0x7F, 0xFF): "EFI_DEVICE_PATH_PROTOCOL", |
| (0xFF, 0xFF): "EFI_DEVICE_PATH_PROTOCOL", |
| } |
| |
| def EFI_DEVICE_PATH_PROTOCOL_TypeSummary (valobj,internal_dict): |
| # |
| # |
| # |
| if valobj.TypeIsPointerType(): |
| # EFI_DEVICE_PATH_PROTOCOL * |
| return "" |
| |
| Str = "" |
| if valobj.num_children == 3: |
| # EFI_DEVICE_PATH_PROTOCOL |
| Type = valobj.GetChildMemberWithName('Type').unsigned |
| SubType = valobj.GetChildMemberWithName('SubType').unsigned |
| if (Type, SubType) in device_path_dict: |
| TypeStr = device_path_dict[Type, SubType] |
| else: |
| TypeStr = "" |
| |
| LenLow = valobj.GetChildMemberWithName('Length').GetChildAtIndex(0).unsigned |
| LenHigh = valobj.GetChildMemberWithName('Length').GetChildAtIndex(1).unsigned |
| Len = LenLow + (LenHigh >> 8) |
| |
| Address = long ("%d" % valobj.addr) |
| if (Address == lldb.LLDB_INVALID_ADDRESS): |
| # Need to reserach this, it seems to be the nested struct case |
| ExprStr = "" |
| elif (Type & 0x7f == 0x7f): |
| ExprStr = "End Device Path" if SubType == 0xff else "End This Instance" |
| else: |
| ExprStr = "expr *(%s *)0x%08x" % (TypeStr, Address) |
| |
| Str = " {\n" |
| Str += " (UINT8) Type = 0x%02x // %s\n" % (Type, "END" if (Type & 0x7f == 0x7f) else "") |
| Str += " (UINT8) SubType = 0x%02x // %s\n" % (SubType, ExprStr) |
| Str += " (UINT8 [2]) Length = { // 0x%04x (%d) bytes\n" % (Len, Len) |
| Str += " (UINT8) [0] = 0x%02x\n" % LenLow |
| Str += " (UINT8) [1] = 0x%02x\n" % LenHigh |
| Str += " }\n" |
| if (Type & 0x7f == 0x7f) and (SubType == 0xff): |
| pass |
| elif ExprStr != "": |
| NextNode = Address + Len |
| Str += "// Next node 'expr *(EFI_DEVICE_PATH_PROTOCOL *)0x%08x'\n" % NextNode |
| |
| return Str |
| |
| |
| |
| def TypePrintFormating(debugger): |
| # |
| # Set the default print formating for EFI types in lldb. |
| # seems lldb defaults to decimal. |
| # |
| category = debugger.GetDefaultCategory() |
| FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool) |
| |
| FormatHex = lldb.SBTypeFormat(lldb.eFormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex) |
| |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_PHYSICAL_ADDRESS"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("PHYSICAL_ADDRESS"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_STATUS"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_TPL"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex) |
| category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_FV_FILETYPE"), FormatHex) |
| |
| # |
| # Smart type printing for EFI |
| # |
| debugger.HandleCommand("type summary add EFI_GUID --python-function lldbefi.EFI_GUID_TypeSummary") |
| debugger.HandleCommand("type summary add EFI_STATUS --python-function lldbefi.EFI_STATUS_TypeSummary") |
| debugger.HandleCommand("type summary add EFI_TPL --python-function lldbefi.EFI_TPL_TypeSummary") |
| debugger.HandleCommand("type summary add EFI_DEVICE_PATH_PROTOCOL --python-function lldbefi.EFI_DEVICE_PATH_PROTOCOL_TypeSummary") |
| |
| debugger.HandleCommand("type summary add CHAR16 --python-function lldbefi.CHAR16_TypeSummary") |
| debugger.HandleCommand('type summary add --regex "CHAR16 \[[0-9]+\]" --python-function lldbefi.CHAR16_TypeSummary') |
| debugger.HandleCommand("type summary add CHAR8 --python-function lldbefi.CHAR8_TypeSummary") |
| debugger.HandleCommand('type summary add --regex "CHAR8 \[[0-9]+\]" --python-function lldbefi.CHAR8_TypeSummary') |
| |
| |
| gEmulatorBreakWorkaroundNeeded = True |
| |
| def LoadEmulatorEfiSymbols(frame, bp_loc , internal_dict): |
| # |
| # This is an lldb breakpoint script, and assumes the breakpoint is on a |
| # function with the same prototype as SecGdbScriptBreak(). The |
| # argument names are important as lldb looks them up. |
| # |
| # VOID |
| # SecGdbScriptBreak ( |
| # char *FileName, |
| # int FileNameLength, |
| # long unsigned int LoadAddress, |
| # int AddSymbolFlag |
| # ) |
| # { |
| # return; |
| # } |
| # |
| # When the emulator loads a PE/COFF image, it calls the stub function with |
| # the filename of the symbol file, the length of the FileName, the |
| # load address and a flag to indicate if this is a load or unload operation |
| # |
| global gEmulatorBreakWorkaroundNeeded |
| |
| if gEmulatorBreakWorkaroundNeeded: |
| # turn off lldb debug prints on SIGALRM (EFI timer tick) |
| frame.thread.process.target.debugger.HandleCommand("process handle SIGALRM -n false") |
| gEmulatorBreakWorkaroundNeeded = False |
| |
| # Convert C string to Python string |
| Error = lldb.SBError() |
| FileNamePtr = frame.FindVariable ("FileName").GetValueAsUnsigned() |
| FileNameLen = frame.FindVariable ("FileNameLength").GetValueAsUnsigned() |
| FileName = frame.thread.process.ReadCStringFromMemory (FileNamePtr, FileNameLen, Error) |
| if not Error.Success(): |
| print "!ReadCStringFromMemory() did not find a %d byte C string at %x" % (FileNameLen, FileNamePtr) |
| # make breakpoint command contiue |
| frame.GetThread().GetProcess().Continue() |
| |
| debugger = frame.thread.process.target.debugger |
| if frame.FindVariable ("AddSymbolFlag").GetValueAsUnsigned() == 1: |
| LoadAddress = frame.FindVariable ("LoadAddress").GetValueAsUnsigned() |
| |
| debugger.HandleCommand ("target modules add %s" % FileName) |
| print "target modules load --slid 0x%x %s" % (LoadAddress, FileName) |
| debugger.HandleCommand ("target modules load --slide 0x%x --file %s" % (LoadAddress, FileName)) |
| else: |
| target = debugger.GetSelectedTarget() |
| for SBModule in target.module_iter(): |
| ModuleName = SBModule.GetFileSpec().GetDirectory() + '/' |
| ModuleName += SBModule.GetFileSpec().GetFilename() |
| if FileName == ModuleName or FileName == SBModule.GetFileSpec().GetFilename(): |
| target.ClearModuleLoadAddress (SBModule) |
| if not target.RemoveModule (SBModule): |
| print "!lldb.target.RemoveModule (%s) FAILED" % SBModule |
| |
| # make breakpoint command contiue |
| frame.thread.process.Continue() |
| |
| def GuidToCStructStr (guid, Name=False): |
| # |
| # Convert a 16-byte bytesarry (or bytearray compat object) to C guid string |
| # { 0xB402621F, 0xA940, 0x1E4A, { 0x86, 0x6B, 0x4D, 0xC9, 0x16, 0x2B, 0x34, 0x7C } } |
| # |
| # Name=True means lookup name in GuidNameDict and us it if you find it |
| # |
| |
| if not isinstance (guid, bytearray): |
| # convert guid object to UUID, and UUID to bytearray |
| Uuid = uuid.UUID(guid) |
| guid = bytearray (Uuid.bytes_le) |
| |
| return "{ 0x%02.2X%02.2X%02.2X%02.2X, 0x%02.2X%02.2X, 0x%02.2X%02.2X, { 0x%02.2X, 0x%02.2X, 0x%02.2X, 0x%02.2X, 0x%02.2X, 0x%02.2X, 0x%02.2X, 0x%02.2X } }" % \ |
| (guid[3], guid[2], guid[1], guid[0], guid[5], guid[4], guid[7], guid[6], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]) |
| |
| def ParseGuidString(GuidStr): |
| # |
| # Error check and convert C Guid init to string |
| # ParseGuidString("49152E77-1ADA-4764-B7A2-7AFEFED95E8B") |
| # ParseGuidString("{ 0xBA24B391, 0x73FD, 0xC54C, { 0x9E, 0xAF, 0x0C, 0xA7, 0x8A, 0x35, 0x46, 0xD1 } }") |
| # |
| |
| if "{" in GuidStr : |
| # convert C form "{ 0xBA24B391, 0x73FD, 0xC54C, { 0x9E, 0xAF, 0x0C, 0xA7, 0x8A, 0x35, 0x46, 0xD1 } }" |
| # to string form BA24B391-73FD-C54C-9EAF-0CA78A3546D1 |
| # make a list of Hex numbers like: ['0xBA24B391', '0x73FD', '0xC54C', '0x9E', '0xAF', '0x0C', '0xA7', '0x8A', '0x35', '0x46', '0xD1'] |
| Hex = ''.join(x for x in GuidStr if x not in '{,}').split() |
| Str = "%08X-%04X-%04X-%02.2X%02.2X-%02.2X%02.2X%02.2X%02.2X%02.2X%02.2X" % \ |
| (int(Hex[0], 0), int(Hex[1], 0), int(Hex[2], 0), int(Hex[3], 0), int(Hex[4], 0), \ |
| int(Hex[5], 0), int(Hex[6], 0), int(Hex[7], 0), int(Hex[8], 0), int(Hex[9], 0), int(Hex[10], 0)) |
| elif GuidStr.count('-') == 4: |
| # validate "49152E77-1ADA-4764-B7A2-7AFEFED95E8B" form |
| Check = "%s" % str(uuid.UUID(GuidStr)).upper() |
| if GuidStr.upper() == Check: |
| Str = GuidStr.upper() |
| else: |
| Ste = "" |
| else: |
| Str = "" |
| |
| return Str |
| |
| |
| def create_guid_options(): |
| usage = "usage: %prog [data]" |
| description='''lookup EFI_GUID by CName, C struct, or GUID string and print out all three. |
| ''' |
| parser = optparse.OptionParser(description=description, prog='guid',usage=usage) |
| return parser |
| |
| def efi_guid_command(debugger, command, result, dict): |
| # Use the Shell Lexer to properly parse up command options just like a |
| # shell would |
| command_args = shlex.split(command) |
| parser = create_guid_options() |
| try: |
| (options, args) = parser.parse_args(command_args) |
| if len(args) >= 1: |
| if args[0] == "{": |
| # caller forgot to quote the string" |
| # mark arg[0] a string containing all args[n] |
| args[0] = ' '.join(args) |
| GuidStr = ParseGuidString (args[0]) |
| if GuidStr == "": |
| # return Key of GuidNameDict for value args[0] |
| GuidStr = [Key for Key, Value in guid_dict.iteritems() if Value == args[0]][0] |
| GuidStr = GuidStr.upper() |
| except: |
| # if you don't handle exceptions, passing an incorrect argument to the OptionParser will cause LLDB to exit |
| # (courtesy of OptParse dealing with argument errors by throwing SystemExit) |
| result.SetError ("option parsing failed") |
| return |
| |
| |
| if len(args) >= 1: |
| if GuidStr in guid_dict: |
| print "%s = %s" % (guid_dict[GuidStr], GuidStr) |
| print "%s = %s" % (guid_dict[GuidStr], GuidToCStructStr (GuidStr)) |
| else: |
| print GuidStr |
| else: |
| # dump entire dictionary |
| width = max(len(v) for k,v in guid_dict.iteritems()) |
| for value in sorted(guid_dict, key=guid_dict.get): |
| print '%-*s %s %s' % (width, guid_dict[value], value, GuidToCStructStr(value)) |
| |
| return |
| |
| |
| # |
| ########## Code that runs when this script is imported into LLDB ########### |
| # |
| def __lldb_init_module (debugger, internal_dict): |
| # This initializer is being run from LLDB in the embedded command interpreter |
| # Make the options so we can generate the help text for the new LLDB |
| # command line command prior to registering it with LLDB below |
| |
| global guid_dict |
| |
| # Source Guid.xref file if we can find it |
| inputfile = os.getcwd() |
| inputfile += os.sep + os.pardir + os.sep + 'FV' + os.sep + 'Guid.xref' |
| with open(inputfile) as f: |
| for line in f: |
| data = line.split(' ') |
| if len(data) >= 2: |
| guid_dict[data[0].upper()] = data[1].strip('\n') |
| |
| # init EFI specific type formaters |
| TypePrintFormating (debugger) |
| |
| |
| # add guid command |
| parser = create_guid_options() |
| efi_guid_command.__doc__ = parser.format_help() |
| debugger.HandleCommand('command script add -f lldbefi.efi_guid_command guid') |
| |
| |
| Target = debugger.GetTargetAtIndex(0) |
| if Target: |
| Breakpoint = Target.BreakpointCreateByName('SecGdbScriptBreak') |
| if Breakpoint.GetNumLocations() == 1: |
| # Set the emulator breakpoints, if we are in the emulator |
| debugger.HandleCommand("breakpoint command add -s python -F lldbefi.LoadEmulatorEfiSymbols {id}".format(id=Breakpoint.GetID())) |
| print 'Type r to run emulator. SecLldbScriptBreak armed. EFI modules should now get source level debugging in the emulator.' |
