]> git.proxmox.com Git - mirror_edk2.git/blame - EmulatorPkg/Unix/lldbefi.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EmulatorPkg: formalize line endings
[mirror_edk2.git] / EmulatorPkg / Unix / lldbefi.py
CommitLineData
79e4f2a5
RN		 1#!/usr/bin/python\r
2\r
3#\r
4# Copyright 2014 Apple Inc. All righes reserved.\r
5#\r
6# This program and the accompanying materials\r
7# are licensed and made available under the terms and conditions of the BSD License\r
8# which accompanies this distribution. The full text of the license may be found at\r
9# http://opensource.org/licenses/bsd-license.php.\r
10# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12#\r
13\r
14import lldb\r
15import os\r
16import uuid\r
17import string\r
18import commands\r
19import optparse\r
20import shlex\r
21\r
22guid_dict = {}\r
23\r
24\r
25def EFI_GUID_TypeSummary (valobj,internal_dict):\r
26 """ Type summary for EFI GUID, print C Name if known\r
27 """\r
28 # typedef struct {\r
29 # UINT32 Data1;\r
30 # UINT16 Data2;\r
31 # UINT16 Data3;\r
32 # UINT8 Data4[8];\r
33 # } EFI_GUID;\r
34 SBError = lldb.SBError()\r
35\r
36 data1_val = valobj.GetChildMemberWithName('Data1')\r
37 data1 = data1_val.GetValueAsUnsigned(0)\r
38 data2_val = valobj.GetChildMemberWithName('Data2')\r
39 data2 = data2_val.GetValueAsUnsigned(0)\r
40 data3_val = valobj.GetChildMemberWithName('Data3')\r
41 data3 = data3_val.GetValueAsUnsigned(0)\r
42 str = "%x-%x-%x-" % (data1, data2, data3)\r
43\r
44 data4_val = valobj.GetChildMemberWithName('Data4')\r
45 for i in range (data4_val.num_children):\r
46 if i == 2:\r
47 str +='-'\r
48 str += "%02x" % data4_val.GetChildAtIndex(i).data.GetUnsignedInt8(SBError, 0)\r
49\r
50 return guid_dict.get (str.upper(), '')\r
51\r
52\r
53\r
54EFI_STATUS_Dict = {\r
55 (0x8000000000000000 | 1): "Load Error",\r
56 (0x8000000000000000 | 2): "Invalid Parameter",\r
57 (0x8000000000000000 | 3): "Unsupported",\r
58 (0x8000000000000000 | 4): "Bad Buffer Size",\r
59 (0x8000000000000000 | 5): "Buffer Too Small",\r
60 (0x8000000000000000 | 6): "Not Ready",\r
61 (0x8000000000000000 | 7): "Device Error",\r
62 (0x8000000000000000 | 8): "Write Protected",\r
63 (0x8000000000000000 | 9): "Out of Resources",\r
64 (0x8000000000000000 | 10): "Volume Corrupt",\r
65 (0x8000000000000000 | 11): "Volume Full",\r
66 (0x8000000000000000 | 12): "No Media",\r
67 (0x8000000000000000 | 13): "Media changed",\r
68 (0x8000000000000000 | 14): "Not Found",\r
69 (0x8000000000000000 | 15): "Access Denied",\r
70 (0x8000000000000000 | 16): "No Response",\r
71 (0x8000000000000000 | 17): "No mapping",\r
72 (0x8000000000000000 | 18): "Time out",\r
73 (0x8000000000000000 | 19): "Not started",\r
74 (0x8000000000000000 | 20): "Already started",\r
75 (0x8000000000000000 | 21): "Aborted",\r
76 (0x8000000000000000 | 22): "ICMP Error",\r
77 (0x8000000000000000 | 23): "TFTP Error",\r
78 (0x8000000000000000 | 24): "Protocol Error",\r
79\r
80 0 : "Success",\r
81 1 : "Warning Unknown Glyph",\r
82 2 : "Warning Delete Failure",\r
83 3 : "Warning Write Failure",\r
84 4 : "Warning Buffer Too Small",\r
85\r
86 (0x80000000 | 1): "Load Error",\r
87 (0x80000000 | 2): "Invalid Parameter",\r
88 (0x80000000 | 3): "Unsupported",\r
89 (0x80000000 | 4): "Bad Buffer Size",\r
90 (0x80000000 | 5): "Buffer Too Small",\r
91 (0x80000000 | 6): "Not Ready",\r
92 (0x80000000 | 7): "Device Error",\r
93 (0x80000000 | 8): "Write Protected",\r
94 (0x80000000 | 9): "Out of Resources",\r
95 (0x80000000 | 10): "Volume Corrupt",\r
96 (0x80000000 | 11): "Volume Full",\r
97 (0x80000000 | 12): "No Media",\r
98 (0x80000000 | 13): "Media changed",\r
99 (0x80000000 | 14): "Not Found",\r
100 (0x80000000 | 15): "Access Denied",\r
101 (0x80000000 | 16): "No Response",\r
102 (0x80000000 | 17): "No mapping",\r
103 (0x80000000 | 18): "Time out",\r
104 (0x80000000 | 19): "Not started",\r
105 (0x80000000 | 20): "Already started",\r
106 (0x80000000 | 21): "Aborted",\r
107 (0x80000000 | 22): "ICMP Error",\r
108 (0x80000000 | 23): "TFTP Error",\r
109 (0x80000000 | 24): "Protocol Error",\r
110}\r
111\r
112def EFI_STATUS_TypeSummary (valobj,internal_dict):\r
113 #\r
114 # Return summary string for EFI_STATUS from dictionary\r
115 #\r
116 Status = valobj.GetValueAsUnsigned(0)\r
117 return EFI_STATUS_Dict.get (Status, '')\r
118\r
119\r
120def EFI_TPL_TypeSummary (valobj,internal_dict):\r
121 #\r
122 # Return TPL values\r
123 #\r
124\r
125 if valobj.TypeIsPointerType():\r
126 return ""\r
127\r
128 Tpl = valobj.GetValueAsUnsigned(0)\r
129 if Tpl < 4:\r
130 Str = "%d" % Tpl\r
131 elif Tpl == 6:\r
132 Str = "TPL_DRIVER (Obsolete Concept in edk2)"\r
133 elif Tpl < 8:\r
134 Str = "TPL_APPLICATION"\r
135 if Tpl - 4 > 0:\r
136 Str += " + " + "%d" % (Tpl - 4)\r
137 elif Tpl < 16:\r
138 Str = "TPL_CALLBACK"\r
139 if Tpl - 8 > 0:\r
140 Str += " + " + "%d" % (Tpl - 4)\r
141 elif Tpl < 31:\r
142 Str = "TPL_NOTIFY"\r
143 if Tpl - 16 > 0:\r
144 Str += " + " + "%d" % (Tpl - 4)\r
145 elif Tpl == 31:\r
146 Str = "TPL_HIGH_LEVEL"\r
147 else:\r
148 Str = "Invalid TPL"\r
149\r
150 return Str\r
151\r
152\r
153def CHAR16_TypeSummary (valobj,internal_dict):\r
154 #\r
155 # Display EFI CHAR16 'unsigned short' as string\r
156 #\r
157 SBError = lldb.SBError()\r
158 Str = ''\r
159 if valobj.TypeIsPointerType():\r
160 if valobj.GetValueAsUnsigned () == 0:\r
161 return "NULL"\r
162\r
163 # CHAR16 * max string size 1024\r
164 for i in range (1024):\r
165 Char = valobj.GetPointeeData(i,1).GetUnsignedInt16(SBError, 0)\r
166 if SBError.fail or Char == 0:\r
167 break\r
168 Str += unichr (Char)\r
169 Str = 'L"' + Str + '"'\r
170 return Str.encode ('utf-8', 'replace')\r
171\r
172 if valobj.num_children == 0:\r
173 # CHAR16\r
174 if chr (valobj.unsigned) in string.printable:\r
175 Str = "L'" + unichr (valobj.unsigned) + "'"\r
176 return Str.encode ('utf-8', 'replace')\r
177 else:\r
178 # CHAR16 []\r
179 for i in range (valobj.num_children):\r
180 Char = valobj.GetChildAtIndex(i).data.GetUnsignedInt16(SBError, 0)\r
181 if Char == 0:\r
182 break\r
183 Str += unichr (Char)\r
184 Str = 'L"' + Str + '"'\r
185 return Str.encode ('utf-8', 'replace')\r
186\r
187 return Str\r
188\r
189def CHAR8_TypeSummary (valobj,internal_dict):\r
190 #\r
191 # Display EFI CHAR8 'signed char' as string\r
192 # unichr() is used as a junk string can produce an error message like this:\r
193 # UnicodeEncodeError: 'ascii' codec can't encode character u'\x90' in position 1: ordinal not in range(128)\r
194 #\r
195 SBError = lldb.SBError()\r
196 Str = ''\r
197 if valobj.TypeIsPointerType():\r
198 if valobj.GetValueAsUnsigned () == 0:\r
199 return "NULL"\r
200\r
201 # CHAR8 * max string size 1024\r
202 for i in range (1024):\r
203 Char = valobj.GetPointeeData(i,1).GetUnsignedInt8(SBError, 0)\r
204 if SBError.fail or Char == 0:\r
205 break\r
206 Str += unichr (Char)\r
207 Str = '"' + Str + '"'\r
208 return Str.encode ('utf-8', 'replace')\r
209\r
210 if valobj.num_children == 0:\r
211 # CHAR8\r
212 if chr (valobj.unsigned) in string.printable:\r
213 Str = '"' + unichr (valobj.unsigned) + '"'\r
214 return Str.encode ('utf-8', 'replace')\r
215 else:\r
216 # CHAR8 []\r
217 for i in range (valobj.num_children):\r
218 Char = valobj.GetChildAtIndex(i).data.GetUnsignedInt8(SBError, 0)\r
219 if Char == 0:\r
220 break\r
221 Str += unichr (Char)\r
222 Str = '"' + Str + '"'\r
223 return Str.encode ('utf-8', 'replace')\r
224\r
225 return Str\r
226\r
227device_path_dict = {\r
228 (0x01, 0x01): "PCI_DEVICE_PATH",\r
229 (0x01, 0x02): "PCCARD_DEVICE_PATH",\r
230 (0x01, 0x03): "MEMMAP_DEVICE_PATH",\r
231 (0x01, 0x04): "VENDOR_DEVICE_PATH",\r
232 (0x01, 0x05): "CONTROLLER_DEVICE_PATH",\r
233 (0x02, 0x01): "ACPI_HID_DEVICE_PATH",\r
234 (0x02, 0x02): "ACPI_EXTENDED_HID_DEVICE_PATH",\r
235 (0x02, 0x03): "ACPI_ADR_DEVICE_PATH",\r
236 (0x03, 0x01): "ATAPI_DEVICE_PATH",\r
237 (0x03, 0x12): "SATA_DEVICE_PATH",\r
238 (0x03, 0x02): "SCSI_DEVICE_PATH",\r
239 (0x03, 0x03): "FIBRECHANNEL_DEVICE_PATH",\r
240 (0x03, 0x04): "F1394_DEVICE_PATH",\r
241 (0x03, 0x05): "USB_DEVICE_PATH",\r
242 (0x03, 0x0f): "USB_CLASS_DEVICE_PATH",\r
243 (0x03, 0x10): "FW_SBP2_UNIT_LUN_DEVICE_PATH",\r
244 (0x03, 0x11): "DEVICE_LOGICAL_UNIT_DEVICE_PATH",\r
245 (0x03, 0x06): "I2O_DEVICE_PATH",\r
246 (0x03, 0x0b): "MAC_ADDR_DEVICE_PATH",\r
247 (0x03, 0x0c): "IPv4_DEVICE_PATH",\r
248 (0x03, 0x09): "INFINIBAND_DEVICE_PATH",\r
249 (0x03, 0x0e): "UART_DEVICE_PATH",\r
250 (0x03, 0x0a): "VENDOR_DEVICE_PATH",\r
251 (0x03, 0x13): "ISCSI_DEVICE_PATH",\r
252 (0x04, 0x01): "HARDDRIVE_DEVICE_PATH",\r
253 (0x04, 0x02): "CDROM_DEVICE_PATH",\r
254 (0x04, 0x03): "VENDOR_DEVICE_PATH",\r
255 (0x04, 0x04): "FILEPATH_DEVICE_PATH",\r
256 (0x04, 0x05): "MEDIA_PROTOCOL_DEVICE_PATH",\r
257 (0x05, 0x01): "BBS_BBS_DEVICE_PATH",\r
258 (0x7F, 0xFF): "EFI_DEVICE_PATH_PROTOCOL",\r
259 (0xFF, 0xFF): "EFI_DEVICE_PATH_PROTOCOL",\r
260}\r
261\r
262def EFI_DEVICE_PATH_PROTOCOL_TypeSummary (valobj,internal_dict):\r
263 #\r
264 #\r
265 #\r
266 if valobj.TypeIsPointerType():\r
267 # EFI_DEVICE_PATH_PROTOCOL *\r
268 return ""\r
269\r
270 Str = ""\r
271 if valobj.num_children == 3:\r
272 # EFI_DEVICE_PATH_PROTOCOL\r
273 Type = valobj.GetChildMemberWithName('Type').unsigned\r
274 SubType = valobj.GetChildMemberWithName('SubType').unsigned\r
275 if (Type, SubType) in device_path_dict:\r
276 TypeStr = device_path_dict[Type, SubType]\r
277 else:\r
278 TypeStr = ""\r
279\r
280 LenLow = valobj.GetChildMemberWithName('Length').GetChildAtIndex(0).unsigned\r
281 LenHigh = valobj.GetChildMemberWithName('Length').GetChildAtIndex(1).unsigned\r
282 Len = LenLow + (LenHigh >> 8)\r
283\r
284 Address = long ("%d" % valobj.addr)\r
285 if (Address == lldb.LLDB_INVALID_ADDRESS):\r
286 # Need to reserach this, it seems to be the nested struct case\r
287 ExprStr = ""\r
288 elif (Type & 0x7f == 0x7f):\r
289 ExprStr = "End Device Path" if SubType == 0xff else "End This Instance"\r
290 else:\r
291 ExprStr = "expr *(%s *)0x%08x" % (TypeStr, Address)\r
292\r
293 Str = " {\n"\r
294 Str += " (UINT8) Type = 0x%02x // %s\n" % (Type, "END" if (Type & 0x7f == 0x7f) else "")\r
295 Str += " (UINT8) SubType = 0x%02x // %s\n" % (SubType, ExprStr)\r
296 Str += " (UINT8 [2]) Length = { // 0x%04x (%d) bytes\n" % (Len, Len)\r
297 Str += " (UINT8) [0] = 0x%02x\n" % LenLow\r
298 Str += " (UINT8) [1] = 0x%02x\n" % LenHigh\r
299 Str += " }\n"\r
300 if (Type & 0x7f == 0x7f) and (SubType == 0xff):\r
301 pass\r
302 elif ExprStr != "":\r
303 NextNode = Address + Len\r
304 Str += "// Next node 'expr *(EFI_DEVICE_PATH_PROTOCOL *)0x%08x'\n" % NextNode\r
305\r
306 return Str\r
307\r
308\r
309\r
310def TypePrintFormating(debugger):\r
311 #\r
312 # Set the default print formating for EFI types in lldb.\r
313 # seems lldb defaults to decimal.\r
314 #\r
315 category = debugger.GetDefaultCategory()\r
316 FormatBool = lldb.SBTypeFormat(lldb.eFormatBoolean)\r
317 category.AddTypeFormat(lldb.SBTypeNameSpecifier("BOOLEAN"), FormatBool)\r
318\r
319 FormatHex = lldb.SBTypeFormat(lldb.eFormatHex)\r
320 category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT64"), FormatHex)\r
321 category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT64"), FormatHex)\r
322 category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT32"), FormatHex)\r
323 category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT32"), FormatHex)\r
324 category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT16"), FormatHex)\r
325 category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT16"), FormatHex)\r
326 category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINT8"), FormatHex)\r
327 category.AddTypeFormat(lldb.SBTypeNameSpecifier("INT8"), FormatHex)\r
328 category.AddTypeFormat(lldb.SBTypeNameSpecifier("UINTN"), FormatHex)\r
329 category.AddTypeFormat(lldb.SBTypeNameSpecifier("INTN"), FormatHex)\r
330 category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR8"), FormatHex)\r
331 category.AddTypeFormat(lldb.SBTypeNameSpecifier("CHAR16"), FormatHex)\r
332\r
333 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_PHYSICAL_ADDRESS"), FormatHex)\r
334 category.AddTypeFormat(lldb.SBTypeNameSpecifier("PHYSICAL_ADDRESS"), FormatHex)\r
335 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_STATUS"), FormatHex)\r
336 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_TPL"), FormatHex)\r
337 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_LBA"), FormatHex)\r
338 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_BOOT_MODE"), FormatHex)\r
339 category.AddTypeFormat(lldb.SBTypeNameSpecifier("EFI_FV_FILETYPE"), FormatHex)\r
340\r
341 #\r
342 # Smart type printing for EFI\r
343 #\r
344 debugger.HandleCommand("type summary add EFI_GUID --python-function lldbefi.EFI_GUID_TypeSummary")\r
345 debugger.HandleCommand("type summary add EFI_STATUS --python-function lldbefi.EFI_STATUS_TypeSummary")\r
346 debugger.HandleCommand("type summary add EFI_TPL --python-function lldbefi.EFI_TPL_TypeSummary")\r
347 debugger.HandleCommand("type summary add EFI_DEVICE_PATH_PROTOCOL --python-function lldbefi.EFI_DEVICE_PATH_PROTOCOL_TypeSummary")\r
348\r
349 debugger.HandleCommand("type summary add CHAR16 --python-function lldbefi.CHAR16_TypeSummary")\r
350 debugger.HandleCommand('type summary add --regex "CHAR16 \[[0-9]+\]" --python-function lldbefi.CHAR16_TypeSummary')\r
351 debugger.HandleCommand("type summary add CHAR8 --python-function lldbefi.CHAR8_TypeSummary")\r
352 debugger.HandleCommand('type summary add --regex "CHAR8 \[[0-9]+\]" --python-function lldbefi.CHAR8_TypeSummary')\r
353\r
354\r
355gEmulatorBreakWorkaroundNeeded = True\r
356\r
357def LoadEmulatorEfiSymbols(frame, bp_loc , internal_dict):\r
358 #\r
359 # This is an lldb breakpoint script, and assumes the breakpoint is on a\r
360 # function with the same prototype as SecGdbScriptBreak(). The\r
361 # argument names are important as lldb looks them up.\r
362 #\r
363 # VOID\r
364 # SecGdbScriptBreak (\r
365 # char *FileName,\r
366 # int FileNameLength,\r
367 # long unsigned int LoadAddress,\r
368 # int AddSymbolFlag\r
369 # )\r
370 # {\r
371 # return;\r
372 # }\r
373 #\r
374 # When the emulator loads a PE/COFF image, it calls the stub function with\r
375 # the filename of the symbol file, the length of the FileName, the\r
376 # load address and a flag to indicate if this is a load or unload operation\r
377 #\r
378 global gEmulatorBreakWorkaroundNeeded\r
379\r
380 if gEmulatorBreakWorkaroundNeeded:\r
381 # turn off lldb debug prints on SIGALRM (EFI timer tick)\r
382 frame.thread.process.target.debugger.HandleCommand("process handle SIGALRM -n false")\r
383 gEmulatorBreakWorkaroundNeeded = False\r
384\r
385 # Convert C string to Python string\r
386 Error = lldb.SBError()\r
387 FileNamePtr = frame.FindVariable ("FileName").GetValueAsUnsigned()\r
388 FileNameLen = frame.FindVariable ("FileNameLength").GetValueAsUnsigned()\r
389 FileName = frame.thread.process.ReadCStringFromMemory (FileNamePtr, FileNameLen, Error)\r
390 if not Error.Success():\r
391 print "!ReadCStringFromMemory() did not find a %d byte C string at %x" % (FileNameLen, FileNamePtr)\r
392 # make breakpoint command contiue\r
393 frame.GetThread().GetProcess().Continue()\r
394\r
395 debugger = frame.thread.process.target.debugger\r
396 if frame.FindVariable ("AddSymbolFlag").GetValueAsUnsigned() == 1:\r
397 LoadAddress = frame.FindVariable ("LoadAddress").GetValueAsUnsigned()\r
398\r
399 debugger.HandleCommand ("target modules add %s" % FileName)\r
400 print "target modules load --slid 0x%x %s" % (LoadAddress, FileName)\r
401 debugger.HandleCommand ("target modules load --slide 0x%x --file %s" % (LoadAddress, FileName))\r
402 else:\r
403 target = debugger.GetSelectedTarget()\r
404 for SBModule in target.module_iter():\r
405 ModuleName = SBModule.GetFileSpec().GetDirectory() + '/'\r
406 ModuleName += SBModule.GetFileSpec().GetFilename()\r
407 if FileName == ModuleName or FileName == SBModule.GetFileSpec().GetFilename():\r
408 target.ClearModuleLoadAddress (SBModule)\r
409 if not target.RemoveModule (SBModule):\r
410 print "!lldb.target.RemoveModule (%s) FAILED" % SBModule\r
411\r
412 # make breakpoint command contiue\r
413 frame.thread.process.Continue()\r
414\r
415def GuidToCStructStr (guid, Name=False):\r
416 #\r
417 # Convert a 16-byte bytesarry (or bytearray compat object) to C guid string\r
418 # { 0xB402621F, 0xA940, 0x1E4A, { 0x86, 0x6B, 0x4D, 0xC9, 0x16, 0x2B, 0x34, 0x7C } }\r
419 #\r
420 # Name=True means lookup name in GuidNameDict and us it if you find it\r
421 #\r
422\r
423 if not isinstance (guid, bytearray):\r
424 # convert guid object to UUID, and UUID to bytearray\r
425 Uuid = uuid.UUID(guid)\r
426 guid = bytearray (Uuid.bytes_le)\r
427\r
428 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
429 (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
430\r
431def ParseGuidString(GuidStr):\r
432 #\r
433 # Error check and convert C Guid init to string\r
434 # ParseGuidString("49152E77-1ADA-4764-B7A2-7AFEFED95E8B")\r
435 # ParseGuidString("{ 0xBA24B391, 0x73FD, 0xC54C, { 0x9E, 0xAF, 0x0C, 0xA7, 0x8A, 0x35, 0x46, 0xD1 } }")\r
436 #\r
437\r
438 if "{" in GuidStr :\r
439 # convert C form "{ 0xBA24B391, 0x73FD, 0xC54C, { 0x9E, 0xAF, 0x0C, 0xA7, 0x8A, 0x35, 0x46, 0xD1 } }"\r
440 # to string form BA24B391-73FD-C54C-9EAF-0CA78A3546D1\r
441 # make a list of Hex numbers like: ['0xBA24B391', '0x73FD', '0xC54C', '0x9E', '0xAF', '0x0C', '0xA7', '0x8A', '0x35', '0x46', '0xD1']\r
442 Hex = ''.join(x for x in GuidStr if x not in '{,}').split()\r
443 Str = "%08X-%04X-%04X-%02.2X%02.2X-%02.2X%02.2X%02.2X%02.2X%02.2X%02.2X" % \\r
444 (int(Hex[0], 0), int(Hex[1], 0), int(Hex[2], 0), int(Hex[3], 0), int(Hex[4], 0), \\r
445 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
446 elif GuidStr.count('-') == 4:\r
447 # validate "49152E77-1ADA-4764-B7A2-7AFEFED95E8B" form\r
448 Check = "%s" % str(uuid.UUID(GuidStr)).upper()\r
449 if GuidStr.upper() == Check:\r
450 Str = GuidStr.upper()\r
451 else:\r
452 Ste = ""\r
453 else:\r
454 Str = ""\r
455\r
456 return Str\r
457\r
458\r
459def create_guid_options():\r
460 usage = "usage: %prog [data]"\r
461 description='''lookup EFI_GUID by CName, C struct, or GUID string and print out all three.\r
462 '''\r
463 parser = optparse.OptionParser(description=description, prog='guid',usage=usage)\r
464 return parser\r
465\r
466def efi_guid_command(debugger, command, result, dict):\r
467 # Use the Shell Lexer to properly parse up command options just like a\r
468 # shell would\r
469 command_args = shlex.split(command)\r
470 parser = create_guid_options()\r
471 try:\r
472 (options, args) = parser.parse_args(command_args)\r
473 if len(args) >= 1:\r
474 if args[0] == "{":\r
475 # caller forgot to quote the string"\r
476 # mark arg[0] a string containing all args[n]\r
477 args[0] = ' '.join(args)\r
478 GuidStr = ParseGuidString (args[0])\r
479 if GuidStr == "":\r
480 # return Key of GuidNameDict for value args[0]\r
481 GuidStr = [Key for Key, Value in guid_dict.iteritems() if Value == args[0]][0]\r
482 GuidStr = GuidStr.upper()\r
483 except:\r
484 # if you don't handle exceptions, passing an incorrect argument to the OptionParser will cause LLDB to exit\r
485 # (courtesy of OptParse dealing with argument errors by throwing SystemExit)\r
486 result.SetError ("option parsing failed")\r
487 return\r
488\r
489\r
490 if len(args) >= 1:\r
491 if GuidStr in guid_dict:\r
492 print "%s = %s" % (guid_dict[GuidStr], GuidStr)\r
493 print "%s = %s" % (guid_dict[GuidStr], GuidToCStructStr (GuidStr))\r
494 else:\r
495 print GuidStr\r
496 else:\r
497 # dump entire dictionary\r
498 width = max(len(v) for k,v in guid_dict.iteritems())\r
499 for value in sorted(guid_dict, key=guid_dict.get):\r
500 print '%-*s %s %s' % (width, guid_dict[value], value, GuidToCStructStr(value))\r
501\r
502 return\r
503\r
504\r
505#\r
506########## Code that runs when this script is imported into LLDB ###########\r
507#\r
508def __lldb_init_module (debugger, internal_dict):\r
509 # This initializer is being run from LLDB in the embedded command interpreter\r
510 # Make the options so we can generate the help text for the new LLDB\r
511 # command line command prior to registering it with LLDB below\r
512\r
513 global guid_dict\r
514\r
515 # Source Guid.xref file if we can find it\r
516 inputfile = os.getcwd()\r
517 inputfile += os.sep + os.pardir + os.sep + 'FV' + os.sep + 'Guid.xref'\r
518 with open(inputfile) as f:\r
519 for line in f:\r
520 data = line.split(' ')\r
521 if len(data) >= 2:\r
522 guid_dict[data[0].upper()] = data[1].strip('\n')\r
523\r
524 # init EFI specific type formaters\r
525 TypePrintFormating (debugger)\r
526\r
527\r
528 # add guid command\r
529 parser = create_guid_options()\r
530 efi_guid_command.__doc__ = parser.format_help()\r
531 debugger.HandleCommand('command script add -f lldbefi.efi_guid_command guid')\r
532\r
533\r
534 Target = debugger.GetTargetAtIndex(0)\r
535 if Target:\r
536 Breakpoint = Target.BreakpointCreateByName('SecGdbScriptBreak')\r
537 if Breakpoint.GetNumLocations() == 1:\r
538 # Set the emulator breakpoints, if we are in the emulator\r
539 debugger.HandleCommand("breakpoint command add -s python -F lldbefi.LoadEmulatorEfiSymbols {id}".format(id=Breakpoint.GetID()))\r
540 print 'Type r to run emulator. SecLldbScriptBreak armed. EFI modules should now get source level debugging in the emulator.'\r
EFI Development Kit II mirror for PVE