OvmfPkg/IntelTdx: Add SecTdxHelperLib

[mirror_edk2.git] / EmulatorPkg / Unix / lldbefi.py

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