Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-11 14:28:08 +01:00
Code Issues Packages Projects Releases Wiki Activity
01f33f7552
CloverBootloader/MdeModulePkg/Universal/EbcDxe/EbcDebugger/EdbSymbol.c
SergeySlice 01f33f7552 detect unknown linux versions, 
stylish change: remove space between func and brace

Signed-off-by: SergeySlice <sergey.slice@gmail.com>
2020-04-23 12:08:10 +03:00

2231 lines
58 KiB
C
Raw Blame History

/** @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) {
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;
}
Reference in New Issue View Git Blame Copy Permalink