/*++

Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution.  The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php

THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

Module Name:

  EdbSymbol.c

Abstract:


--*/

#include "Edb.h"

EFI_STATUS
EdbLoadSymbolSingleEntry (
  IN EFI_DEBUGGER_SYMBOL_OBJECT  *Object,
  IN CHAR8                       *Name,
  IN CHAR8                       *ObjName,
  IN UINTN                       Address,
  IN EFI_DEBUGGER_SYMBOL_TYPE    Type
  )
/*++

Routine Description:

  Load single symbol entry

Arguments:

  Object          - Symbol file object
  Name            - Symbol name
  ObjName         - Object name
  Address         - Symbol address
  Type            - Symbol type

Returns:

  EFI_SUCCESS - add single symbol entry successfully

--*/
{
  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
===============================================================================

--*/
EFI_STATUS
EdbLoadSymbolEntryByIec (
  IN EFI_DEBUGGER_SYMBOL_OBJECT  *Object,
  IN UINTN                       BufferSize,
  IN VOID                        *Buffer
  )
/*++

Routine Description:

  Load symbol entry by Iec

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  Object          - Symbol file object
  BufferSize      - Symbol file buffer size
  Buffer          - Symbol file buffer

Returns:

  EFI_SUCCESS - add symbol entry successfully

--*/
{
  CHAR8                      *LineBuffer;
  CHAR8                      *FieldBuffer;
  EFI_DEBUGGER_SYMBOL_ENTRY  *Entry;
  EDB_EBC_MAP_PARSE_STATE    MapParseState;
  EDB_EBC_SYMBOL_PARSE_STATE SymbolParseState;
  CHAR8                      *Name;
  CHAR8                      *ObjName;
  UINTN                      Address;
  EFI_DEBUGGER_SYMBOL_TYPE   Type;

  Entry = Object->Entry;

  //
  // 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;
}

EFI_STATUS
EdbLoadSymbolEntry (
  IN EFI_DEBUGGER_SYMBOL_OBJECT  *Object,
  IN UINTN                       BufferSize,
  IN VOID                        *Buffer
  )
/*++

Routine Description:

  Load symbol entry

Arguments:

  Object          - Symbol file object
  BufferSize      - Symbol file buffer size
  Buffer          - Symbol file buffer

Returns:

  EFI_SUCCESS - add symbol entry successfully

--*/
{
  //
  // 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);
}

EFI_DEBUGGER_SYMBOL_OBJECT *
EdbFindSymbolFile (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN CHAR16                      *FileName,
  IN OUT UINTN                   *Index OPTIONAL
  )
/*++

Routine Description:

  Find symbol file by name

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  FileName        - Symbol file name
  Index           - Symbol file index

Returns:

  Object

--*/
{
  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;
}

UINTN
EbdFindSymbolAddress (
  IN UINTN                       Address,
  IN EDB_MATCH_SYMBOL_TYPE       Type,
  OUT EFI_DEBUGGER_SYMBOL_OBJECT **RetObject,
  OUT EFI_DEBUGGER_SYMBOL_ENTRY  **RetEntry
  )
/*++

Routine Description:

  Find symbol by address

Arguments:

  Address         - Symbol address
  Type            - Search type
  RetObject       - Symbol object
  RetEntry        - Symbol entry

Returns:

  Nearest symbol address

--*/
{
  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;
}

EFI_STATUS
EdbUnloadSymbol (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN CHAR16                      *FileName
  )
/*++

Routine Description:

  Unload symbol file by name

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  FileName        - Symbol file name

Returns:

  EFI_SUCCESS - unload symbol successfully

--*/
{
  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;
}

EFI_STATUS
EdbLoadSymbol (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN CHAR16                      *FileName,
  IN UINTN                       BufferSize,
  IN VOID                        *Buffer
  )
/*++

Routine Description:

  Load symbol file by name

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  FileName        - Symbol file name
  BufferSize      - Symbol file buffer size
  Buffer          - Symbol file buffer

Returns:

  EFI_SUCCESS - load symbol successfully

--*/
{
  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;
}

CHAR8 *
GetPdbPath (
  VOID *ImageBase
  )
/*++

Routine Description:

  Located PDB path name in PE image

Arguments:

  ImageBase - base of PE to search

Returns:

  Pointer into image at offset of PDB file name if PDB file name is found,
  Otherwise a pointer to an empty string.

--*/
{
  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;
}

BOOLEAN
MatchPdbAndMap (
  IN CHAR8   *PdbFileName,
  IN CHAR16  *MapFileName
  )
/*++

Routine Description:

  Check whether PDB file and MAP file have same name

Arguments:

  PdbFileName - PDB file name
  MapFileName - MAP file name

Returns:

  TRUE  - PDB and MAP file name match
  FALSE - PDB and MAP file name not match

--*/
{
  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;

VOID
EdbFixDebugImageInfoTable (
  IN OUT EFI_DEBUG_IMAGE_INFO_TABLE_HEADER **DebugImageInfoTableHeader
  )
/*
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              |    |                        |
  +------------------------+    +------------------------+

*/
{
  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
//

EFI_STATUS
EdbPatchSymbolRVA (
  IN EFI_DEBUGGER_PRIVATE_DATA     *DebuggerPrivate,
  IN CHAR16                        *FileName,
  IN EDB_EBC_IMAGE_RVA_SEARCH_TYPE SearchType
  )
/*++

Routine Description:

  Patch symbol RVA

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  FileName        - Symbol file name
  SearchType      - Search type for Object

Returns:

  EFI_SUCCESS   - Patch symbol RVA successfully
  EFI_NOT_FOUND - Symbol RVA base not found

--*/
{
  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;
}

BOOLEAN
MatchObjAndCod (
  IN CHAR8   *ObjFileName,
  IN CHAR16  *CodFileName
  )
/*++

Routine Description:

  Check whether OBJ file and COD file have same name

Arguments:

  ObjFileName - OBJ file name
  CodFileName - COD file name

Returns:

  TRUE  - OBJ and COD file name match
  FALSE - OBJ and COD file name not match

--*/
{
  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.

  Sample as follows: EbcTest.cod
===============================================================================
; -- Machine type EFI
; mark_description "Intel(R) C Compiler for EFI Byte Code, Version 1.2 Build 20040123";
; mark_description "XXX";
;ident "Intel(R) C Compiler for EFI Byte Code, Version 1.2 Build 20040123"
;ident "XXX"
    .686P
    .387
_TEXT   SEGMENT PARA PUBLIC USE32 'CODE'
_TEXT   ENDS
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
    ALIGN 010H
_DATA   ENDS
_BSS    SEGMENT PARA PUBLIC USE32 'BSS'
    ALIGN 010H
_BSS    ENDS
_VARBSS SEGMENT PARA PUBLIC USE32 'BSS'
    ALIGN 010H
_VARBSS ENDS
    ASSUME  CS:FLAT,DS:FLAT,SS:FLAT
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
TestVariable2   DD 000000003H,000000000H    ; u64
_DATA   ENDS
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
_DATA   ENDS
_TEXT   SEGMENT PARA PUBLIC USE32 'CODE'
; -- Begin  EfiMain
; mark_begin;
    PUBLIC   EfiMain
EfiMain  PROC NEAR
$B3$1:; 11a
$LN45:

;117 ; {

  0011a 60 00 70 80         MOVqw     R0, R0(+0,-112)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:117
$LN46:

;118 ;   UINT16 test = 0x1234;

  0011e 77 58 58 00 34
        12                  MOVIww    @R0(+0,+88), +4660      ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:118
$LN47:

;121 ;   EFI_STATUS  Status;
;121 ;
;121 ;   SystemTable->ConOut->OutputString (

  00124 72 87 01 12         MOVnw     R7, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:121
  00128 72 f7 85 21         MOVnw     R7, @R7(+5,+24)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:121
$LN48:

;122 ;                          SystemTable->ConOut,

  0012c 72 84 01 12         MOVnw     R4, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:122
  00130 72 c8 85 21         MOVnw     @R0, @R4(+5,+24)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:122
  00134 b9 34 00 00 00
        00                  MOVreld   R4, __STRING$1          ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:122
  0013a b2 48 01 10         MOVnw     @R0(+1,+0), R4          ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:122
  0013e 83 2f 01 00 00
        10                  CALLEX    @R7(+1,+0)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:122
$B3$2:; 144
$LN49:

;125 ;                          L"Hello EBC Test!\n\r"
;125 ;                          );
;125 ;   EFI_BREAKPOINT ();

  00144 00 03               BREAK     3                       ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:125
$B3$3:; 146
$LN50:

;126 ;   TestVariable1 = 6;

  00146 b9 37 00 00 00
        00                  MOVreld   R7, TestVariable1       ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:126
  0014c 78 0f 06 00         MOVInw    @R7, (0,6)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:126
$LN51:

;127 ;   TestSubRoutineSub (1, 5);

  00150 78 08 01 00         MOVInw    @R0, (0,1)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:127
  00154 78 48 01 10 05
        00                  MOVInw    @R0(1,0), (0,5)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:127
  0015a 83 10 00 00 00
        00                  CALL      TestSubRoutineSub       ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:127
$B3$4:; 160
$LN52:

;129 ;
;129 ;   SystemTable->ConOut->OutputString (

  00160 72 87 01 12         MOVnw     R7, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:129
  00164 72 f7 85 21         MOVnw     R7, @R7(+5,+24)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:129
$LN53:

;130 ;                          SystemTable->ConOut,

  00168 72 84 01 12         MOVnw     R4, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:130
  0016c 72 c8 85 21         MOVnw     @R0, @R4(+5,+24)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:130
$LN54:

;131 ;                          TestStr

  00170 b9 34 00 00 00
        00                  MOVreld   R4, TestStr             ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:131
  00176 b2 c8 01 10         MOVnw     @R0(+1, +0), @R4        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:131
  0017a 83 2f 01 00 00
        10                  CALLEX    @R7(+1,+0)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:131
$B3$5:; 180
$LN55:

;134 ;                          );
;134 ;
;134 ;   test = test & 0xFF;

  00180 de 88 58 00 58
        00                  MOVww     @R0(+0,+88), @R0(+0,+88) ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:134
$LN56:

;139 ;   if (test != 0x34) {
;139 ; //    EFI_BREAKPOINT ();
;139 ;   }
;139 ;
;139 ;   Status = TestSubRoutine (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

  00186 78 08 01 00         MOVInw    @R0, (0,1)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  0018a 78 48 01 10 02
        00                  MOVInw    @R0(1,0), (0,2)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  00190 78 48 02 10 03
        00                  MOVInw    @R0(2,0), (0,3)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  00196 78 48 03 10 04
        00                  MOVInw    @R0(3,0), (0,4)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  0019c 78 48 04 20 05
        00                  MOVInw    @R0(4,0), (0,5)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001a2 78 48 05 20 06
        00                  MOVInw    @R0(5,0), (0,6)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001a8 78 48 06 20 07
        00                  MOVInw    @R0(6,0), (0,7)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001ae 78 48 07 20 08
        00                  MOVInw    @R0(7,0), (0,8)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001b4 78 48 08 20 09
        00                  MOVInw    @R0(8,0), (0,9)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001ba 78 48 09 20 0a
        00                  MOVInw    @R0(9,0), (0,10)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
  001c0 83 10 00 00 00
        00                  CALL      TestSubRoutine          ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
$B3$10:; 1c6
  001c6 b2 78 60 00         MOVnw     @R0(+0,+96), R7         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
$B3$6:; 1ca
$LN57:
  001ca f2 88 50 00 60
        00                  MOVnw     @R0(+0,+80), @R0(+0,+96) ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:139
$LN58:

;141 ;
;141 ;   SystemTable->ConOut->OutputString (

  001d0 72 87 01 12         MOVnw     R7, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:141
  001d4 72 f7 85 21         MOVnw     R7, @R7(+5,+24)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:141
$LN59:

;142 ;                          SystemTable->ConOut,

  001d8 72 84 01 12         MOVnw     R4, @R0(+1,+128)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:142
  001dc 72 c8 85 21         MOVnw     @R0, @R4(+5,+24)        ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:142
  001e0 b9 34 00 00 00
        00                  MOVreld   R4, __STRING$2          ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:142
  001e6 b2 48 01 10         MOVnw     @R0(+1,+0), R4          ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:142
  001ea 83 2f 01 00 00
        10                  CALLEX    @R7(+1,+0)              ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:142
$B3$7:; 1f0
$LN60:

;146 ;                          L"Goodbye EBC Test!\n\r"
;146 ;                          );
;146 ;
;146 ;   return Status;

  001f0 72 87 50 00         MOVnw     R7, @R0(+0,+80)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:146
  001f4 60 00 70 00         MOVqw     R0, R0(+0,+112)         ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:146
  001f8 04 00               RET                               ;C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest.c:146
; mark_end;
EfiMain ENDP
_TEXT   ENDS
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
    DB 3 DUP (0)    ; pad
__STRING$2  DW 71   ; u16
    DW 111  ; u16
    DW 111  ; u16
    DW 100  ; u16
    DW 98   ; u16
    DW 121  ; u16
    DW 101  ; u16
    DW 32   ; u16
    DW 69   ; u16
    DW 66   ; u16
    DW 67   ; u16
    DW 32   ; u16
    DW 84   ; u16
    DW 101  ; u16
    DW 115  ; u16
    DW 116  ; u16
    DW 33   ; u16
    DW 10   ; u16
    DW 13   ; u16
    DW 0    ; u16
__STRING$1  DW 72   ; u16
    DW 101  ; u16
    DW 108  ; u16
    DW 108  ; u16
    DW 111  ; u16
    DW 32   ; u16
    DW 69   ; u16
    DW 66   ; u16
    DW 67   ; u16
    DW 32   ; u16
    DW 84   ; u16
    DW 101  ; u16
    DW 115  ; u16
    DW 116  ; u16
    DW 33   ; u16
    DW 10   ; u16
    DW 13   ; u16
    DW 0    ; u16
_DATA   ENDS
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
_DATA   ENDS
; -- End  EfiMain
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
__STRING$0  DW 55   ; u16
    DW 56   ; u16
    DW 57   ; u16
    DW 52   ; u16
    DW 53   ; u16
    DW 54   ; u16
    DW 49   ; u16
    DW 50   ; u16
    DW 51   ; u16
    DW 13   ; u16
    DW 10   ; u16
    DW 0    ; u16
_DATA   ENDS
_VARBSS SEGMENT PARA PUBLIC USE32 'BSS'
    PUBLIC TestStr
TestStr DD 2 DUP (?)    ; pad
    PUBLIC TestVariable1
TestVariable1   DD 2 DUP (?)    ; pad
_VARBSS ENDS
_VARBSS_INIT    SEGMENT DWORD PUBLIC USE32 'CODE'
; -- Begin varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest$c45b815d2
    PUBLIC    varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest$c45b815d2
varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest$c45b815d2 PROC NEAR
  00000 b9 34 00 00 00
        00                  MOVreld   R4, TestStr
  00006 b9 35 00 00 00
        00                  MOVreld   R5, __STRING$0
  0000c 33 5c               MOVnd     @R4, R5
  0000e b9 34 00 00 00
        00                  MOVreld   R4, TestVariable1
  00014 78 0c 04 00         MOVInw    @R4, (0,4)
  00018 04 00               RET
; -- End varbss_init_C:\efi_src\TIANO\Edk\Sample\Universal\Ebc\Dxe\EbcTest\EbcTest$c45b815d2
_VARBSS_INIT    ENDS
_DATA   SEGMENT PARA PUBLIC USE32 'DATA'
_DATA   ENDS
EXTRN   TestSubRoutineSub:PROC
    END

===============================================================================

--*/
CHAR8 *
EdbLoadCodBySymbolByIec (
  IN CHAR8                       *Name,
  IN VOID                        *Buffer,
  IN UINTN                       BufferSize,
  OUT UINTN                      *CodeBufferSize,
  OUT UINTN                      *FuncOffset
  )
/*++

Routine Description:

  Load code by symbol by Iec

Arguments:

  Name            - Symbol file name
  BufferSize      - Symbol file buffer size
  Buffer          - Symbol file buffer
  CodeBufferSize  - Code buffer size
  FuncOffset      - Code funcion offset

Returns:

  CodeBuffer

--*/
{
  CHAR8                      *LineBuffer;
  CHAR8                      *FieldBuffer;
  VOID                       *BufferStart;
  VOID                       *BufferEnd;
  UINTN                      Offset;
  EDB_EBC_COD_PARSE_STATE    CodParseState;
  CHAR8                      Char[2] = {9, 0};

  //
  // Init
  //
  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);
      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;
}

CHAR8 *
EdbLoadCodBySymbol (
  IN CHAR8                       *Name,
  IN VOID                        *Buffer,
  IN UINTN                       BufferSize,
  OUT UINTN                      *CodeBufferSize,
  OUT UINTN                      *FuncOffset
  )
/*++

Routine Description:

  Load code by symbol

Arguments:

  Name            - Symbol file name
  BufferSize      - Symbol file buffer size
  Buffer          - Symbol file buffer
  CodeBufferSize  - Code buffer size
  FuncOffset      - Code funcion offset

Returns:

  CodeBuffer

--*/
{
  //
  // 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);
}

VOID *
EdbFindCodeFromObject (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN EFI_DEBUGGER_SYMBOL_OBJECT  *Object,
  IN CHAR16                      *FileName
  )
/*++

Routine Description:

  Find code from object

Arguments:

  Object          - Symbol object
  FileName        - File name

Returns:

  CodeBuffer

--*/
{
  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;
}

EFI_STATUS
EdbLoadCode (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN CHAR16                      *MapFileName,
  IN CHAR16                      *FileName,
  IN UINTN                       BufferSize,
  IN VOID                        *Buffer
  )
/*++

Routine Description:

  Load code

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  MapFileName     - Symbol file name
  FileName        - Code file name
  BufferSize      - Code file buffer size
  Buffer          - Code file buffer

Returns:

  EFI_SUCCESS - Code loaded successfully

--*/
{
  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;
}

EFI_STATUS
EdbUnloadCode (
  IN EFI_DEBUGGER_PRIVATE_DATA   *DebuggerPrivate,
  IN CHAR16                      *MapFileName,
  IN CHAR16                      *FileName,
  OUT VOID                       **Buffer
  )
/*++

Routine Description:

  Unload code

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  MapFileName     - Symbol file name
  FileName        - Code file name
  Buffer          - Code file buffer

Returns:

  EFI_SUCCESS - Code unloaded successfully

--*/
{
  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;
}

EFI_STATUS
EdbAddCodeBuffer (
  IN     EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate,
  IN     CHAR16                    *MapFileName,
  IN     CHAR16                    *CodeFileName,
  IN     UINTN                     SourceBufferSize,
  IN     VOID                      *SourceBuffer
  )
/*++

Routine Description:

  Add code buffer

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  MapFileName     - Symbol file name
  CodeFileName    - Code file name
  SourceBufferSize- Code buffer size
  SourceBuffer    - Code buffer

Returns:

  EFI_SUCCESS - CodeBuffer added successfully

--*/
{
  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;
}

EFI_STATUS
EdbDeleteCodeBuffer (
  IN     EFI_DEBUGGER_PRIVATE_DATA *DebuggerPrivate,
  IN     CHAR16                    *MapFileName,
  IN     CHAR16                    *CodeFileName,
  IN     VOID                      *SourceBuffer
  )
/*++

Routine Description:

  Delete code buffer

Arguments:

  DebuggerPrivate - EBC Debugger private data structure
  MapFileName     - Symbol file name
  CodeFileName    - Code file name
  SourceBuffer    - Code buffer

Returns:

  EFI_SUCCESS - CodeBuffer deleted successfully

--*/
{
  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;
}

CHAR8 *
FindSymbolStr (
  IN UINTN Address
  )
/*++

Routine Description:

  Find the symbol string according to address

Arguments:

  Address         - Symbol address

Returns:

  Symbol string

--*/
{
  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;
}

UINTN
EdbGetLineNumberAndOffsetFromThisLine (
  IN VOID     *Line,
  OUT UINTN   *Offset
  )
/*++

Routine Description:

  Get line number and offset from this line in code file

Arguments:

  Line            - Line buffer in code file
  Offset          - Offset to functin entry

Returns:

  Line number

--*/
{
  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;

UINTN
EdbGetLineNumberFromCode (
  IN EFI_DEBUGGER_SYMBOL_ENTRY  *Entry,
  IN UINTN                      FuncOffset,
  IN EDB_EBC_LINE_SEARCH_TYPE   SearchType
  )
/*++

Routine Description:

  Get line number from this code file

Arguments:

  Entry           - Symbol entry
  FuncOffset      - Offset to functin entry
  SearchType      - Search type for the code

Returns:

  Line number

--*/
{
  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;
}

VOID *
EdbGetSourceStrFromCodeByLine (
  IN EFI_DEBUGGER_SYMBOL_ENTRY  *Entry,
  IN UINTN                      LineNumber,
  IN VOID                       **FuncEnd
  )
/*++

Routine Description:

  Get the source string from this code file by line

Arguments:

  Entry           - Symbol entry
  LineNumber      - line number
  FuncEnd         - Function end

Returns:

  Funtion start

--*/
{
  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;
}

VOID *
EdbGetSourceStrFromCode (
  IN EFI_DEBUGGER_SYMBOL_ENTRY  *Entry,
  IN UINTN                      FuncOffset,
  IN VOID                       **FuncEnd
  )
/*++

Routine Description:

  Get source string from this code file

Arguments:

  Entry           - Symbol entry
  FuncOffset      - Offset to functin entry
  FuncEnd         - Function end

Returns:

  Funtion start

--*/
{
  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);
}

UINTN
EdbPrintSource (
  IN UINTN     Address,
  IN BOOLEAN   IsPrint
  )
/*++

Routine Description:

  Print source

Arguments:

  Address         - Instruction address
  IsPrint         - Whether need to print

Returns:

  1 - find the source
  0 - not find the source

--*/
{
  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 ;
}

VOID
GetMapfileAndSymbol (
  IN CHAR16   *Symbol,
  OUT CHAR16  **MapfileName,
  OUT CHAR16  **SymbolName
  )
/*++

Routine Description:

  Get Mapfile and SymbolName from one symbol format: [MapFileName:]SymbolName

Arguments:

  Symbol          - whole Symbol name
  MapfileName     - the mapfile name in the symbol
  SymbolName      - the symbol name in the symbol

Returns:

  None

--*/
{
  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 ;
}

EFI_STATUS
Symboltoi (
  IN CHAR16   *Symbol,
  OUT UINTN   *Address
  )
/*++

Routine Description:

  Convert a symbol to an address

Arguments:

  Symbol          - Symbol name
  Address         - Symbol address

Returns:

  EFI_SUCCESS    - symbol found and address returned.
  EFI_NOT_FOUND  - symbol not found
  EFI_NO_MAPPING - duplicated symbol not found

--*/
{
  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;
}