| /** @file | |
| Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include "Edb.h" | |
| /** | |
| Load single symbol entry. | |
| @param Object - Symbol file object | |
| @param Name - Symbol name | |
| @param ObjName - Object name | |
| @param Address - Symbol address | |
| @param Type - Symbol type | |
| @retval EFI_SUCCESS - add single symbol entry successfully | |
| **/ | |
| EFI_STATUS | |
| EdbLoadSymbolSingleEntry ( | |
| IN EFI_DEBUGGER_SYMBOL_OBJECT *Object, | |
| IN CHAR8 *Name, | |
| IN CHAR8 *ObjName, | |
| IN UINTN Address, | |
| IN EFI_DEBUGGER_SYMBOL_TYPE Type | |
| ) | |
| { | |
| EFI_DEBUGGER_SYMBOL_ENTRY *Entry; | |
| // | |
| // Check Count VS MaxCount | |
| // | |
| if (Object->EntryCount >= Object->MaxEntryCount) { | |
| // | |
| // reallocate (for codebuffer too) | |
| // TBD | |
| // | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| Entry = &Object->Entry[Object->EntryCount]; | |
| // | |
| // Print Debug info | |
| // | |
| if (sizeof (UINTN) == sizeof (UINT64)) { | |
| DEBUG ((DEBUG_ERROR, " Symbol: %a, Address: 0x%016lx (%d)\n", Name, (UINT64)Address, (UINTN)Type)); | |
| } else { | |
| DEBUG ((DEBUG_ERROR, " Symbol: %a, Address: 0x%08x (%d)\n", Name, Address, (UINTN)Type)); | |
| } | |
| // | |
| // Fill the entry - name, RVA, type | |
| // | |
| AsciiStrnCpyS (Entry->Name, sizeof (Entry->Name), Name, sizeof (Entry->Name) - 1); | |
| if (ObjName != NULL) { | |
| AsciiStrnCpyS (Entry->ObjName, sizeof (Entry->ObjName), ObjName, sizeof (Entry->ObjName) - 1); | |
| } | |
| Entry->Rva = Address % EFI_DEBUGGER_DEFAULT_LINK_IMAGEBASE; | |
| Entry->Type = Type; | |
| // | |
| // Increase Count | |
| // | |
| Object->EntryCount++; | |
| // | |
| // Done | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| typedef enum { | |
| EdbEbcMapParseStateUninitialized, | |
| EdbEbcMapParseStateSymbolStart, | |
| EdbEbcMapParseStateSeHandlerSymbol, | |
| EdbEbcMapParseStateFunctionSymbol, | |
| EdbEbcMapParseStateVarbssInitSymbol, | |
| EdbEbcMapParseStateCrtSymbol, | |
| EdbEbcMapParseStateVariableSymbol, | |
| EdbEbcMapParseStateStaticFunctionSymbol, | |
| EdbEbcMapParseStateMax, | |
| } EDB_EBC_MAP_PARSE_STATE; | |
| typedef enum { | |
| EdbEbcSymbolParseStateUninitialized, | |
| EdbEbcSymbolParseStateReadyForName, | |
| EdbEbcSymbolParseStateReadyForRVA, | |
| EdbEbcSymbolParseStateReadyForType, | |
| EdbEbcSymbolParseStateReadyForObject, | |
| EdbEbcSymbolParseStateMax, | |
| } EDB_EBC_SYMBOL_PARSE_STATE; | |
| /** | |
| The following code depends on the MAP file generated by IEC compiler (actually Microsoft linker). | |
| Sample as follows: EbcTest.map | |
| =============================================================================== | |
| EbcTest | |
| Timestamp is 45b02718 (Fri Jan 19 10:04:08 2007) | |
| Preferred load address is 10000000 | |
| Start Length Name Class | |
| 0001:00000000 00000370H .text CODE | |
| 0002:00000000 00000030H _VARBSS_INIT CODE | |
| 0003:00000000 00000004H .CRT$TSA DATA | |
| 0003:00000004 00000004H .CRT$TSC DATA | |
| 0003:00000008 00000004H .CRT$X DATA | |
| 0003:0000000c 00000008H .CRT$XCU DATA | |
| 0003:00000014 00000004H .CRT$Z DATA | |
| 0003:00000020 0000001cH .rdata DATA | |
| 0003:0000003c 00000000H .edata DATA | |
| 0003:0000003c 00000056H .rdata$debug DATA | |
| 0004:00000000 00000070H .data DATA | |
| 0004:00000070 00000020H .bss DATA | |
| Address Publics by Value Rva+Base Lib:Object | |
| 0000:00000000 ___safe_se_handler_table 00000000 <absolute> | |
| 0000:00000000 ___safe_se_handler_count 00000000 <absolute> | |
| 0001:00000042 TestSubRoutine 10000442 f EbcTest.obj | |
| 0001:0000011a EfiMain 1000051a f EbcTest.obj | |
| 0001:00000200 TestSubRoutineSub 10000600 f EbcTestSub.obj | |
| 0001:00000220 EfiStart 10000620 f EbcLib:EbcLib.obj | |
| 0002:00000000 varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest$c45b02717 10000800 f EbcTest.obj | |
| 0002:00000020 varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTestSub$c45af77f3 10000820 f EbcTestSub.obj | |
| 0003:00000000 CrtThunkBegin 10000a00 EbcLib:EbcLib.obj | |
| 0003:00000004 CrtThunkEnd 10000a04 EbcLib:EbcLib.obj | |
| 0003:00000008 CrtBegin 10000a08 EbcLib:EbcLib.obj | |
| 0003:00000014 CrtEnd 10000a14 EbcLib:EbcLib.obj | |
| 0004:00000070 TestStr 10000c70 EbcTest.obj | |
| 0004:00000078 TestVariable1 10000c78 EbcTest.obj | |
| 0004:00000080 TestSubVariableSub 10000c80 EbcTestSub.obj | |
| entry point at 0001:00000220 | |
| Static symbols | |
| 0001:00000000 TestSubRoutine2 10000400 f EbcTest.obj | |
| =============================================================================== | |
| **/ | |
| /** | |
| Load symbol entry by Iec. | |
| @param Object - Symbol file object | |
| @param BufferSize - Symbol file buffer size | |
| @param Buffer - Symbol file buffer | |
| @retval EFI_SUCCESS - add symbol entry successfully | |
| **/ | |
| EFI_STATUS | |
| EdbLoadSymbolEntryByIec ( | |
| IN EFI_DEBUGGER_SYMBOL_OBJECT *Object, | |
| IN UINTN BufferSize, | |
| IN VOID *Buffer | |
| ) | |
| { | |
| CHAR8 *LineBuffer; | |
| CHAR8 *FieldBuffer; | |
| EDB_EBC_MAP_PARSE_STATE MapParseState; | |
| EDB_EBC_SYMBOL_PARSE_STATE SymbolParseState; | |
| CHAR8 *Name; | |
| CHAR8 *ObjName; | |
| UINTN Address; | |
| EFI_DEBUGGER_SYMBOL_TYPE Type; | |
| // | |
| // Begin to parse the Buffer | |
| // | |
| LineBuffer = AsciiStrGetNewTokenLine (Buffer, "\n\r"); | |
| MapParseState = EdbEbcMapParseStateUninitialized; | |
| // | |
| // Check each line | |
| // | |
| while (LineBuffer != NULL) { | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer, " "); | |
| SymbolParseState = EdbEbcSymbolParseStateUninitialized; | |
| // | |
| // Init entry value | |
| // | |
| Name = NULL; | |
| ObjName = NULL; | |
| Address = 0; | |
| Type = EfiDebuggerSymbolTypeMax; | |
| // | |
| // Check each field | |
| // | |
| while (FieldBuffer != NULL) { | |
| if (AsciiStrCmp (FieldBuffer, "") == 0) { | |
| FieldBuffer = AsciiStrGetNextTokenField (" "); | |
| continue; | |
| } | |
| // | |
| // check "Address" | |
| // | |
| if (AsciiStrCmp (FieldBuffer, "Address") == 0) { | |
| MapParseState = EdbEbcMapParseStateSymbolStart; | |
| break; | |
| } | |
| // | |
| // check "Static" | |
| // | |
| if (AsciiStrCmp (FieldBuffer, "Static") == 0) { | |
| MapParseState = EdbEbcMapParseStateStaticFunctionSymbol; | |
| break; | |
| } | |
| if (MapParseState == EdbEbcMapParseStateUninitialized) { | |
| // | |
| // Do not parse anything until get "Address" or "Static" | |
| // | |
| break; | |
| } | |
| if (AsciiStrCmp (FieldBuffer, "entry") == 0) { | |
| // | |
| // Skip entry point | |
| // | |
| break; | |
| } | |
| // | |
| // Now we start to parse this line for Name, Address, and Object | |
| // | |
| switch (SymbolParseState) { | |
| case EdbEbcSymbolParseStateUninitialized: | |
| // | |
| // Get the Address | |
| // | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForName; | |
| break; | |
| case EdbEbcSymbolParseStateReadyForName: | |
| // | |
| // Get the Name | |
| // | |
| if (AsciiStrnCmp (FieldBuffer, "___safe_se_handler", AsciiStrLen ("___safe_se_handler")) == 0) { | |
| // | |
| // skip SeHandler | |
| // | |
| MapParseState = EdbEbcMapParseStateSeHandlerSymbol; | |
| goto ExitFieldParse; | |
| } else if (AsciiStrnCmp (FieldBuffer, "varbss_init", AsciiStrLen ("varbss_init")) == 0) { | |
| // | |
| // check VarbssInit | |
| // | |
| MapParseState = EdbEbcMapParseStateVarbssInitSymbol; | |
| // goto ExitFieldParse; | |
| Name = FieldBuffer; | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForRVA; | |
| } else if (AsciiStrnCmp (FieldBuffer, "Crt", AsciiStrLen ("Crt")) == 0) { | |
| // | |
| // check Crt | |
| // | |
| MapParseState = EdbEbcMapParseStateCrtSymbol; | |
| // goto ExitFieldParse; | |
| Name = FieldBuffer; | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForRVA; | |
| } else { | |
| // | |
| // Now, it is normal function | |
| // | |
| switch (MapParseState) { | |
| case EdbEbcMapParseStateSeHandlerSymbol: | |
| MapParseState = EdbEbcMapParseStateFunctionSymbol; | |
| break; | |
| case EdbEbcMapParseStateCrtSymbol: | |
| MapParseState = EdbEbcMapParseStateVariableSymbol; | |
| break; | |
| case EdbEbcMapParseStateFunctionSymbol: | |
| case EdbEbcMapParseStateVariableSymbol: | |
| case EdbEbcMapParseStateStaticFunctionSymbol: | |
| break; | |
| default: | |
| ASSERT (FALSE); | |
| break; | |
| } | |
| Name = FieldBuffer; | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForRVA; | |
| } | |
| break; | |
| case EdbEbcSymbolParseStateReadyForRVA: | |
| // | |
| // Get the RVA | |
| // | |
| Address = AsciiXtoi (FieldBuffer); | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForType; | |
| break; | |
| case EdbEbcSymbolParseStateReadyForType: | |
| // | |
| // Get the Type. This is optional, only for "f". | |
| // | |
| if (AsciiStrCmp (FieldBuffer, "f") == 0) { | |
| SymbolParseState = EdbEbcSymbolParseStateReadyForObject; | |
| switch (MapParseState) { | |
| case EdbEbcMapParseStateFunctionSymbol: | |
| case EdbEbcMapParseStateVarbssInitSymbol: | |
| Type = EfiDebuggerSymbolFunction; | |
| break; | |
| case EdbEbcMapParseStateStaticFunctionSymbol: | |
| Type = EfiDebuggerSymbolStaticFunction; | |
| break; | |
| default: | |
| ASSERT (FALSE); | |
| break; | |
| } | |
| break; | |
| } | |
| // | |
| // Else it should be Object. | |
| // let it bypass here | |
| // | |
| case EdbEbcSymbolParseStateReadyForObject: | |
| switch (Type) { | |
| case EfiDebuggerSymbolTypeMax: | |
| switch (MapParseState) { | |
| case EdbEbcMapParseStateVariableSymbol: | |
| case EdbEbcMapParseStateCrtSymbol: | |
| Type = EfiDebuggerSymbolGlobalVariable; | |
| break; | |
| case EdbEbcMapParseStateSeHandlerSymbol: | |
| // | |
| // do nothing here | |
| // | |
| break; | |
| default: | |
| ASSERT (FALSE); | |
| break; | |
| } | |
| break; | |
| case EfiDebuggerSymbolFunction: | |
| case EfiDebuggerSymbolStaticFunction: | |
| break; | |
| default: | |
| ASSERT (FALSE); | |
| break; | |
| } | |
| // | |
| // Get the Object | |
| // | |
| ObjName = FieldBuffer; | |
| SymbolParseState = EdbEbcSymbolParseStateUninitialized; | |
| break; | |
| default: | |
| ASSERT (FALSE); | |
| break; | |
| } | |
| // | |
| // Get the next field | |
| // | |
| FieldBuffer = AsciiStrGetNextTokenField (" "); | |
| } | |
| // | |
| // Add the entry if we get everything. | |
| // | |
| if ((Name != NULL) && (Type != EfiDebuggerSymbolTypeMax)) { | |
| EdbLoadSymbolSingleEntry (Object, Name, ObjName, Address, Type); | |
| } | |
| ExitFieldParse: | |
| // | |
| // Get the next line | |
| // | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| } | |
| // | |
| // Done | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Load symbol entry. | |
| @param Object - Symbol file object | |
| @param BufferSize - Symbol file buffer size | |
| @param Buffer - Symbol file buffer | |
| @retval EFI_SUCCESS - add symbol entry successfully | |
| **/ | |
| EFI_STATUS | |
| EdbLoadSymbolEntry ( | |
| IN EFI_DEBUGGER_SYMBOL_OBJECT *Object, | |
| IN UINTN BufferSize, | |
| IN VOID *Buffer | |
| ) | |
| { | |
| // | |
| // MAP file format depends on the compiler (actually linker). | |
| // | |
| // It is possible to check the different MAP file format in this routine. | |
| // Now only IEC is supported. | |
| // | |
| return EdbLoadSymbolEntryByIec (Object, BufferSize, Buffer); | |
| } | |
| /** | |
| Find symbol file by name. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param FileName - Symbol file name | |
| @param Index - Symbol file index | |
| @return Object | |
| **/ | |
| EFI_DEBUGGER_SYMBOL_OBJECT * | |
| EdbFindSymbolFile ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *FileName, | |
| IN OUT UINTN *Index OPTIONAL | |
| ) | |
| { | |
| UINTN ObjectIndex; | |
| // | |
| // Check each Object | |
| // | |
| for (ObjectIndex = 0; ObjectIndex < DebuggerPrivate->DebuggerSymbolContext.ObjectCount; ObjectIndex++) { | |
| if (StrCmp (FileName, DebuggerPrivate->DebuggerSymbolContext.Object[ObjectIndex].Name) == 0) { | |
| // | |
| // Name match, found it | |
| // | |
| if (Index != NULL) { | |
| *Index = ObjectIndex; | |
| } | |
| return &DebuggerPrivate->DebuggerSymbolContext.Object[ObjectIndex]; | |
| } | |
| } | |
| // | |
| // Not found | |
| // | |
| return NULL; | |
| } | |
| /** | |
| Find symbol by address. | |
| @param Address - Symbol address | |
| @param Type - Search type | |
| @param RetObject - Symbol object | |
| @param RetEntry - Symbol entry | |
| @return Nearest symbol address | |
| **/ | |
| UINTN | |
| EbdFindSymbolAddress ( | |
| IN UINTN Address, | |
| IN EDB_MATCH_SYMBOL_TYPE Type, | |
| OUT EFI_DEBUGGER_SYMBOL_OBJECT **RetObject, | |
| OUT EFI_DEBUGGER_SYMBOL_ENTRY **RetEntry | |
| ) | |
| { | |
| UINTN Index; | |
| UINTN SubIndex; | |
| UINTN CandidateLowerAddress; | |
| UINTN CandidateUpperAddress; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *Entry; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *LowEntry; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *UpperEntry; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *LowObject; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *UpperObject; | |
| if ((Type < 0) || (Type >= EdbMatchSymbolTypeMax)) { | |
| return 0; | |
| } | |
| // | |
| // Init | |
| // | |
| CandidateLowerAddress = 0; | |
| CandidateUpperAddress = (UINTN)-1; | |
| LowEntry = NULL; | |
| UpperEntry = NULL; | |
| LowObject = NULL; | |
| UpperObject = NULL; | |
| // | |
| // Go through each object | |
| // | |
| Object = mDebuggerPrivate.DebuggerSymbolContext.Object; | |
| for (Index = 0; Index < mDebuggerPrivate.DebuggerSymbolContext.ObjectCount; Index++, Object++) { | |
| if (Object->EntryCount == 0) { | |
| continue; | |
| } | |
| // | |
| // Go through each entry | |
| // | |
| Entry = Object->Entry; | |
| for (SubIndex = 0; SubIndex < Object->EntryCount; SubIndex++, Entry++) { | |
| if (Address != Entry->Rva + Object->BaseAddress) { | |
| // | |
| // Check for nearest address | |
| // | |
| if (Address > Entry->Rva + Object->BaseAddress) { | |
| // | |
| // Record it if Current RVA < Address | |
| // | |
| if (CandidateLowerAddress < Entry->Rva + Object->BaseAddress) { | |
| CandidateLowerAddress = Entry->Rva + Object->BaseAddress; | |
| LowEntry = Entry; | |
| LowObject = Object; | |
| } | |
| } else { | |
| // | |
| // Record it if Current RVA > Address | |
| // | |
| if (CandidateUpperAddress > Entry->Rva + Object->BaseAddress) { | |
| CandidateUpperAddress = Entry->Rva + Object->BaseAddress; | |
| UpperEntry = Entry; | |
| UpperObject = Object; | |
| } | |
| } | |
| continue; | |
| } | |
| // | |
| // address match, return directly | |
| // | |
| *RetEntry = Entry; | |
| *RetObject = Object; | |
| return Address; | |
| } | |
| } | |
| // | |
| // No Match, provide latest symbol | |
| // | |
| if ((Address - CandidateLowerAddress) < EFI_DEBUGGER_MAX_SYMBOL_ADDRESS_DELTA_VALUE) { | |
| // | |
| // Check for lower address | |
| // | |
| if (((Type == EdbMatchSymbolTypeNearestAddress) && | |
| ((CandidateUpperAddress - Address) > (Address - CandidateLowerAddress))) || | |
| (Type == EdbMatchSymbolTypeLowerAddress)) | |
| { | |
| // | |
| // return nearest lower address | |
| // | |
| *RetEntry = LowEntry; | |
| *RetObject = LowObject; | |
| return CandidateLowerAddress; | |
| } | |
| } | |
| if ((CandidateUpperAddress - Address) < EFI_DEBUGGER_MAX_SYMBOL_ADDRESS_DELTA_VALUE) { | |
| // | |
| // Check for upper address | |
| // | |
| if (((Type == EdbMatchSymbolTypeNearestAddress) && | |
| ((CandidateUpperAddress - Address) < (Address - CandidateLowerAddress))) || | |
| (Type == EdbMatchSymbolTypeUpperAddress)) | |
| { | |
| // | |
| // return nearest upper address | |
| // | |
| *RetEntry = UpperEntry; | |
| *RetObject = UpperObject; | |
| return CandidateUpperAddress; | |
| } | |
| } | |
| // | |
| // No match and nearest one, return NULL | |
| // | |
| return 0; | |
| } | |
| /** | |
| Unload symbol file by name. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param FileName - Symbol file name | |
| @retval EFI_SUCCESS - unload symbol successfully | |
| **/ | |
| EFI_STATUS | |
| EdbUnloadSymbol ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *FileName | |
| ) | |
| { | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| UINTN ObjectIndex; | |
| UINTN Index; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *OldEntry; | |
| UINTN OldEntryCount; | |
| UINTN MaxEntryCount; | |
| VOID **OldSourceBuffer; | |
| // | |
| // Find Symbol | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, FileName, &ObjectIndex); | |
| if (Object == NULL) { | |
| EDBPrint (L"SymbolFile is not loaded!\n"); | |
| return EFI_DEBUG_CONTINUE; | |
| } | |
| // | |
| // Record old data | |
| // | |
| Object = DebuggerPrivate->DebuggerSymbolContext.Object; | |
| OldEntry = Object->Entry; | |
| OldSourceBuffer = Object->SourceBuffer; | |
| MaxEntryCount = Object->MaxEntryCount; | |
| OldEntryCount = Object->EntryCount; | |
| // | |
| // Remove the matched Object | |
| // | |
| for (Index = ObjectIndex; Index < DebuggerPrivate->DebuggerSymbolContext.ObjectCount - 1; Index++) { | |
| CopyMem (&Object[Index], &Object[Index + 1], sizeof (EFI_DEBUGGER_SYMBOL_OBJECT)); | |
| } | |
| ZeroMem (&Object[Index], sizeof (Object[Index])); | |
| // | |
| // Move old data to new place | |
| // | |
| Object[Index].Entry = OldEntry; | |
| Object[Index].SourceBuffer = OldSourceBuffer; | |
| Object[Index].MaxEntryCount = MaxEntryCount; | |
| DebuggerPrivate->DebuggerSymbolContext.ObjectCount--; | |
| // | |
| // Clean old entry data | |
| // | |
| for (Index = 0; Index < OldEntryCount; Index++) { | |
| ZeroMem (&OldEntry[Index], sizeof (OldEntry[Index])); | |
| } | |
| // | |
| // Free OldSourceBuffer | |
| // | |
| for (Index = 0; OldSourceBuffer[Index] != NULL; Index++) { | |
| gBS->FreePool (OldSourceBuffer[Index]); | |
| OldSourceBuffer[Index] = NULL; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Load symbol file by name. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param FileName - Symbol file name | |
| @param BufferSize - Symbol file buffer size | |
| @param Buffer - Symbol file buffer | |
| @retval EFI_SUCCESS - load symbol successfully | |
| **/ | |
| EFI_STATUS | |
| EdbLoadSymbol ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *FileName, | |
| IN UINTN BufferSize, | |
| IN VOID *Buffer | |
| ) | |
| { | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| EFI_STATUS Status; | |
| // | |
| // Check duplicated File | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, FileName, NULL); | |
| if (Object != NULL) { | |
| Status = EdbUnloadSymbol (DebuggerPrivate, FileName); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "Unload Duplicated Symbol File Error!\n")); | |
| return Status; | |
| } | |
| } | |
| // | |
| // Check Count VS MaxCount | |
| // | |
| if (DebuggerPrivate->DebuggerSymbolContext.ObjectCount >= DebuggerPrivate->DebuggerSymbolContext.MaxObjectCount) { | |
| // | |
| // reallocate | |
| // TBD | |
| // | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| Object = &DebuggerPrivate->DebuggerSymbolContext.Object[DebuggerPrivate->DebuggerSymbolContext.ObjectCount]; | |
| // | |
| // Init Object | |
| // | |
| Object->EntryCount = 0; | |
| Object->MaxEntryCount = EFI_DEBUGGER_SYMBOL_ENTRY_MAX; | |
| // | |
| // Load SymbolEntry | |
| // | |
| DEBUG ((DEBUG_ERROR, "Symbol File: %s\n", FileName)); | |
| Status = EdbLoadSymbolEntry (Object, BufferSize, Buffer); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Fill Object value | |
| // | |
| StrnCpyS ( | |
| Object->Name, | |
| sizeof (Object->Name) / sizeof (CHAR16), | |
| FileName, | |
| (sizeof (Object->Name) / sizeof (CHAR16)) - 1 | |
| ); | |
| Object->BaseAddress = 0; | |
| // | |
| // Increase the object count | |
| // | |
| DebuggerPrivate->DebuggerSymbolContext.ObjectCount++; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Located PDB path name in PE image. | |
| @param ImageBase - base of PE to search | |
| @return Pointer into image at offset of PDB file name if PDB file name is found, | |
| Otherwise a pointer to an empty string. | |
| **/ | |
| CHAR8 * | |
| GetPdbPath ( | |
| VOID *ImageBase | |
| ) | |
| { | |
| CHAR8 *PdbPath; | |
| UINT32 DirCount; | |
| EFI_IMAGE_DOS_HEADER *DosHdr; | |
| EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr; | |
| EFI_IMAGE_OPTIONAL_HEADER32 *OptionalHdr32; | |
| EFI_IMAGE_OPTIONAL_HEADER64 *OptionalHdr64; | |
| EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; | |
| EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; | |
| VOID *CodeViewEntryPointer; | |
| // | |
| // Init value | |
| // | |
| CodeViewEntryPointer = NULL; | |
| PdbPath = NULL; | |
| DosHdr = ImageBase; | |
| // | |
| // Check magic | |
| // | |
| if (DosHdr->e_magic != EFI_IMAGE_DOS_SIGNATURE) { | |
| return NULL; | |
| } | |
| NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINT8 *)DosHdr + DosHdr->e_lfanew); | |
| // | |
| // Check Machine, filter for EBC | |
| // | |
| if (NtHdr->Pe32.FileHeader.Machine != EFI_IMAGE_MACHINE_EBC) { | |
| // | |
| // If not EBC, return NULL | |
| // | |
| return NULL; | |
| } | |
| // | |
| // Get DirectoryEntry | |
| // EBC spec says PE32+, but implementation uses PE32. So check dynamically here. | |
| // | |
| if (NtHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { | |
| OptionalHdr32 = (VOID *)&NtHdr->Pe32.OptionalHeader; | |
| DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(OptionalHdr32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); | |
| } else if (NtHdr->Pe32Plus.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) { | |
| OptionalHdr64 = (VOID *)&NtHdr->Pe32Plus.OptionalHeader; | |
| DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(OptionalHdr64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); | |
| } else { | |
| return NULL; | |
| } | |
| if (DirectoryEntry->VirtualAddress == 0) { | |
| return NULL; | |
| } | |
| // | |
| // Go through DirectoryEntry | |
| // | |
| for (DirCount = 0; | |
| (DirCount < DirectoryEntry->Size / sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) && CodeViewEntryPointer == NULL; | |
| DirCount++ | |
| ) | |
| { | |
| DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)(DirectoryEntry->VirtualAddress + (UINTN)ImageBase + DirCount * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)); | |
| if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) { | |
| // | |
| // Match DebugEntry, only CODEVIEW_SIGNATURE_NB10 and CODEVIEW_SIGNATURE_RSDS are supported. | |
| // | |
| CodeViewEntryPointer = (VOID *)((UINTN)DebugEntry->RVA + (UINTN)ImageBase); | |
| switch (*(UINT32 *)CodeViewEntryPointer) { | |
| case CODEVIEW_SIGNATURE_NB10: | |
| PdbPath = (CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY); | |
| break; | |
| case CODEVIEW_SIGNATURE_RSDS: | |
| PdbPath = (CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| // | |
| // Done successfully | |
| // | |
| return PdbPath; | |
| } | |
| /** | |
| Check whether PDB file and MAP file have same name. | |
| @param PdbFileName - PDB file name | |
| @param MapFileName - MAP file name | |
| @retval TRUE - PDB and MAP file name match | |
| @retval FALSE - PDB and MAP file name not match | |
| **/ | |
| BOOLEAN | |
| MatchPdbAndMap ( | |
| IN CHAR8 *PdbFileName, | |
| IN CHAR16 *MapFileName | |
| ) | |
| { | |
| UINTN PdbNameSize; | |
| UINTN MapNameSize; | |
| CHAR8 *PurePdbFileName; | |
| UINTN Index; | |
| // | |
| // remove dir name | |
| // | |
| PurePdbFileName = PdbFileName; | |
| for (Index = 0; PdbFileName[Index] != 0; Index++) { | |
| if (PdbFileName[Index] == '\\') { | |
| PurePdbFileName = &PdbFileName[Index + 1]; | |
| } | |
| } | |
| PdbFileName = PurePdbFileName; | |
| // | |
| // get size | |
| // | |
| PdbNameSize = AsciiStrLen (PdbFileName); | |
| MapNameSize = StrLen (MapFileName); | |
| if (PdbNameSize != MapNameSize) { | |
| return FALSE; | |
| } | |
| // | |
| // check the name | |
| // | |
| for (Index = 0; Index < MapNameSize - 4; Index++) { | |
| if ((PdbFileName[Index] | 0x20) != (MapFileName[Index] | 0x20)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| // | |
| // BUGBUG: work-around start | |
| // | |
| typedef struct { | |
| EFI_DEBUG_IMAGE_INFO *EfiDebugImageInfoTable; | |
| volatile UINT32 UpdateStatus; | |
| UINT32 TableSize; | |
| } EFI_DEBUG_IMAGE_INFO_TABLE_HEADER_OLD; | |
| EFI_DEBUG_IMAGE_INFO_TABLE_HEADER mDebugImageInfoTableHeader; | |
| /** | |
| For compatibility consideration, we handle 2 cases: | |
| 1) IA32: | |
| Old: New: | |
| +------------------------+ +------------------------+ | |
| | EfiDebugImageInfoTable | | UpdateStatus | | |
| +------------------------+ +------------------------+ | |
| | UpdateStatus | | TableSize | | |
| +------------------------+ +------------------------+ | |
| | TableSize | | EfiDebugImageInfoTable | | |
| +------------------------+ +------------------------+ | |
| 2) X64 and IPF: | |
| Old: New: | |
| +------------------------+ +------------------------+ | |
| | EfiDebugImageInfoTable | | UpdateStatus | | |
| | | +------------------------+ | |
| | | | TableSize | | |
| +------------------------+ +------------------------+ | |
| | UpdateStatus | | EfiDebugImageInfoTable | | |
| +------------------------+ | | | |
| | TableSize | | | | |
| +------------------------+ +------------------------+ | |
| @param DebugImageInfoTableHeader Point to the EFI_DEBUG_IMAGE_INFO_TABLE_HEADER structure. | |
| **/ | |
| VOID | |
| EdbFixDebugImageInfoTable ( | |
| IN OUT EFI_DEBUG_IMAGE_INFO_TABLE_HEADER **DebugImageInfoTableHeader | |
| ) | |
| { | |
| mDebugImageInfoTableHeader.EfiDebugImageInfoTable = ((EFI_DEBUG_IMAGE_INFO_TABLE_HEADER_OLD *)(*DebugImageInfoTableHeader))->EfiDebugImageInfoTable; | |
| mDebugImageInfoTableHeader.UpdateStatus = ((EFI_DEBUG_IMAGE_INFO_TABLE_HEADER_OLD *)(*DebugImageInfoTableHeader))->UpdateStatus; | |
| mDebugImageInfoTableHeader.TableSize = ((EFI_DEBUG_IMAGE_INFO_TABLE_HEADER_OLD *)(*DebugImageInfoTableHeader))->TableSize; | |
| if ((*DebugImageInfoTableHeader)->UpdateStatus > 3) { | |
| *DebugImageInfoTableHeader = &mDebugImageInfoTableHeader; | |
| return; | |
| } | |
| if ((*DebugImageInfoTableHeader)->TableSize % (EFI_PAGE_SIZE / (sizeof (VOID *))) != 0) { | |
| *DebugImageInfoTableHeader = &mDebugImageInfoTableHeader; | |
| return; | |
| } | |
| return; | |
| } | |
| // | |
| // BUGBUG: work-around end | |
| // | |
| /** | |
| Patch symbol RVA. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param FileName - Symbol file name | |
| @param SearchType - Search type for Object | |
| @retval EFI_SUCCESS - Patch symbol RVA successfully | |
| @retval EFI_NOT_FOUND - Symbol RVA base not found | |
| **/ | |
| EFI_STATUS | |
| EdbPatchSymbolRVA ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *FileName, | |
| IN EDB_EBC_IMAGE_RVA_SEARCH_TYPE SearchType | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN ImageNumber; | |
| EFI_DEBUG_IMAGE_INFO *ImageTable; | |
| CHAR8 *PdbPath; | |
| VOID *ImageBase; | |
| VOID *CandidateImageBase; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| if ((SearchType < 0) || (SearchType >= EdbEbcImageRvaSearchTypeMax)) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Get the related object | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, FileName, NULL); | |
| if (Object == NULL) { | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // Try again to get DebugImageInfoTable | |
| // | |
| if (mDebuggerPrivate.DebugImageInfoTableHeader == NULL) { | |
| Status = EfiGetSystemConfigurationTable ( | |
| &gEfiDebugImageInfoTableGuid, | |
| (VOID **)&mDebuggerPrivate.DebugImageInfoTableHeader | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| EDBPrint (L"DebugImageInfoTable not found!\n"); | |
| return Status; | |
| } | |
| } | |
| DEBUG ((DEBUG_ERROR, "DebugImageInfoTableHeader: %x\n", mDebuggerPrivate.DebugImageInfoTableHeader)); | |
| // | |
| // BUGBUG: work-around start | |
| // | |
| EdbFixDebugImageInfoTable (&mDebuggerPrivate.DebugImageInfoTableHeader); | |
| // | |
| // BUGBUG: work-around end | |
| // | |
| // | |
| // Go through DebugImageInfoTable for each Image | |
| // | |
| CandidateImageBase = NULL; | |
| ImageTable = mDebuggerPrivate.DebugImageInfoTableHeader->EfiDebugImageInfoTable; | |
| for (ImageNumber = 0; ImageNumber < mDebuggerPrivate.DebugImageInfoTableHeader->TableSize; ImageNumber++) { | |
| if (ImageTable[ImageNumber].NormalImage == NULL) { | |
| continue; | |
| } | |
| ImageBase = ImageTable[ImageNumber].NormalImage->LoadedImageProtocolInstance->ImageBase; | |
| // | |
| // Get PDB path | |
| // | |
| PdbPath = GetPdbPath (ImageBase); | |
| if (PdbPath == NULL) { | |
| continue; | |
| } | |
| // | |
| // Check PDB name | |
| // | |
| if (!MatchPdbAndMap (PdbPath, FileName)) { | |
| continue; | |
| } | |
| DEBUG ((DEBUG_ERROR, "ImageBase: %x\n", ImageBase)); | |
| // | |
| // Check SearchType | |
| // | |
| if ((SearchType == EdbEbcImageRvaSearchTypeAny) || (SearchType == EdbEbcImageRvaSearchTypeFirst)) { | |
| // | |
| // Assign base address and return | |
| // | |
| Object->BaseAddress = (UINTN)ImageBase; | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Get CandidateImageBase for EdbEbcImageRvaSearchTypeLast | |
| // | |
| CandidateImageBase = ImageBase; | |
| } | |
| // | |
| // Check EdbEbcImageRvaSearchTypeLast | |
| // | |
| if (SearchType == EdbEbcImageRvaSearchTypeLast) { | |
| if (CandidateImageBase == NULL) { | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // Assign base address and return | |
| // | |
| Object->BaseAddress = (UINTN)CandidateImageBase; | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // No match | |
| // | |
| return EFI_NOT_FOUND; | |
| } | |
| /** | |
| Check whether OBJ file and COD file have same name. | |
| @param ObjFileName - OBJ file name | |
| @param CodFileName - COD file name | |
| @retval TRUE - OBJ and COD file name match | |
| @retval FALSE - OBJ and COD file name not match | |
| **/ | |
| BOOLEAN | |
| MatchObjAndCod ( | |
| IN CHAR8 *ObjFileName, | |
| IN CHAR16 *CodFileName | |
| ) | |
| { | |
| UINTN ObjNameSize; | |
| UINTN CodNameSize; | |
| CHAR8 *PureObjFileName; | |
| UINTN Index; | |
| // | |
| // remove library name | |
| // | |
| PureObjFileName = ObjFileName; | |
| for (Index = 0; ObjFileName[Index] != 0; Index++) { | |
| if (ObjFileName[Index] == ':') { | |
| PureObjFileName = &ObjFileName[Index + 1]; | |
| break; | |
| } | |
| } | |
| ObjFileName = PureObjFileName; | |
| // | |
| // get size | |
| // | |
| ObjNameSize = AsciiStrLen (ObjFileName); | |
| CodNameSize = StrLen (CodFileName); | |
| if (ObjNameSize != CodNameSize) { | |
| return FALSE; | |
| } | |
| // | |
| // check the name | |
| // | |
| for (Index = 0; Index < CodNameSize - 4; Index++) { | |
| if ((ObjFileName[Index] | 0x20) != (CodFileName[Index] | 0x20)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| typedef enum { | |
| EdbEbcCodParseStateUninitialized, | |
| EdbEbcCodParseStateSymbolInitialized, | |
| EdbEbcCodParseStateSymbolStart, | |
| EdbEbcCodParseStateSymbolEnd, | |
| EdbEbcCodParseStateMax, | |
| } EDB_EBC_COD_PARSE_STATE; | |
| /** | |
| The following code depends on the COD file generated by IEC compiler. | |
| **/ | |
| /** | |
| Load code by symbol by Iec. | |
| @param Name - Symbol file name | |
| @param Buffer - Symbol file buffer | |
| @param BufferSize - Symbol file buffer size | |
| @param CodeBufferSize - Code buffer size | |
| @param FuncOffset - Code funcion offset | |
| @return CodeBuffer | |
| **/ | |
| CHAR8 * | |
| EdbLoadCodBySymbolByIec ( | |
| IN CHAR8 *Name, | |
| IN VOID *Buffer, | |
| IN UINTN BufferSize, | |
| OUT UINTN *CodeBufferSize, | |
| OUT UINTN *FuncOffset | |
| ) | |
| { | |
| CHAR8 *LineBuffer; | |
| CHAR8 *FieldBuffer; | |
| VOID *BufferStart; | |
| VOID *BufferEnd; | |
| UINTN Offset; | |
| EDB_EBC_COD_PARSE_STATE CodParseState; | |
| CHAR8 Char[2]; | |
| // | |
| // Init | |
| // | |
| Char[0] = 9; | |
| Char[1] = 0; | |
| LineBuffer = AsciiStrGetNewTokenLine (Buffer, "\n\r"); | |
| Offset = (UINTN)-1; | |
| BufferStart = NULL; | |
| BufferEnd = NULL; | |
| CodParseState = EdbEbcCodParseStateUninitialized; | |
| // | |
| // Check each line | |
| // | |
| while (LineBuffer != NULL) { | |
| switch (CodParseState) { | |
| case EdbEbcCodParseStateUninitialized: | |
| // | |
| // check mark_begin, begin to check line after this match | |
| // | |
| if (AsciiStrCmp (LineBuffer, "; mark_begin;") == 0) { | |
| CodParseState = EdbEbcCodParseStateSymbolInitialized; | |
| } | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| break; | |
| case EdbEbcCodParseStateSymbolInitialized: | |
| // | |
| // check mark_end, not check line after this match | |
| // | |
| if (AsciiStrCmp (LineBuffer, "; mark_end;") == 0) { | |
| CodParseState = EdbEbcCodParseStateUninitialized; | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| break; | |
| } | |
| // | |
| // not check this line if the first char is as follows | |
| // | |
| if ((*LineBuffer == 0) || | |
| (*LineBuffer == '$') || | |
| (*LineBuffer == ';') || | |
| (*LineBuffer == '_') || | |
| (*LineBuffer == ' ')) | |
| { | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| break; | |
| } | |
| // | |
| // get function name, function name is followed by char 0x09. | |
| // | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer, Char); | |
| ASSERT (FieldBuffer != NULL); | |
| if (AsciiStriCmp (FieldBuffer, Name) == 0) { | |
| BufferStart = FieldBuffer; | |
| CodParseState = EdbEbcCodParseStateSymbolStart; | |
| } | |
| PatchForAsciiStrTokenAfter (FieldBuffer, 0x9); | |
| // | |
| // Get next line | |
| // | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| break; | |
| case EdbEbcCodParseStateSymbolStart: | |
| // | |
| // check mark_end, if this match, means the function is found successfully. | |
| // | |
| if (AsciiStrCmp (LineBuffer, "; mark_end;") == 0) { | |
| CodParseState = EdbEbcCodParseStateSymbolEnd; | |
| // | |
| // prepare CodeBufferSize, FuncOffset, and FuncStart to return | |
| // | |
| BufferEnd = LineBuffer + sizeof ("; mark_end;") - 1; | |
| *CodeBufferSize = (UINTN)BufferEnd - (UINTN)BufferStart; | |
| *FuncOffset = Offset; | |
| PatchForAsciiStrTokenAfter (LineBuffer, '\n'); | |
| return BufferStart; | |
| } | |
| // | |
| // Get function offset | |
| // | |
| if ((Offset == (UINTN)-1) && | |
| (*LineBuffer == ' ')) | |
| { | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer + 2, " "); | |
| Offset = AsciiXtoi (FieldBuffer); | |
| PatchForAsciiStrTokenAfter (FieldBuffer, ' '); | |
| } | |
| // | |
| // Get next line | |
| // | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n\r"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| break; | |
| case EdbEbcCodParseStateSymbolEnd: | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| // | |
| // no function found | |
| // | |
| return NULL; | |
| } | |
| /** | |
| Load code by symbol. | |
| @param Name - Symbol file name | |
| @param Buffer - Symbol file buffer | |
| @param BufferSize - Symbol file buffer size | |
| @param CodeBufferSize - Code buffer size | |
| @param FuncOffset - Code funcion offset | |
| @return CodeBuffer | |
| **/ | |
| CHAR8 * | |
| EdbLoadCodBySymbol ( | |
| IN CHAR8 *Name, | |
| IN VOID *Buffer, | |
| IN UINTN BufferSize, | |
| OUT UINTN *CodeBufferSize, | |
| OUT UINTN *FuncOffset | |
| ) | |
| { | |
| // | |
| // COD file format depends on the compiler. | |
| // | |
| // It is possible to check the different COD file format in this routine. | |
| // Now only IEC is supported. | |
| // | |
| return EdbLoadCodBySymbolByIec (Name, Buffer, BufferSize, CodeBufferSize, FuncOffset); | |
| } | |
| /** | |
| Find code from object. | |
| @param DebuggerPrivate EBC Debugger private data structure | |
| @param Object - Symbol object | |
| @param FileName - File name | |
| **/ | |
| VOID * | |
| EdbFindCodeFromObject ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN EFI_DEBUGGER_SYMBOL_OBJECT *Object, | |
| IN CHAR16 *FileName | |
| ) | |
| { | |
| UINTN EntryIndex; | |
| // | |
| // Go througn each Entry in this Object | |
| // | |
| for (EntryIndex = 0; EntryIndex < Object->EntryCount; EntryIndex++) { | |
| // | |
| // This check is for Function only | |
| // | |
| if ((Object->Entry[EntryIndex].Type != EfiDebuggerSymbolFunction) && | |
| (Object->Entry[EntryIndex].Type != EfiDebuggerSymbolStaticFunction)) | |
| { | |
| continue; | |
| } | |
| // | |
| // Skip match varbss_init function, because they has no source code | |
| // | |
| if (AsciiStrnCmp (Object->Entry[EntryIndex].Name, "varbss_init", sizeof ("varbss_init") - 1) == 0) { | |
| continue; | |
| } | |
| // | |
| // check the name | |
| // | |
| if (!MatchObjAndCod (Object->Entry[EntryIndex].ObjName, FileName)) { | |
| continue; | |
| } | |
| // | |
| // found it, return source buffer | |
| // | |
| if (Object->Entry[EntryIndex].CodBuffer != NULL) { | |
| return Object->Entry[EntryIndex].SourceBuffer; | |
| } | |
| } | |
| // | |
| // not found | |
| // | |
| return NULL; | |
| } | |
| /** | |
| Load code. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param MapFileName - Symbol file name | |
| @param FileName - Code file name | |
| @param BufferSize - Code file buffer size | |
| @param Buffer - Code file buffer | |
| @retval EFI_SUCCESS - Code loaded successfully | |
| **/ | |
| EFI_STATUS | |
| EdbLoadCode ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *MapFileName, | |
| IN CHAR16 *FileName, | |
| IN UINTN BufferSize, | |
| IN VOID *Buffer | |
| ) | |
| { | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| UINTN ObjectIndex; | |
| UINTN EntryIndex; | |
| VOID *SourceBuffer; | |
| EFI_STATUS Status; | |
| // | |
| // Find Symbol | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, MapFileName, &ObjectIndex); | |
| if (Object == NULL) { | |
| EDBPrint (L"SymbolFile is not loaded!\n"); | |
| return EFI_NOT_FOUND; | |
| } else { | |
| // | |
| // Check duplicated File | |
| // | |
| SourceBuffer = EdbFindCodeFromObject (DebuggerPrivate, Object, FileName); | |
| if (SourceBuffer != NULL) { | |
| // | |
| // unnload duplicated code | |
| // | |
| Status = EdbUnloadCode (DebuggerPrivate, MapFileName, FileName, &SourceBuffer); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "Unload Duplicated Code File Error!\n")); | |
| return Status; | |
| } | |
| Status = EdbDeleteCodeBuffer (DebuggerPrivate, MapFileName, FileName, SourceBuffer); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "Delete Duplicated Code File Error!\n")); | |
| return Status; | |
| } | |
| } | |
| } | |
| // | |
| // Go through each SymbolEntry | |
| // | |
| for (EntryIndex = 0; EntryIndex < Object->EntryCount; EntryIndex++) { | |
| // | |
| // load symbol for function only | |
| // | |
| if ((Object->Entry[EntryIndex].Type != EfiDebuggerSymbolFunction) && | |
| (Object->Entry[EntryIndex].Type != EfiDebuggerSymbolStaticFunction)) | |
| { | |
| continue; | |
| } | |
| // | |
| // skip varbss_init | |
| // | |
| if (AsciiStrnCmp (Object->Entry[EntryIndex].Name, "varbss_init", sizeof ("varbss_init") - 1) == 0) { | |
| continue; | |
| } | |
| // | |
| // Check the name | |
| // | |
| if (!MatchObjAndCod (Object->Entry[EntryIndex].ObjName, FileName)) { | |
| continue; | |
| } | |
| // | |
| // load code for this symbol | |
| // | |
| Object->Entry[EntryIndex].CodBuffer = EdbLoadCodBySymbol ( | |
| Object->Entry[EntryIndex].Name, | |
| Buffer, | |
| BufferSize, | |
| &Object->Entry[EntryIndex].CodBufferSize, | |
| &Object->Entry[EntryIndex].FuncOffsetBase | |
| ); | |
| if (Object->Entry[EntryIndex].CodBuffer != NULL) { | |
| Object->Entry[EntryIndex].SourceBuffer = Buffer; | |
| } | |
| } | |
| // | |
| // patch end '\0' for each code buffer | |
| // | |
| for (EntryIndex = 0; EntryIndex < Object->EntryCount; EntryIndex++) { | |
| if (Object->Entry[EntryIndex].CodBuffer != NULL) { | |
| *((UINT8 *)Object->Entry[EntryIndex].CodBuffer + Object->Entry[EntryIndex].CodBufferSize) = 0; | |
| DEBUG ((DEBUG_ERROR, " CodeSymbol: %a, FuncOffset: 0x05%x\n", Object->Entry[EntryIndex].Name, Object->Entry[EntryIndex].FuncOffsetBase)); | |
| // DEBUG ((DEBUG_ERROR, " [CODE]:\n%a\n", Object->Entry[EntryIndex].CodBuffer)); | |
| } | |
| } | |
| // | |
| // Done | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Unload code. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param MapFileName - Symbol file name | |
| @param FileName - Code file name | |
| @param Buffer - Code file buffer | |
| @retval EFI_SUCCESS - Code unloaded successfully | |
| **/ | |
| EFI_STATUS | |
| EdbUnloadCode ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *MapFileName, | |
| IN CHAR16 *FileName, | |
| OUT VOID **Buffer | |
| ) | |
| { | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| UINTN ObjectIndex; | |
| UINTN EntryIndex; | |
| // | |
| // Find Symbol | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, MapFileName, &ObjectIndex); | |
| if (Object == NULL) { | |
| EDBPrint (L"SymbolFile is not loaded!\n"); | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // Find code | |
| // | |
| *Buffer = EdbFindCodeFromObject (DebuggerPrivate, Object, FileName); | |
| if (*Buffer == NULL) { | |
| EDBPrint (L"CodeFile is not loaded!\n"); | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // go through each entry | |
| // | |
| for (EntryIndex = 0; EntryIndex < Object->EntryCount; EntryIndex++) { | |
| if ((Object->Entry[EntryIndex].Type != EfiDebuggerSymbolFunction) && | |
| (Object->Entry[EntryIndex].Type != EfiDebuggerSymbolStaticFunction)) | |
| { | |
| continue; | |
| } | |
| if (AsciiStrnCmp (Object->Entry[EntryIndex].Name, "varbss_init", sizeof ("varbss_init") - 1) == 0) { | |
| continue; | |
| } | |
| if (!MatchObjAndCod (Object->Entry[EntryIndex].ObjName, FileName)) { | |
| continue; | |
| } | |
| // | |
| // clean up the buffer | |
| // | |
| Object->Entry[EntryIndex].CodBuffer = NULL; | |
| Object->Entry[EntryIndex].CodBufferSize = 0; | |
| Object->Entry[EntryIndex].FuncOffsetBase = 0; | |
| Object->Entry[EntryIndex].SourceBuffer = NULL; | |
| } | |
| // | |
| // Done | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Add code buffer. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param MapFileName - Symbol file name | |
| @param CodeFileName - Code file name | |
| @param SourceBufferSize- Code buffer size | |
| @param SourceBuffer - Code buffer | |
| @retval EFI_SUCCESS - CodeBuffer added successfully | |
| **/ | |
| EFI_STATUS | |
| EdbAddCodeBuffer ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *MapFileName, | |
| IN CHAR16 *CodeFileName, | |
| IN UINTN SourceBufferSize, | |
| IN VOID *SourceBuffer | |
| ) | |
| { | |
| UINTN Index; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| // | |
| // Find Symbol | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, MapFileName, NULL); | |
| if (Object == NULL) { | |
| EDBPrint (L"SymbolFile is not loaded!\n"); | |
| return EFI_NOT_FOUND; | |
| } | |
| // | |
| // Add it to last entry | |
| // | |
| for (Index = 0; Object->SourceBuffer[Index] != NULL; Index++) { | |
| } | |
| Object->SourceBuffer[Index] = SourceBuffer; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Delete code buffer. | |
| @param DebuggerPrivate - EBC Debugger private data structure | |
| @param MapFileName - Symbol file name | |
| @param CodeFileName - Code file name | |
| @param SourceBuffer - Code buffer | |
| @retval EFI_SUCCESS - CodeBuffer deleted successfully | |
| **/ | |
| EFI_STATUS | |
| EdbDeleteCodeBuffer ( | |
| IN EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate, | |
| IN CHAR16 *MapFileName, | |
| IN CHAR16 *CodeFileName, | |
| IN VOID *SourceBuffer | |
| ) | |
| { | |
| UINTN Index; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| // | |
| // Find Symbol | |
| // | |
| Object = EdbFindSymbolFile (DebuggerPrivate, MapFileName, NULL); | |
| if (Object == NULL) { | |
| EDBPrint (L"SymbolFile is not loaded!\n"); | |
| return EFI_NOT_FOUND; | |
| } | |
| for (Index = 0; Object->SourceBuffer[Index] != NULL; Index++) { | |
| // | |
| // free the buffer if match | |
| // | |
| if (Object->SourceBuffer[Index] == SourceBuffer) { | |
| gBS->FreePool (SourceBuffer); | |
| break; | |
| } | |
| } | |
| if (Object->SourceBuffer[Index] == NULL) { | |
| // | |
| // not return NOT_FOUND | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // remove the entry | |
| // | |
| Object->SourceBuffer[Index] = NULL; | |
| for (Index = Index + 1; Object->SourceBuffer[Index] != NULL; Index++) { | |
| Object->SourceBuffer[Index - 1] = Object->SourceBuffer[Index]; | |
| } | |
| Object->SourceBuffer[Index - 1] = NULL; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Find the symbol string according to address. | |
| @param Address - Symbol address | |
| @return Symbol string | |
| **/ | |
| CHAR8 * | |
| FindSymbolStr ( | |
| IN UINTN Address | |
| ) | |
| { | |
| UINTN ObjectIndex; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| UINTN EntryIndex; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *Entry; | |
| // | |
| // need we display symbol | |
| // | |
| if (!mDebuggerPrivate.DebuggerSymbolContext.DisplaySymbol) { | |
| return NULL; | |
| } | |
| // | |
| // Go through each object and entry | |
| // | |
| Object = mDebuggerPrivate.DebuggerSymbolContext.Object; | |
| for (ObjectIndex = 0; ObjectIndex < mDebuggerPrivate.DebuggerSymbolContext.ObjectCount; ObjectIndex++) { | |
| Entry = Object[ObjectIndex].Entry; | |
| for (EntryIndex = 0; EntryIndex < Object[ObjectIndex].EntryCount; EntryIndex++) { | |
| // | |
| // if Address match, return Name | |
| // | |
| if (Address == (Entry[EntryIndex].Rva + Object[ObjectIndex].BaseAddress)) { | |
| return Entry[EntryIndex].Name; | |
| } | |
| } | |
| } | |
| // | |
| // not found | |
| // | |
| return NULL; | |
| } | |
| /** | |
| Get line number and offset from this line in code file. | |
| @param Line - Line buffer in code file | |
| @param Offset - Offset to functin entry | |
| @return Line number | |
| **/ | |
| UINTN | |
| EdbGetLineNumberAndOffsetFromThisLine ( | |
| IN VOID *Line, | |
| OUT UINTN *Offset | |
| ) | |
| { | |
| UINTN LineNumber; | |
| CHAR8 *LineBuffer; | |
| CHAR8 *FieldBuffer; | |
| LineNumber = (UINTN)-1; | |
| LineBuffer = Line; | |
| *Offset = (UINTN)-1; | |
| while (LineBuffer != NULL) { | |
| // | |
| // Check candidate | |
| // | |
| if (*LineBuffer != ' ') { | |
| return (UINTN)-1; | |
| } | |
| // | |
| // Get Offset | |
| // | |
| if (*(LineBuffer + 2) != ' ') { | |
| if (*Offset == (UINTN)-1) { | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer + 2, " "); | |
| *Offset = AsciiXtoi (FieldBuffer); | |
| PatchForAsciiStrTokenAfter (FieldBuffer, ' '); | |
| } | |
| } | |
| // | |
| // 1. assembly instruction | |
| // | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer, ":"); | |
| // | |
| // 2. file path | |
| // | |
| FieldBuffer = AsciiStrGetNextTokenField (":"); | |
| PatchForAsciiStrTokenBefore (FieldBuffer, ':'); | |
| if (FieldBuffer == NULL) { | |
| // | |
| // candidate found | |
| // | |
| LineNumber = 0; | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| continue; | |
| } | |
| // | |
| // 3. line number | |
| // | |
| FieldBuffer = AsciiStrGetNextTokenField (":"); | |
| PatchForAsciiStrTokenBefore (FieldBuffer, ':'); | |
| if (FieldBuffer == NULL) { | |
| // | |
| // impossible, TBD? | |
| // | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| continue; | |
| } | |
| LineNumber = AsciiAtoi (FieldBuffer); | |
| // | |
| // Not patch after | |
| // | |
| return LineNumber; | |
| } | |
| return (UINTN)-1; | |
| } | |
| typedef enum { | |
| EdbEbcLineSearchTypeAny, | |
| EdbEbcLineSearchTypeFirst, | |
| EdbEbcLineSearchTypeLast, | |
| EdbEbcLineSearchTypeMax, | |
| } EDB_EBC_LINE_SEARCH_TYPE; | |
| /** | |
| Get line number from this code file. | |
| @param Entry - Symbol entry | |
| @param FuncOffset - Offset to functin entry | |
| @param SearchType - Search type for the code | |
| @return Line number | |
| **/ | |
| UINTN | |
| EdbGetLineNumberFromCode ( | |
| IN EFI_DEBUGGER_SYMBOL_ENTRY *Entry, | |
| IN UINTN FuncOffset, | |
| IN EDB_EBC_LINE_SEARCH_TYPE SearchType | |
| ) | |
| { | |
| CHAR8 *LineBuffer; | |
| UINTN LineNumber; | |
| UINTN Offset; | |
| UINTN CandidateLineNumber; | |
| UINTN CandidateOffset; | |
| if ((SearchType < 0) || (SearchType >= EdbEbcLineSearchTypeMax)) { | |
| return (UINTN)-1; | |
| } | |
| LineNumber = (UINTN)-1; | |
| CandidateLineNumber = (UINTN)-1; | |
| CandidateOffset = (UINTN)-1; | |
| LineBuffer = AsciiStrGetNewTokenLine (Entry->CodBuffer, "\n"); | |
| while (LineBuffer != NULL) { | |
| if (*LineBuffer != ' ') { | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| continue; | |
| } | |
| // | |
| // Get Info | |
| // | |
| LineNumber = EdbGetLineNumberAndOffsetFromThisLine (LineBuffer, &Offset); | |
| // | |
| // Check offset | |
| // | |
| if (Offset != FuncOffset) { | |
| // | |
| // Check last offset match | |
| // | |
| if (CandidateOffset == FuncOffset) { | |
| if (SearchType == EdbEbcLineSearchTypeLast) { | |
| PatchForAsciiStrTokenAfter (LineBuffer, '\n'); | |
| if (CandidateLineNumber != LineNumber) { | |
| return CandidateLineNumber; | |
| } else { | |
| return (UINTN)-1; | |
| } | |
| } else { | |
| // | |
| // impossible, TBD? | |
| // | |
| } | |
| } | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| CandidateLineNumber = LineNumber; | |
| continue; | |
| } | |
| // | |
| // Offset match, more check | |
| // | |
| if (SearchType == EdbEbcLineSearchTypeAny) { | |
| PatchForAsciiStrTokenAfter (LineBuffer, '\n'); | |
| return LineNumber; | |
| } | |
| if (SearchType == EdbEbcLineSearchTypeFirst) { | |
| // | |
| // Check last line | |
| // | |
| PatchForAsciiStrTokenAfter (LineBuffer, '\n'); | |
| if (CandidateLineNumber != LineNumber) { | |
| return LineNumber; | |
| } else { | |
| return (UINTN)-1; | |
| } | |
| } | |
| CandidateLineNumber = LineNumber; | |
| CandidateOffset = Offset; | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| } | |
| // | |
| // Check last offset match | |
| // | |
| if (CandidateOffset == FuncOffset) { | |
| if (SearchType == EdbEbcLineSearchTypeLast) { | |
| return CandidateLineNumber; | |
| } | |
| } | |
| return (UINTN)-1; | |
| } | |
| /** | |
| Get the source string from this code file by line. | |
| @param Entry - Symbol entry | |
| @param LineNumber - line number | |
| @param FuncEnd - Function end | |
| @return Funtion start | |
| **/ | |
| VOID * | |
| EdbGetSourceStrFromCodeByLine ( | |
| IN EFI_DEBUGGER_SYMBOL_ENTRY *Entry, | |
| IN UINTN LineNumber, | |
| IN VOID **FuncEnd | |
| ) | |
| { | |
| CHAR8 *LineBuffer; | |
| CHAR8 *FieldBuffer; | |
| VOID *FuncStart; | |
| UINTN Number; | |
| FuncStart = NULL; | |
| LineBuffer = AsciiStrGetNewTokenLine (Entry->CodBuffer, "\n"); | |
| while (LineBuffer != NULL) { | |
| if (*LineBuffer != ';') { | |
| if (FuncStart != NULL) { | |
| // | |
| // Over | |
| // | |
| *FuncEnd = LineBuffer - 1; | |
| PatchForAsciiStrTokenAfter (LineBuffer, '\n'); | |
| return FuncStart; | |
| } | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| continue; | |
| } | |
| // | |
| // Check LineNumber | |
| // | |
| FieldBuffer = AsciiStrGetNewTokenField (LineBuffer + 1, " "); | |
| Number = AsciiAtoi (FieldBuffer); | |
| PatchForAsciiStrTokenAfter (FieldBuffer, ' '); | |
| if (Number != LineNumber) { | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| continue; | |
| } | |
| // | |
| // Line match, get line number | |
| // | |
| if (FuncStart == NULL) { | |
| FuncStart = LineBuffer; | |
| } | |
| LineBuffer = AsciiStrGetNextTokenLine ("\n"); | |
| PatchForAsciiStrTokenBefore (LineBuffer, '\n'); | |
| } | |
| return NULL; | |
| } | |
| /** | |
| Get source string from this code file. | |
| @param Entry - Symbol entry | |
| @param FuncOffset - Offset to functin entry | |
| @param FuncEnd - Function end | |
| @retval Funtion start | |
| **/ | |
| VOID * | |
| EdbGetSourceStrFromCode ( | |
| IN EFI_DEBUGGER_SYMBOL_ENTRY *Entry, | |
| IN UINTN FuncOffset, | |
| IN VOID **FuncEnd | |
| ) | |
| { | |
| UINTN LineNumber; | |
| // | |
| // Only search the last line, then display | |
| // | |
| LineNumber = EdbGetLineNumberFromCode (Entry, FuncOffset, EdbEbcLineSearchTypeLast); | |
| if (LineNumber == (UINTN)-1) { | |
| return NULL; | |
| } | |
| return EdbGetSourceStrFromCodeByLine (Entry, LineNumber, FuncEnd); | |
| } | |
| /** | |
| Print source. | |
| @param Address - Instruction address | |
| @param IsPrint - Whether need to print | |
| @retval 1 - find the source | |
| @retval 0 - not find the source | |
| **/ | |
| UINTN | |
| EdbPrintSource ( | |
| IN UINTN Address, | |
| IN BOOLEAN IsPrint | |
| ) | |
| { | |
| UINTN SymbolAddress; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *RetObject; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *RetEntry; | |
| UINTN FuncOffset; | |
| UINT8 *FuncStart; | |
| UINT8 *FuncEnd; | |
| UINT8 *FuncIndex; | |
| CHAR8 Buffer[EFI_DEBUG_MAX_PRINT_BUFFER]; | |
| UINTN BufferSize; | |
| // | |
| // need we display symbol | |
| // | |
| if (!mDebuggerPrivate.DebuggerSymbolContext.DisplaySymbol) { | |
| return 0; | |
| } | |
| // | |
| // find the symbol address | |
| // | |
| SymbolAddress = EbdFindSymbolAddress ( | |
| Address, | |
| EdbMatchSymbolTypeLowerAddress, | |
| &RetObject, | |
| &RetEntry | |
| ); | |
| if ((SymbolAddress == 0) || (RetEntry == NULL)) { | |
| return 0; | |
| } | |
| FuncOffset = Address - SymbolAddress + RetEntry->FuncOffsetBase; | |
| // | |
| // Get Func String | |
| // | |
| FuncStart = EdbGetSourceStrFromCode (RetEntry, FuncOffset, (VOID **)&FuncEnd); | |
| if (FuncStart == NULL) { | |
| return 0; | |
| } | |
| // | |
| // check whether need to real print | |
| // | |
| if (!IsPrint) { | |
| return 1; | |
| } | |
| *(UINT8 *)FuncEnd = 0; | |
| // | |
| // seperate buffer by \n, so that \r can be added. | |
| // | |
| FuncIndex = FuncStart; | |
| while (*FuncIndex != 0) { | |
| if (*FuncIndex == '\n') { | |
| if ((FuncIndex - FuncStart) < (EFI_DEBUG_MAX_PRINT_BUFFER - 3)) { | |
| BufferSize = FuncIndex - FuncStart; | |
| } else { | |
| BufferSize = EFI_DEBUG_MAX_PRINT_BUFFER - 3; | |
| } | |
| if (BufferSize != 0) { | |
| CopyMem (Buffer, FuncStart, BufferSize); | |
| } | |
| Buffer[BufferSize] = 0; | |
| EDBPrint (L"%a\n", Buffer); | |
| FuncStart = FuncIndex + 1; | |
| FuncIndex = FuncStart; | |
| } else { | |
| FuncIndex++; | |
| } | |
| } | |
| // | |
| // Patch the end | |
| // | |
| *(UINT8 *)FuncEnd = '\n'; | |
| return 1; | |
| } | |
| /** | |
| Get Mapfile and SymbolName from one symbol format: [MapFileName:]SymbolName. | |
| @param Symbol - whole Symbol name | |
| @param MapfileName - the mapfile name in the symbol | |
| @param SymbolName - the symbol name in the symbol | |
| **/ | |
| VOID | |
| GetMapfileAndSymbol ( | |
| IN CHAR16 *Symbol, | |
| OUT CHAR16 **MapfileName, | |
| OUT CHAR16 **SymbolName | |
| ) | |
| { | |
| CHAR16 *Ch; | |
| *MapfileName = NULL; | |
| *SymbolName = Symbol; | |
| for (Ch = Symbol; *Ch != 0; Ch++) { | |
| // | |
| // Find split char | |
| // | |
| if (*Ch == L':') { | |
| *MapfileName = Symbol; | |
| *Ch = 0; | |
| *SymbolName = Ch + 1; | |
| break; | |
| } | |
| } | |
| return; | |
| } | |
| /** | |
| Convert a symbol to an address. | |
| @param Symbol - Symbol name | |
| @param Address - Symbol address | |
| @retval EFI_SUCCESS - symbol found and address returned. | |
| @retval EFI_NOT_FOUND - symbol not found | |
| @retval EFI_NO_MAPPING - duplicated symbol not found | |
| **/ | |
| EFI_STATUS | |
| Symboltoi ( | |
| IN CHAR16 *Symbol, | |
| OUT UINTN *Address | |
| ) | |
| { | |
| UINTN ObjectIndex; | |
| EFI_DEBUGGER_SYMBOL_OBJECT *Object; | |
| UINTN EntryIndex; | |
| EFI_DEBUGGER_SYMBOL_ENTRY *Entry; | |
| CHAR16 *SymbolName; | |
| CHAR16 *MapfileName; | |
| // | |
| // Split one symbol to mapfile name and symbol name | |
| // | |
| GetMapfileAndSymbol (Symbol, &MapfileName, &SymbolName); | |
| *Address = 0; | |
| // | |
| // Go through each object | |
| // | |
| Object = mDebuggerPrivate.DebuggerSymbolContext.Object; | |
| for (ObjectIndex = 0; ObjectIndex < mDebuggerPrivate.DebuggerSymbolContext.ObjectCount; ObjectIndex++) { | |
| // | |
| // Check MapfileName | |
| // | |
| if ((MapfileName != NULL) && (StriCmp (Object[ObjectIndex].Name, MapfileName) != 0)) { | |
| continue; | |
| } | |
| // | |
| // Go through each entry | |
| // | |
| Entry = Object[ObjectIndex].Entry; | |
| for (EntryIndex = 0; EntryIndex < Object[ObjectIndex].EntryCount; EntryIndex++) { | |
| // | |
| // Check SymbolName (case sensitive) | |
| // | |
| if (StrCmpUnicodeAndAscii (SymbolName, Entry[EntryIndex].Name) == 0) { | |
| if ((*Address != 0) && (MapfileName == NULL)) { | |
| // | |
| // Find the duplicated symbol | |
| // | |
| EDBPrint (L"Duplicated Symbol found!\n"); | |
| return EFI_NO_MAPPING; | |
| } else { | |
| // | |
| // record Address | |
| // | |
| *Address = (Entry[EntryIndex].Rva + Object[ObjectIndex].BaseAddress); | |
| } | |
| } | |
| } | |
| } | |
| if (*Address == 0) { | |
| // | |
| // Not found | |
| // | |
| return EFI_NOT_FOUND; | |
| } | |
| return EFI_SUCCESS; | |
| } |