[mirror_edk2.git] / MdeModulePkg / Universal / EbcDxe / EbcDebugger / EdbDisasmSupport.c

/** @file\r
\r
Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
\r
**/\r
\r
#include "Edb.h"\r
\r
extern EDB_DISASM_INSTRUCTION  mEdbDisasmInstructionTable[];\r
\r
typedef struct {\r
  CHAR16    Name[EDB_INSTRUCTION_NAME_MAX_LENGTH];\r
  CHAR16    Content[EDB_INSTRUCTION_CONTENT_MAX_LENGTH];\r
  CHAR16    Tail;\r
} EDB_INSTRUCTION_STRING;\r
\r
EDB_INSTRUCTION_STRING  mInstructionString;\r
UINTN                   mInstructionNameOffset;\r
UINTN                   mInstructionContentOffset;\r
\r
/**\r
\r
  Set offset for Instruction name and content.\r
\r
  @param  InstructionNameOffset     - Instruction name offset\r
  @param  InstructionContentOffset  - Instruction content offset\r
\r
**/\r
VOID\r
EdbSetOffset (\r
  IN UINTN  InstructionNameOffset,\r
  IN UINTN  InstructionContentOffset\r
  )\r
{\r
  mInstructionNameOffset    = InstructionNameOffset;\r
  mInstructionContentOffset = InstructionContentOffset;\r
\r
  return;\r
}\r
\r
/**\r
\r
  Pre instruction string construction.\r
\r
  @return Instruction string\r
\r
**/\r
CHAR16 *\r
EdbPreInstructionString (\r
  VOID\r
  )\r
{\r
  ZeroMem (&mInstructionString, sizeof (mInstructionString));\r
  mInstructionNameOffset    = 0;\r
  mInstructionContentOffset = 0;\r
\r
  return (CHAR16 *)&mInstructionString;\r
}\r
\r
/**\r
\r
  Post instruction string construction.\r
\r
  @return Instruction string\r
\r
**/\r
CHAR16 *\r
EdbPostInstructionString (\r
  VOID\r
  )\r
{\r
  CHAR16  *Char;\r
\r
  for (Char = (CHAR16 *)&mInstructionString; Char < &mInstructionString.Tail; Char++) {\r
    if (*Char == 0) {\r
      *Char = L' ';\r
    }\r
  }\r
\r
  mInstructionString.Tail = 0;\r
\r
  mInstructionNameOffset    = 0;\r
  mInstructionContentOffset = 0;\r
\r
  return (CHAR16 *)&mInstructionString;\r
}\r
\r
/**\r
\r
  Get Sign, NaturalUnits, and ConstantUnits of the WORD data.\r
\r
  @param  Data16        - WORD data\r
  @param  NaturalUnits  - Natural Units of the WORD\r
  @param  ConstantUnits - Constant Units of the WORD\r
\r
  @return Sign value of WORD\r
\r
**/\r
BOOLEAN\r
EdbGetNaturalIndex16 (\r
  IN  UINT16  Data16,\r
  OUT UINTN   *NaturalUnits,\r
  OUT UINTN   *ConstantUnits\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINTN    NaturalUnitBit;\r
\r
  Sign            = (BOOLEAN)(Data16 >> 15);\r
  NaturalUnitBit  = (UINTN)((Data16 >> 12) & 0x7);\r
  NaturalUnitBit *= 2;\r
  Data16          = Data16 & 0xFFF;\r
  *NaturalUnits   = (UINTN)(Data16 & ((1 << NaturalUnitBit) - 1));\r
  *ConstantUnits  = (UINTN)((Data16 >> NaturalUnitBit) & ((1 << (12 - NaturalUnitBit)) - 1));\r
\r
  return Sign;\r
}\r
\r
/**\r
\r
  Get Sign, NaturalUnits, and ConstantUnits of the DWORD data.\r
\r
  @param  Data32        - DWORD data\r
  @param  NaturalUnits  - Natural Units of the DWORD\r
  @param  ConstantUnits - Constant Units of the DWORD\r
\r
  @return Sign value of DWORD\r
\r
**/\r
BOOLEAN\r
EdbGetNaturalIndex32 (\r
  IN  UINT32  Data32,\r
  OUT UINTN   *NaturalUnits,\r
  OUT UINTN   *ConstantUnits\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINTN    NaturalUnitBit;\r
\r
  Sign            = (BOOLEAN)(Data32 >> 31);\r
  NaturalUnitBit  = (UINTN)((Data32 >> 28) & 0x7);\r
  NaturalUnitBit *= 4;\r
  Data32          = Data32 & 0xFFFFFFF;\r
  *NaturalUnits   = (UINTN)(Data32 & ((1 << NaturalUnitBit) - 1));\r
  *ConstantUnits  = (UINTN)((Data32 >> NaturalUnitBit) & ((1 << (28 - NaturalUnitBit)) - 1));\r
\r
  return Sign;\r
}\r
\r
/**\r
\r
  Get Sign, NaturalUnits, and ConstantUnits of the QWORD data.\r
\r
  @param  Data64        - QWORD data\r
  @param  NaturalUnits  - Natural Units of the QWORD\r
  @param  ConstantUnits - Constant Units of the QWORD\r
\r
  @return Sign value of QWORD\r
\r
**/\r
BOOLEAN\r
EdbGetNaturalIndex64 (\r
  IN  UINT64  Data64,\r
  OUT UINT64  *NaturalUnits,\r
  OUT UINT64  *ConstantUnits\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINTN    NaturalUnitBit;\r
\r
  Sign            = (BOOLEAN)RShiftU64 (Data64, 63);\r
  NaturalUnitBit  = (UINTN)(RShiftU64 (Data64, 60) & 0x7);\r
  NaturalUnitBit *= 8;\r
  Data64          = RShiftU64 (LShiftU64 (Data64, 4), 4);\r
  *NaturalUnits   = (UINT64)(Data64 & (LShiftU64 (1, NaturalUnitBit) - 1));\r
  *ConstantUnits  = (UINT64)(RShiftU64 (Data64, NaturalUnitBit) & (LShiftU64 (1, (60 - NaturalUnitBit)) - 1));\r
\r
  return Sign;\r
}\r
\r
/**\r
\r
  Get Bit Width of the value.\r
\r
  @param  Value - data\r
\r
  @return Bit width\r
\r
**/\r
UINT8\r
EdbGetBitWidth (\r
  IN UINT64  Value\r
  )\r
{\r
  if (Value >= 10000000000000) {\r
    return 14;\r
  } else if (Value >= 1000000000000) {\r
    return 13;\r
  } else if (Value >= 100000000000) {\r
    return 12;\r
  } else if (Value >= 10000000000) {\r
    return 11;\r
  } else if (Value >= 1000000000) {\r
    return 10;\r
  } else if (Value >= 100000000) {\r
    return 9;\r
  } else if (Value >= 10000000) {\r
    return 8;\r
  } else if (Value >= 1000000) {\r
    return 7;\r
  } else if (Value >= 100000) {\r
    return 6;\r
  } else if (Value >= 10000) {\r
    return 5;\r
  } else if (Value >= 1000) {\r
    return 4;\r
  } else if (Value >= 100) {\r
    return 3;\r
  } else if (Value >= 10) {\r
    return 2;\r
  } else {\r
    return 1;\r
  }\r
}\r
\r
/**\r
\r
  Print the instruction name.\r
\r
  @param  Name - instruction name\r
\r
  @return Instruction name offset\r
\r
**/\r
UINTN\r
EdbPrintInstructionName (\r
  IN CHAR16  *Name\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Name,\r
    EDB_INSTRUCTION_NAME_MAX_SIZE,\r
    mInstructionNameOffset,\r
    L"%s",\r
    Name\r
    );\r
  mInstructionNameOffset += StrLen (Name);\r
\r
  return mInstructionNameOffset;\r
}\r
\r
/**\r
\r
  Print register 1 in operands.\r
\r
  @param  Operands - instruction operands\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintRegister1 (\r
  IN UINT8  Operands\r
  )\r
{\r
  if ((Operands & OPERAND_M_INDIRECT1) != 0) {\r
    EDBSPrintWithOffset (\r
      mInstructionString.Content,\r
      EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
      mInstructionContentOffset,\r
      L"@"\r
      );\r
    mInstructionContentOffset += 1;\r
  }\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"R%d",\r
    (UINTN)(Operands & OPERAND_M_OP1)\r
    );\r
  mInstructionContentOffset += 2;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print register 2 in operands.\r
\r
  @param  Operands - instruction operands\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintRegister2 (\r
  IN UINT8  Operands\r
  )\r
{\r
  if ((Operands & OPERAND_M_INDIRECT2) != 0) {\r
    EDBSPrintWithOffset (\r
      mInstructionString.Content,\r
      EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
      mInstructionContentOffset,\r
      L"@"\r
      );\r
    mInstructionContentOffset += 1;\r
  }\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"R%d",\r
    (UINTN)((Operands & OPERAND_M_OP2) >> 4)\r
    );\r
  mInstructionContentOffset += 2;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print dedicated register 1 in operands.\r
\r
  @param Operands - instruction operands\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintDedicatedRegister1 (\r
  IN UINT8  Operands\r
  )\r
{\r
  switch (Operands & OPERAND_M_OP1) {\r
    case 0:\r
      EDBSPrintWithOffset (\r
        mInstructionString.Content,\r
        EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
        mInstructionContentOffset,\r
        L"[FLAGS]"\r
        );\r
      mInstructionContentOffset += 7;\r
      break;\r
    case 1:\r
      EDBSPrintWithOffset (\r
        mInstructionString.Content,\r
        EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
        mInstructionContentOffset,\r
        L"[IP]"\r
        );\r
      mInstructionContentOffset += 4;\r
      break;\r
  }\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print dedicated register 2 in operands.\r
\r
  @param  Operands - instruction operands\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintDedicatedRegister2 (\r
  IN UINT8  Operands\r
  )\r
{\r
  switch ((Operands & OPERAND_M_OP2) >> 4) {\r
    case 0:\r
      EDBSPrintWithOffset (\r
        mInstructionString.Content,\r
        EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
        mInstructionContentOffset,\r
        L"[FLAGS]"\r
        );\r
      mInstructionContentOffset += 7;\r
      break;\r
    case 1:\r
      EDBSPrintWithOffset (\r
        mInstructionString.Content,\r
        EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
        mInstructionContentOffset,\r
        L"[IP]"\r
        );\r
      mInstructionContentOffset += 4;\r
      break;\r
  }\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical UINTN index data to instruction content.\r
\r
  @param  Sign          - Signed bit of UINTN data\r
  @param  NaturalUnits  - natural units of UINTN data\r
  @param  ConstantUnits - natural units of UINTN data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintIndexData (\r
  IN BOOLEAN  Sign,\r
  IN UINTN    NaturalUnits,\r
  IN UINTN    ConstantUnits\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(%s%d,%s%d)",\r
    Sign ? L"-" : L"+",\r
    NaturalUnits,\r
    Sign ? L"-" : L"+",\r
    ConstantUnits\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 5 + EdbGetBitWidth (NaturalUnits) + EdbGetBitWidth (ConstantUnits);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical QWORD index data to instruction content.\r
\r
  @param  Sign          - Signed bit of QWORD data\r
  @param  NaturalUnits  - natural units of QWORD data\r
  @param  ConstantUnits - natural units of QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintIndexData64 (\r
  IN BOOLEAN  Sign,\r
  IN UINT64   NaturalUnits,\r
  IN UINT64   ConstantUnits\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(%s%ld,%s%ld)",\r
    Sign ? L"-" : L"+",\r
    NaturalUnits,\r
    Sign ? L"-" : L"+",\r
    ConstantUnits\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 5 + EdbGetBitWidth (NaturalUnits) + EdbGetBitWidth (ConstantUnits);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical WORD raw index data to instruction content.\r
\r
  @param  Data16 - WORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintRawIndexData16 (\r
  IN UINT16  Data16\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINTN    NaturalUnits;\r
  UINTN    ConstantUnits;\r
  UINTN    Offset;\r
\r
  Sign   = EdbGetNaturalIndex16 (Data16, &NaturalUnits, &ConstantUnits);\r
  Offset = EdbPrintIndexData (Sign, NaturalUnits, ConstantUnits);\r
\r
  return Offset;\r
}\r
\r
/**\r
\r
  Print the hexical DWORD raw index data to instruction content.\r
\r
  @param  Data32 - DWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintRawIndexData32 (\r
  IN UINT32  Data32\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINTN    NaturalUnits;\r
  UINTN    ConstantUnits;\r
  UINTN    Offset;\r
\r
  Sign   = EdbGetNaturalIndex32 (Data32, &NaturalUnits, &ConstantUnits);\r
  Offset = EdbPrintIndexData (Sign, NaturalUnits, ConstantUnits);\r
\r
  return Offset;\r
}\r
\r
/**\r
\r
  Print the hexical QWORD raw index data to instruction content.\r
\r
  @param  Data64 - QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintRawIndexData64 (\r
  IN UINT64  Data64\r
  )\r
{\r
  BOOLEAN  Sign;\r
  UINT64   NaturalUnits;\r
  UINT64   ConstantUnits;\r
  UINTN    Offset;\r
\r
  Sign   = EdbGetNaturalIndex64 (Data64, &NaturalUnits, &ConstantUnits);\r
  Offset = EdbPrintIndexData64 (Sign, NaturalUnits, ConstantUnits);\r
\r
  return Offset;\r
}\r
\r
/**\r
\r
  Print the hexical BYTE immediate data to instruction content.\r
\r
  @param  Data - BYTE data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmData8 (\r
  IN UINT8  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(0x%02x)",\r
    (UINTN)Data\r
    );\r
  mInstructionContentOffset += 6;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical WORD immediate data to instruction content.\r
\r
  @param  Data - WORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmData16 (\r
  IN UINT16  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(0x%04x)",\r
    (UINTN)Data\r
    );\r
  mInstructionContentOffset += 8;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical DWORD immediate data to instruction content.\r
\r
  @param  Data - DWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmData32 (\r
  IN UINT32  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(0x%08x)",\r
    (UINTN)Data\r
    );\r
  mInstructionContentOffset += 12;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical QWORD immediate data to instruction content.\r
\r
  @param  Data - QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmData64 (\r
  IN UINT64  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(0x%016lx)",\r
    Data\r
    );\r
  mInstructionContentOffset += 20;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal UINTN immediate data to instruction content.\r
\r
  @param  Data - UINTN data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmDatan (\r
  IN UINTN  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(%d)",\r
    (UINTN)Data\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 2 + EdbGetBitWidth (Data);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal QWORD immediate data to instruction content.\r
\r
  @param  Data64 - QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintImmData64n (\r
  IN UINT64  Data64\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"(%ld)",\r
    Data64\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 2 + EdbGetBitWidth (Data64);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical BYTE to instruction content.\r
\r
  @param  Data8 - BYTE data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData8 (\r
  IN UINT8  Data8\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"0x%02x",\r
    (UINTN)Data8\r
    );\r
  mInstructionContentOffset += 4;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical WORD to instruction content.\r
\r
  @param  Data16 - WORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData16 (\r
  IN UINT16  Data16\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"0x%04x",\r
    (UINTN)Data16\r
    );\r
  mInstructionContentOffset += 6;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical DWORD to instruction content.\r
\r
  @param  Data32 - DWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData32 (\r
  IN UINT32  Data32\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"0x%08x",\r
    (UINTN)Data32\r
    );\r
  mInstructionContentOffset += 10;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the hexical QWORD to instruction content.\r
\r
  @param  Data64 - QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData64 (\r
  IN UINT64  Data64\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"0x%016lx",\r
    (UINT64)Data64\r
    );\r
  mInstructionContentOffset += 18;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal unsigned UINTN to instruction content.\r
\r
  @param  Data - unsigned UINTN data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintDatan (\r
  IN UINTN  Data\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%d",\r
    (UINTN)Data\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + EdbGetBitWidth (Data);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal unsigned QWORD to instruction content.\r
\r
  @param  Data64 - unsigned QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData64n (\r
  IN UINT64  Data64\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%ld",\r
    Data64\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + EdbGetBitWidth (Data64);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal signed BYTE to instruction content.\r
\r
  @param  Data8 - signed BYTE data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData8s (\r
  IN UINT8  Data8\r
  )\r
{\r
  BOOLEAN  Sign;\r
\r
  Sign = (BOOLEAN)(Data8 >> 7);\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%s%d",\r
    Sign ? L"-" : L"+",\r
    (UINTN)(Data8 & 0x7F)\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data8 & 0x7F);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal signed WORD to instruction content.\r
\r
  @param  Data16 - signed WORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData16s (\r
  IN UINT16  Data16\r
  )\r
{\r
  BOOLEAN  Sign;\r
\r
  Sign = (BOOLEAN)(Data16 >> 15);\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%s%d",\r
    Sign ? L"-" : L"+",\r
    (UINTN)(Data16 & 0x7FFF)\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data16 & 0x7FFF);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal signed DWORD to instruction content.\r
\r
  @param  Data32 - signed DWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData32s (\r
  IN UINT32  Data32\r
  )\r
{\r
  BOOLEAN  Sign;\r
\r
  Sign = (BOOLEAN)(Data32 >> 31);\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%s%d",\r
    Sign ? L"-" : L"+",\r
    (UINTN)(Data32 & 0x7FFFFFFF)\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data32 & 0x7FFFFFFF);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the decimal signed QWORD to instruction content.\r
\r
  @param  Data64 - signed QWORD data\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintData64s (\r
  IN UINT64  Data64\r
  )\r
{\r
  BOOLEAN  Sign;\r
  INT64    Data64s;\r
\r
  Sign    = (BOOLEAN)RShiftU64 (Data64, 63);\r
  Data64s = (INT64)RShiftU64 (LShiftU64 (Data64, 1), 1);\r
\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L"%s%ld",\r
    Sign ? L"-" : L"+",\r
    (UINT64)Data64s\r
    );\r
  mInstructionContentOffset = mInstructionContentOffset + 1 + EdbGetBitWidth (Data64s);\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Print the comma to instruction content.\r
\r
  @return Instruction content offset\r
\r
**/\r
UINTN\r
EdbPrintComma (\r
  VOID\r
  )\r
{\r
  EDBSPrintWithOffset (\r
    mInstructionString.Content,\r
    EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
    mInstructionContentOffset,\r
    L", "\r
    );\r
  mInstructionContentOffset += 2;\r
\r
  return mInstructionContentOffset;\r
}\r
\r
/**\r
\r
  Find the symbol string according to address, then print it.\r
\r
  @param  Address - instruction address\r
\r
  @retval 1 - symbol string is found and printed\r
  @retval 0 - symbol string not found\r
\r
**/\r
UINTN\r
EdbFindAndPrintSymbol (\r
  IN UINTN  Address\r
  )\r
{\r
  CHAR8  *SymbolStr;\r
\r
  SymbolStr = FindSymbolStr (Address);\r
  if (SymbolStr != NULL) {\r
    EDBSPrintWithOffset (\r
      mInstructionString.Content,\r
      EDB_INSTRUCTION_CONTENT_MAX_SIZE,\r
      mInstructionContentOffset,\r
      L"[%a]",\r
      SymbolStr\r
      );\r
    return 1;\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
\r
  Print the EBC byte code.\r
\r
  @param  InstructionAddress - instruction address\r
  @param  InstructionNumber  - instruction number\r
\r
**/\r
VOID\r
EdbPrintRaw (\r
  IN EFI_PHYSICAL_ADDRESS  InstructionAddress,\r
  IN UINTN                 InstructionNumber\r
  )\r
{\r
  UINTN  LineNumber;\r
  UINTN  ByteNumber;\r
  UINTN  LineIndex;\r
  UINTN  ByteIndex;\r
  CHAR8  *SymbolStr;\r
\r
  if (InstructionNumber == 0) {\r
    return;\r
  }\r
\r
  LineNumber = InstructionNumber / EDB_BYTECODE_NUMBER_IN_LINE;\r
  ByteNumber = InstructionNumber % EDB_BYTECODE_NUMBER_IN_LINE;\r
  if (ByteNumber == 0) {\r
    LineNumber -= 1;\r
    ByteNumber  = EDB_BYTECODE_NUMBER_IN_LINE;\r
  }\r
\r
  //\r
  // Print Symbol\r
  //\r
  SymbolStr = FindSymbolStr ((UINTN)InstructionAddress);\r
  if (SymbolStr != NULL) {\r
    EDBPrint (L"[%a]:\n", SymbolStr);\r
  }\r
\r
  for (LineIndex = 0; LineIndex < LineNumber; LineIndex++) {\r
    EDBPrint (EDB_PRINT_ADDRESS_FORMAT, (UINTN)InstructionAddress);\r
    for (ByteIndex = 0; ByteIndex < EDB_BYTECODE_NUMBER_IN_LINE; ByteIndex++) {\r
      EDBPrint (L"%02x ", *(UINT8 *)(UINTN)InstructionAddress);\r
      InstructionAddress += 1;\r
    }\r
\r
    EDBPrint (L"\n");\r
  }\r
\r
  EDBPrint (EDB_PRINT_ADDRESS_FORMAT, (UINTN)InstructionAddress);\r
  for (ByteIndex = 0; ByteIndex < ByteNumber; ByteIndex++) {\r
    EDBPrint (L"%02x ", *(UINT8 *)(UINTN)InstructionAddress);\r
    InstructionAddress += 1;\r
  }\r
\r
  for (ByteIndex = 0; ByteIndex < EDB_BYTECODE_NUMBER_IN_LINE - ByteNumber; ByteIndex++) {\r
    EDBPrint (L"   ");\r
  }\r
\r
  return;\r
}\r
\r
/**\r
\r
  Print the EBC asm code.\r
\r
  @param  DebuggerPrivate - EBC Debugger private data structure\r
  @param  SystemContext   - EBC system context.\r
\r
  @retval EFI_SUCCESS - show disasm successfully\r
\r
**/\r
EFI_STATUS\r
EdbShowDisasm (\r
  IN     EFI_DEBUGGER_PRIVATE_DATA  *DebuggerPrivate,\r
  IN     EFI_SYSTEM_CONTEXT         SystemContext\r
  )\r
{\r
  EFI_PHYSICAL_ADDRESS  InstructionAddress;\r
  UINTN                 InstructionNumber;\r
  UINTN                 InstructionLength;\r
  UINT8                 Opcode;\r
  CHAR16                *InstructionString;\r
\r
  //  UINTN                   Result;\r
\r
  InstructionAddress = DebuggerPrivate->InstructionScope;\r
  for (InstructionNumber = 0; InstructionNumber < DebuggerPrivate->InstructionNumber; InstructionNumber++) {\r
    //\r
    // Break each 0x10 instruction\r
    //\r
    if (((InstructionNumber % EFI_DEBUGGER_LINE_NUMBER_IN_PAGE) == 0) &&\r
        (InstructionNumber != 0))\r
    {\r
      if (SetPageBreak ()) {\r
        break;\r
      }\r
    }\r
\r
    Opcode = GET_OPCODE (InstructionAddress);\r
    if ((Opcode < OPCODE_MAX) && (mEdbDisasmInstructionTable[Opcode] != NULL)) {\r
      InstructionLength = mEdbDisasmInstructionTable[Opcode](InstructionAddress, SystemContext, &InstructionString);\r
      if (InstructionLength != 0) {\r
        //\r
        // Print Source\r
        //\r
        //        Result = EdbPrintSource ((UINTN)InstructionAddress, FALSE);\r
\r
        if (!DebuggerPrivate->DebuggerSymbolContext.DisplayCodeOnly) {\r
          EdbPrintRaw (InstructionAddress, InstructionLength);\r
          if (InstructionString != NULL) {\r
            EDBPrint (L"%s\n", InstructionString);\r
          } else {\r
            EDBPrint (L"%s\n", L"<Unknown Instruction>");\r
          }\r
        }\r
\r
        EdbPrintSource ((UINTN)InstructionAddress, TRUE);\r
\r
        InstructionAddress += InstructionLength;\r
      } else {\r
        //\r
        // Something wrong with OPCODE\r
        //\r
        EdbPrintRaw (InstructionAddress, EDB_BYTECODE_NUMBER_IN_LINE);\r
        EDBPrint (L"%s\n", L"<Bad Instruction>");\r
        break;\r
      }\r
    } else {\r
      //\r
      // Something wrong with OPCODE\r
      //\r
      EdbPrintRaw (InstructionAddress, EDB_BYTECODE_NUMBER_IN_LINE);\r
      EDBPrint (L"%s\n", L"<Bad Instruction>");\r
      break;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Get register value according to the system context, and register index.\r
\r
  @param  SystemContext   - EBC system context.\r
  @param  Index           - EBC register index\r
\r
  @return register value\r
\r
**/\r
UINT64\r
GetRegisterValue (\r
  IN     EFI_SYSTEM_CONTEXT  SystemContext,\r
  IN     UINT8               Index\r
  )\r
{\r
  switch (Index) {\r
    case 0:\r
      return SystemContext.SystemContextEbc->R0;\r
    case 1:\r
      return SystemContext.SystemContextEbc->R1;\r
    case 2:\r
      return SystemContext.SystemContextEbc->R2;\r
    case 3:\r
      return SystemContext.SystemContextEbc->R3;\r
    case 4:\r
      return SystemContext.SystemContextEbc->R4;\r
    case 5:\r
      return SystemContext.SystemContextEbc->R5;\r
    case 6:\r
      return SystemContext.SystemContextEbc->R6;\r
    case 7:\r
      return SystemContext.SystemContextEbc->R7;\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
  }\r
\r
  return 0;\r
}\r