diff options
| -rw-r--r-- | EmulatorPkg/Unix/Host/Host.c | 9 | ||||
| -rwxr-xr-x | EmulatorPkg/Unix/lldbefi.py | 540 | ||||
| -rw-r--r-- | EmulatorPkg/Unix/lldbinit | 3 |
3 files changed, 550 insertions, 2 deletions
diff --git a/EmulatorPkg/Unix/Host/Host.c b/EmulatorPkg/Unix/Host/Host.c index 7eecbceaad..2f01cf88a2 100644 --- a/EmulatorPkg/Unix/Host/Host.c +++ b/EmulatorPkg/Unix/Host/Host.c @@ -1161,6 +1161,8 @@ GdbScriptAddImage ( SymbolsAddr ); fclose (GdbTempFile); + // This is for the lldb breakpoint only + SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders), 1); } else { ASSERT (FALSE); } @@ -1178,8 +1180,10 @@ GdbScriptAddImage ( // // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint. // Hey what can you say scripting in gdb is not that great.... + // Also used for the lldb breakpoint script. The lldb breakpoint script does + // not use the file, it uses the arguments. // - SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer), (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders), 1); + SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders), 1); } else { ASSERT (FALSE); } @@ -1235,6 +1239,7 @@ GdbScriptRemoveImage ( ImageContext->PdbPointer ); fclose (GdbTempFile); + SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, 0, 0); } else { ASSERT (FALSE); } @@ -1248,7 +1253,7 @@ GdbScriptRemoveImage ( // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint. // Hey what can you say scripting in gdb is not that great.... // - SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer), 0, 0); + SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, 0, 0); } else { ASSERT (FALSE); } diff --git a/EmulatorPkg/Unix/lldbefi.py b/EmulatorPkg/Unix/lldbefi.py new file mode 100755 index 0000000000..64549ce3ec --- /dev/null +++ b/EmulatorPkg/Unix/lldbefi.py @@ -0,0 +1,540 @@ +#!/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.' diff --git a/EmulatorPkg/Unix/lldbinit b/EmulatorPkg/Unix/lldbinit new file mode 100644 index 0000000000..16b34e362b --- /dev/null +++ b/EmulatorPkg/Unix/lldbinit @@ -0,0 +1,3 @@ +setting set frame-format "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}{:${function.name}()${function.pc-offset}}}{ at ${line.file.fullpath}:${line.number}}\n" +command script import lldbefi.py +run |