/** @file

Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent


**/

#include "Edb.h"

//
// Debugger Disasm definition
//
#define EDB_DISASM_DEFINE(func) \
UINTN \
func ( \
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress, \
  IN     EFI_SYSTEM_CONTEXT        SystemContext, \
  OUT    CHAR16                    **DisasmString \
  )

EDB_DISASM_DEFINE (EdbDisasmBREAK);
EDB_DISASM_DEFINE (EdbDisasmJMP);
EDB_DISASM_DEFINE (EdbDisasmJMP8);
EDB_DISASM_DEFINE (EdbDisasmCALL);
EDB_DISASM_DEFINE (EdbDisasmRET);
EDB_DISASM_DEFINE (EdbDisasmCMP);
EDB_DISASM_DEFINE (EdbDisasmUnsignedDataManip);
EDB_DISASM_DEFINE (EdbDisasmSignedDataManip);
EDB_DISASM_DEFINE (EdbDisasmMOVxx);
EDB_DISASM_DEFINE (EdbDisasmMOVsnw);
EDB_DISASM_DEFINE (EdbDisasmMOVsnd);
EDB_DISASM_DEFINE (EdbDisasmLOADSP);
EDB_DISASM_DEFINE (EdbDisasmSTORESP);
EDB_DISASM_DEFINE (EdbDisasmPUSH);
EDB_DISASM_DEFINE (EdbDisasmPOP);
EDB_DISASM_DEFINE (EdbDisasmCMPI);
EDB_DISASM_DEFINE (EdbDisasmPUSHn);
EDB_DISASM_DEFINE (EdbDisasmPOPn);
EDB_DISASM_DEFINE (EdbDisasmMOVI);
EDB_DISASM_DEFINE (EdbDisasmMOVIn);
EDB_DISASM_DEFINE (EdbDisasmMOVREL);

//
// Debugger Disasm Table
//
EDB_DISASM_INSTRUCTION mEdbDisasmInstructionTable[] = {
  EdbDisasmBREAK,             // opcode 0x00 BREAK
  EdbDisasmJMP,               // opcode 0x01 JMP
  EdbDisasmJMP8,              // opcode 0x02 JMP8
  EdbDisasmCALL,              // opcode 0x03 CALL
  EdbDisasmRET,               // opcode 0x04 RET
  EdbDisasmCMP,               // opcode 0x05 CMPEQ
  EdbDisasmCMP,               // opcode 0x06 CMPLTE
  EdbDisasmCMP,               // opcode 0x07 CMPGTE
  EdbDisasmCMP,               // opcode 0x08 CMPULTE
  EdbDisasmCMP,               // opcode 0x09 CMPUGTE
  EdbDisasmUnsignedDataManip, // opcode 0x0A NOT
  EdbDisasmSignedDataManip,   // opcode 0x0B NEG
  EdbDisasmSignedDataManip,   // opcode 0x0C ADD
  EdbDisasmSignedDataManip,   // opcode 0x0D SUB
  EdbDisasmSignedDataManip,   // opcode 0x0E MUL
  EdbDisasmUnsignedDataManip, // opcode 0x0F MULU
  EdbDisasmSignedDataManip,   // opcode 0x10 DIV
  EdbDisasmUnsignedDataManip, // opcode 0x11 DIVU
  EdbDisasmSignedDataManip,   // opcode 0x12 MOD
  EdbDisasmUnsignedDataManip, // opcode 0x13 MODU
  EdbDisasmUnsignedDataManip, // opcode 0x14 AND
  EdbDisasmUnsignedDataManip, // opcode 0x15 OR
  EdbDisasmUnsignedDataManip, // opcode 0x16 XOR
  EdbDisasmUnsignedDataManip, // opcode 0x17 SHL
  EdbDisasmUnsignedDataManip, // opcode 0x18 SHR
  EdbDisasmSignedDataManip,   // opcode 0x19 ASHR
  EdbDisasmUnsignedDataManip, // opcode 0x1A EXTNDB
  EdbDisasmUnsignedDataManip, // opcode 0x1B EXTNDW
  EdbDisasmUnsignedDataManip, // opcode 0x1C EXTNDD
  EdbDisasmMOVxx,             // opcode 0x1D MOVBW
  EdbDisasmMOVxx,             // opcode 0x1E MOVWW
  EdbDisasmMOVxx,             // opcode 0x1F MOVDW
  EdbDisasmMOVxx,             // opcode 0x20 MOVQW
  EdbDisasmMOVxx,             // opcode 0x21 MOVBD
  EdbDisasmMOVxx,             // opcode 0x22 MOVWD
  EdbDisasmMOVxx,             // opcode 0x23 MOVDD
  EdbDisasmMOVxx,             // opcode 0x24 MOVQD
  EdbDisasmMOVsnw,            // opcode 0x25 MOVSNW
  EdbDisasmMOVsnd,            // opcode 0x26 MOVSND
  NULL,                       // opcode 0x27
  EdbDisasmMOVxx,             // opcode 0x28 MOVQQ
  EdbDisasmLOADSP,            // opcode 0x29 LOADSP
  EdbDisasmSTORESP,           // opcode 0x2A STORESP
  EdbDisasmPUSH,              // opcode 0x2B PUSH
  EdbDisasmPOP,               // opcode 0x2C POP
  EdbDisasmCMPI,              // opcode 0x2D CMPIEQ
  EdbDisasmCMPI,              // opcode 0x2E CMPILTE
  EdbDisasmCMPI,              // opcode 0x2F CMPIGTE
  EdbDisasmCMPI,              // opcode 0x30 CMPIULTE
  EdbDisasmCMPI,              // opcode 0x31 CMPIUGTE
  EdbDisasmMOVxx,             // opcode 0x32 MOVNW
  EdbDisasmMOVxx,             // opcode 0x33 MOVND
  NULL,                       // opcode 0x34
  EdbDisasmPUSHn,             // opcode 0x35 PUSHN
  EdbDisasmPOPn,              // opcode 0x36 POPN
  EdbDisasmMOVI,              // opcode 0x37 MOVI
  EdbDisasmMOVIn,             // opcode 0x38 MOVIN
  EdbDisasmMOVREL,            // opcode 0x39 MOVREL
};

/**

  Disasm instruction - BREAK.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmBREAK (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_BREAK);

  if (*(UINT8 *)(UINTN)(InstructionAddress + 1) > 6) {
    return 0;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"BREAK");
    EdbPrintDatan (*(UINT8 *)(UINTN)(InstructionAddress + 1));

    EdbPostInstructionString ();
  }

  return 2;
}

extern CONST UINT8                    mJMPLen[];

/**

  Disasm instruction - JMP.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmJMP (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8   Modifiers;
  UINT8   Operands;
  UINTN   Size;
  UINT32  Data32;
  UINT64  Data64;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_JMP);

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Size = (UINTN)mJMPLen[(Modifiers >> 6) & 0x03];

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"JMP");
//    if (Modifiers & OPCODE_M_IMMDATA64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }
    if ((Modifiers & CONDITION_M_CONDITIONAL) != 0) {
      if ((Modifiers & JMP_M_CS) != 0) {
        EdbPrintInstructionName (L"cs");
      } else {
        EdbPrintInstructionName (L"cc");
      }
    }

    InstructionAddress += 2;
    if ((Modifiers & OPCODE_M_IMMDATA64) != 0) {
      CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
      if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
        EdbPrintData64 (Data64);
      } else {
        return 0;
      }
    } else {
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      EdbPrintRegister1 (Operands);

      if ((Operands & OPERAND_M_INDIRECT1) == 0) {
        if ((Modifiers & OPCODE_M_IMMDATA) == 0) {
          Data32 = 0;
        }
        EdbPrintImmDatan (Data32);
      } else {
        EdbPrintRawIndexData32 (Data32);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - JMP8.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmJMP8 (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8   Modifiers;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_JMP8);
  Modifiers  = GET_MODIFIERS (InstructionAddress);

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"JMP8");
    if ((Modifiers & CONDITION_M_CONDITIONAL) != 0) {
      if ((Modifiers & JMP_M_CS) != 0) {
        EdbPrintInstructionName (L"cs");
      } else {
        EdbPrintInstructionName (L"cc");
      }
    }

    EdbPrintData8 (*(UINT8 *)(UINTN)(InstructionAddress + 1));

    EdbPostInstructionString ();
  }

  return 2;
}

/**

  Disasm instruction - CALL.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmCALL (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8   Modifiers;
  UINT8   Operands;
  UINTN   Size;
  UINT32  Data32;
  UINT64  Data64;
  UINT64  Ip;
  UINTN   Result;
  EFI_PHYSICAL_ADDRESS      SavedInstructionAddress;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_CALL);
  SavedInstructionAddress = InstructionAddress;

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Size = (UINTN)mJMPLen[(Modifiers >> 6) & 0x03];

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"CALL");
//    if (Modifiers & OPCODE_M_IMMDATA64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }
    if ((Operands & OPERAND_M_NATIVE_CALL) != 0) {
      EdbPrintInstructionName (L"EX");
    }
//    if ((Operands & OPERAND_M_RELATIVE_ADDR) == 0) {
//      EdbPrintInstructionName (L"a");
//    }

    InstructionAddress += 2;
    if ((Modifiers & OPCODE_M_IMMDATA64) != 0) {
      CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
      Ip = Data64;
      if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
        Result = EdbFindAndPrintSymbol ((UINTN)Ip);
        if (Result == 0) {
          EdbPrintData64 (Data64);
        }
      } else {
        return 0;
      }
    } else {
      if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
        CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      } else {
        Data32 = 0;
      }

      if ((Operands & OPERAND_M_OP1) == 0) {
        Ip = (UINT64)Data32;
      } else {
        Ip = GetRegisterValue (SystemContext, (Operands & OPERAND_M_OP1));
      }

      if ((Operands & OPERAND_M_INDIRECT1) == 0) {
        if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {
          Result = EdbFindAndPrintSymbol ((UINTN)(SavedInstructionAddress + Ip + Size));
        } else {
          Result = EdbFindAndPrintSymbol ((UINTN)Ip);
        }
        if (Result == 0) {
          EdbPrintRegister1 (Operands);
          if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
            EdbPrintImmData32 (Data32);
          }
        }
      } else {
        EdbPrintRegister1 (Operands);
        if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
          EdbPrintRawIndexData32 (Data32);
        }
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - RET.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmRET (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_RET);

  if (*(UINT8 *)(UINTN)(InstructionAddress + 1) != 0) {
    return 0;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"RET");

    EdbPostInstructionString ();
  }

  return 2;
}

/**

  Disasm instruction - CMP.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmCMP (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Opcode;
  UINT8  Modifiers;
  UINT8  Operands;
  UINT16 Data16;
  UINTN  Size;

  ASSERT (
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPEQ)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPLTE)  ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPGTE)  ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPULTE) ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPUGTE)
    );

  Opcode     = GET_OPCODE (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"CMP");
//    if (Modifiers & OPCODE_M_64BIT) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }
    switch (Opcode) {
    case OPCODE_CMPEQ:
      EdbPrintInstructionName (L"eq");
      break;
    case OPCODE_CMPLTE:
      EdbPrintInstructionName (L"lte");
      break;
    case OPCODE_CMPGTE:
      EdbPrintInstructionName (L"gte");
      break;
    case OPCODE_CMPULTE:
      EdbPrintInstructionName (L"ulte");
      break;
    case OPCODE_CMPUGTE:
      EdbPrintInstructionName (L"ugte");
      break;
    }

    EdbPrintRegister1 (Operands);
    InstructionAddress += 2;

    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    if ((Modifiers & OPCODE_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT2) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - Unsigned Data Manipulate.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmUnsignedDataManip (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Opcode;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (
    (GET_OPCODE(InstructionAddress) == OPCODE_NOT)    ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MULU)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_DIVU)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MODU)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_AND)    ||
    (GET_OPCODE(InstructionAddress) == OPCODE_OR)     ||
    (GET_OPCODE(InstructionAddress) == OPCODE_XOR)    ||
    (GET_OPCODE(InstructionAddress) == OPCODE_SHL)    ||
    (GET_OPCODE(InstructionAddress) == OPCODE_SHR)    ||
    (GET_OPCODE(InstructionAddress) == OPCODE_EXTNDB) ||
    (GET_OPCODE(InstructionAddress) == OPCODE_EXTNDW) ||
    (GET_OPCODE(InstructionAddress) == OPCODE_EXTNDD)
    );

  Opcode     = GET_OPCODE (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & DATAMANIP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    switch (Opcode) {
    case OPCODE_NOT:
      EdbPrintInstructionName (L"NOT");
      break;
    case OPCODE_MULU:
      EdbPrintInstructionName (L"MULU");
      break;
    case OPCODE_DIVU:
      EdbPrintInstructionName (L"DIVU");
      break;
    case OPCODE_MODU:
      EdbPrintInstructionName (L"MODU");
      break;
    case OPCODE_AND:
      EdbPrintInstructionName (L"AND");
      break;
    case OPCODE_OR:
      EdbPrintInstructionName (L"OR");
      break;
    case OPCODE_XOR:
      EdbPrintInstructionName (L"XOR");
      break;
    case OPCODE_SHL:
      EdbPrintInstructionName (L"SHL");
      break;
    case OPCODE_SHR:
      EdbPrintInstructionName (L"SHR");
      break;
    case OPCODE_EXTNDB:
      EdbPrintInstructionName (L"EXTNDB");
      break;
    case OPCODE_EXTNDW:
      EdbPrintInstructionName (L"EXTNDW");
      break;
    case OPCODE_EXTNDD:
      EdbPrintInstructionName (L"EXTNDD");
      break;
    }
//    if (Modifiers & DATAMANIP_M_64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }

    EdbPrintRegister1 (Operands);
    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & DATAMANIP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT2) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - Signed Data Manipulate,

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmSignedDataManip (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Opcode;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (
    (GET_OPCODE(InstructionAddress) == OPCODE_NEG)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_ADD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_SUB)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MUL)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_DIV)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_ASHR)
    );

  Opcode     = GET_OPCODE (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & DATAMANIP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    switch (Opcode) {
    case OPCODE_NEG:
      EdbPrintInstructionName (L"NEG");
      break;
    case OPCODE_ADD:
      EdbPrintInstructionName (L"ADD");
      break;
    case OPCODE_SUB:
      EdbPrintInstructionName (L"SUB");
      break;
    case OPCODE_MUL:
      EdbPrintInstructionName (L"MUL");
      break;
    case OPCODE_DIV:
      EdbPrintInstructionName (L"DIV");
      break;
    case OPCODE_MOD:
      EdbPrintInstructionName (L"MOD");
      break;
    case OPCODE_ASHR:
      EdbPrintInstructionName (L"ASHR");
      break;
    }
//    if (Modifiers & DATAMANIP_M_64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }

    EdbPrintRegister1 (Operands);
    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & DATAMANIP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT2) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVxx.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVxx (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8   Modifiers;
  UINT8   Opcode;
  UINT8   Operands;
  UINTN   Size;
  UINT16  Data16;
  UINT32  Data32;
  UINT64  Data64;

  ASSERT (
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVBW)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVWW)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVDW)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVQW)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVBD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVWD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVDD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVQD)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVQQ)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVNW)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_MOVND)
    );

  Opcode     = GET_OPCODE (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Size = 2;
  if ((Modifiers & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) != 0) {
    if ((Opcode <= OPCODE_MOVQW) || (Opcode == OPCODE_MOVNW)) {
      if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
        Size += 2;
      }
      if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
        Size += 2;
      }
    } else if (((Opcode <= OPCODE_MOVQD) || (Opcode == OPCODE_MOVND)) != 0) {
      if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
        Size += 4;
      }
      if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
        Size += 4;
      }
    } else if (Opcode == OPCODE_MOVQQ) {
      if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
        Size += 8;
      }
      if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
        Size += 8;
      }
    }
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOV");
    switch (Opcode) {
    case OPCODE_MOVBW:
      EdbPrintInstructionName (L"bw");
      break;
    case OPCODE_MOVWW:
      EdbPrintInstructionName (L"ww");
      break;
    case OPCODE_MOVDW:
      EdbPrintInstructionName (L"dw");
      break;
    case OPCODE_MOVQW:
      EdbPrintInstructionName (L"qw");
      break;
    case OPCODE_MOVBD:
      EdbPrintInstructionName (L"bd");
      break;
    case OPCODE_MOVWD:
      EdbPrintInstructionName (L"wd");
      break;
    case OPCODE_MOVDD:
      EdbPrintInstructionName (L"dd");
      break;
    case OPCODE_MOVQD:
      EdbPrintInstructionName (L"qd");
      break;
    case OPCODE_MOVQQ:
      EdbPrintInstructionName (L"qq");
      break;
    case OPCODE_MOVNW:
      EdbPrintInstructionName (L"nw");
      break;
    case OPCODE_MOVND:
      EdbPrintInstructionName (L"nd");
      break;
    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
      if ((Opcode <= OPCODE_MOVQW) || (Opcode == OPCODE_MOVNW)) {
        CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
        InstructionAddress += 2;
        EdbPrintRawIndexData16 (Data16);
      } else if ((Opcode <= OPCODE_MOVQD) || (Opcode == OPCODE_MOVND)) {
        CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
        InstructionAddress += 4;
        EdbPrintRawIndexData32 (Data32);
      } else if (Opcode == OPCODE_MOVQQ) {
        CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
        InstructionAddress += 8;
        EdbPrintRawIndexData64 (Data64);
      }
    }

    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
      if ((Opcode <= OPCODE_MOVQW) || (Opcode == OPCODE_MOVNW)) {
        CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
        EdbPrintRawIndexData16 (Data16);
      } else if ((Opcode <= OPCODE_MOVQD) || (Opcode == OPCODE_MOVND)) {
        CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
        EdbPrintRawIndexData32 (Data32);
      } else if (Opcode == OPCODE_MOVQQ) {
        CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
        EdbPrintRawIndexData64 (Data64);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVsnw.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVsnw (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_MOVSNW);

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Size = 2;
  if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
    Size += 2;
  }
  if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
    Size += 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOVsnw");

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      InstructionAddress += 2;
      EdbPrintRawIndexData16 (Data16);
    }

    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT2) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVsnd.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVsnd (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT32 Data32;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_MOVSND);

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);
  Size = 2;
  if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
    Size += 4;
  }
  if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
    Size += 4;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOVsnd");

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & OPCODE_M_IMMED_OP1) != 0) {
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      InstructionAddress += 4;
      EdbPrintRawIndexData32 (Data32);
    }

    EdbPrintComma ();
    EdbPrintRegister2 (Operands);

    if ((Modifiers & OPCODE_M_IMMED_OP2) != 0) {
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      if ((Operands & OPERAND_M_INDIRECT2) != 0) {
        EdbPrintRawIndexData32 (Data32);
      } else {
        EdbPrintImmDatan (Data32);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - LOADSP.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmLOADSP (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Operands;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_LOADSP);

  Operands   = GET_OPERANDS (InstructionAddress);

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"LOADSP");

    EdbPrintDedicatedRegister1 (Operands);

    EdbPrintRegister2 (Operands);

    EdbPostInstructionString ();
  }

  return 2;
}

/**

  Disasm instruction - STORESP.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmSTORESP (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Operands;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_STORESP);

  Operands   = GET_OPERANDS (InstructionAddress);

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"STORESP");

    EdbPrintRegister1 (Operands);

    EdbPrintDedicatedRegister2 (Operands);

    EdbPostInstructionString ();
  }

  return 2;
}


/**

  Disasm instruction - PUSH.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmPUSH (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_PUSH);

  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"PUSH");
//    if (Modifiers & PUSHPOP_M_64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT1) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - POP.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmPOP (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_POP);

  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"POP");
//    if (Modifiers & PUSHPOP_M_64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT1) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - CMPI.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmCMPI (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Opcode;
  UINT8  Operands;
  UINT16 Data16;
  UINT32 Data32;
  UINTN  Size;

  ASSERT (
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPIEQ)   ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPILTE)  ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPIGTE)  ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPIULTE) ||
    (GET_OPCODE(InstructionAddress) == OPCODE_CMPIUGTE)
    );

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Opcode     = GET_OPCODE (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);

  if ((Operands & 0xE0) != 0) {
    return 0;
  }

  Size = 2;
  if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {
    Size += 2;
  }
  if ((Modifiers & OPCODE_M_CMPI32_DATA) != 0) {
    Size += 4;
  } else {
    Size += 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"CMPI");
//    if (Modifiers & OPCODE_M_CMPI64) {
//      EdbPrintInstructionName (L"64");
//    } else {
//      EdbPrintInstructionName (L"32");
//    }
    if ((Modifiers & OPCODE_M_CMPI32_DATA) != 0) {
      EdbPrintInstructionName (L"d");
    } else {
      EdbPrintInstructionName (L"w");
    }
    switch (Opcode) {
    case OPCODE_CMPIEQ:
      EdbPrintInstructionName (L"eq");
      break;
    case OPCODE_CMPILTE:
      EdbPrintInstructionName (L"lte");
      break;
    case OPCODE_CMPIGTE:
      EdbPrintInstructionName (L"gte");
      break;
    case OPCODE_CMPIULTE:
      EdbPrintInstructionName (L"ulte");
      break;
    case OPCODE_CMPIUGTE:
      EdbPrintInstructionName (L"ugte");
      break;
    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      InstructionAddress += 2;
      EdbPrintRawIndexData16 (Data16);
    }

    EdbPrintComma ();

    if ((Modifiers & OPCODE_M_CMPI32_DATA) != 0) {
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      EdbPrintDatan (Data32);
    } else {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      EdbPrintDatan (Data16);
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - PUSHn.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmPUSHn (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_PUSHN);

  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"PUSHn");

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT1) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - POPn.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmPOPn (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_POPN);

  Operands   = GET_OPERANDS (InstructionAddress);
  Modifiers  = GET_MODIFIERS (InstructionAddress);
  if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
    Size = 4;
  } else {
    Size = 2;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"POPn");

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Modifiers & PUSHPOP_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      if ((Operands & OPERAND_M_INDIRECT1) != 0) {
        EdbPrintRawIndexData16 (Data16);
      } else {
        EdbPrintImmDatan (Data16);
      }
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVI.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVI (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;
  UINT32 Data32;
  UINT64 Data64;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_MOVI);

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);

  if ((Operands & MOVI_M_IMMDATA) != 0) {
    Size    = 4;
  } else {
    Size    = 2;
  }
  if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    Size += 2;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    Size += 4;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    Size += 8;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOVI");
    switch (Operands & MOVI_M_MOVEWIDTH) {
    case MOVI_MOVEWIDTH8:
      EdbPrintInstructionName (L"b");
      break;
    case MOVI_MOVEWIDTH16:
      EdbPrintInstructionName (L"w");
      break;
    case MOVI_MOVEWIDTH32:
      EdbPrintInstructionName (L"d");
      break;
    case MOVI_MOVEWIDTH64:
      EdbPrintInstructionName (L"q");
      break;
    }
    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      EdbPrintInstructionName (L"w");
      break;
    case MOVI_DATAWIDTH32:
      EdbPrintInstructionName (L"d");
      break;
    case MOVI_DATAWIDTH64:
      EdbPrintInstructionName (L"q");
      break;
    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Operands & MOVI_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      InstructionAddress += 2;
      EdbPrintRawIndexData16 (Data16);
    }

    EdbPrintComma ();

    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      EdbPrintDatan (Data16);
      break;
    case MOVI_DATAWIDTH32:
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      EdbPrintDatan (Data32);
      break;
    case MOVI_DATAWIDTH64:
      CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
      EdbPrintData64n (Data64);
      break;
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVIn.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVIn (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8  Modifiers;
  UINT8  Operands;
  UINTN  Size;
  UINT16 Data16;
  UINT32 Data32;
  UINT64 Data64;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_MOVIN);

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);

  if ((Operands & MOVI_M_IMMDATA) != 0) {
    Size    = 4;
  } else {
    Size    = 2;
  }
  if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    Size += 2;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    Size += 4;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    Size += 8;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOVIn");
    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      EdbPrintInstructionName (L"w");
      break;
    case MOVI_DATAWIDTH32:
      EdbPrintInstructionName (L"d");
      break;
    case MOVI_DATAWIDTH64:
      EdbPrintInstructionName (L"q");
      break;
    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Operands & MOVI_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      InstructionAddress += 2;
      EdbPrintRawIndexData16 (Data16);
    }

    EdbPrintComma ();

    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      EdbPrintRawIndexData16 (Data16);
      break;
    case MOVI_DATAWIDTH32:
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      EdbPrintRawIndexData32 (Data32);
      break;
    case MOVI_DATAWIDTH64:
      CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
      EdbPrintRawIndexData64 (Data64);
      break;
    }

    EdbPostInstructionString ();
  }

  return Size;
}

/**

  Disasm instruction - MOVREL.

  @param  InstructionAddress - The instruction address
  @param  SystemContext      - EBC system context.
  @param  DisasmString       - The instruction string

  @return Instruction length

**/
UINTN
EdbDisasmMOVREL (
  IN     EFI_PHYSICAL_ADDRESS      InstructionAddress,
  IN     EFI_SYSTEM_CONTEXT        SystemContext,
  OUT    CHAR16                    **DisasmString
  )
{
  UINT8   Modifiers;
  UINT8   Operands;
  UINTN   Size;
  UINT16  Data16;
  UINT32  Data32;
  UINT64  Data64;
  UINTN   Result;
  EFI_PHYSICAL_ADDRESS      SavedInstructionAddress;

  ASSERT (GET_OPCODE(InstructionAddress) == OPCODE_MOVREL);
  SavedInstructionAddress = InstructionAddress;

  Modifiers  = GET_MODIFIERS (InstructionAddress);
  Operands   = GET_OPERANDS (InstructionAddress);

  if ((Operands & MOVI_M_IMMDATA) != 0) {
    Size    = 4;
  } else {
    Size    = 2;
  }
  if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
    Size += 2;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
    Size += 4;
  } else if ((Modifiers & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
    Size += 8;
  } else {
    return 0;
  }

  //
  // Construct Disasm String
  //
  if (DisasmString != NULL) {
    *DisasmString = EdbPreInstructionString ();

    EdbPrintInstructionName (L"MOVrel");
    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      EdbPrintInstructionName (L"w");
      break;
    case MOVI_DATAWIDTH32:
      EdbPrintInstructionName (L"d");
      break;
    case MOVI_DATAWIDTH64:
      EdbPrintInstructionName (L"q");
      break;
    }

    EdbPrintRegister1 (Operands);

    InstructionAddress += 2;
    if ((Operands & MOVI_M_IMMDATA) != 0) {
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      InstructionAddress += 2;
      EdbPrintRawIndexData16 (Data16);
    }

    EdbPrintComma ();

    switch (Modifiers & MOVI_M_DATAWIDTH) {
    case MOVI_DATAWIDTH16:
      CopyMem(&Data16, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT16));
      Result = EdbFindAndPrintSymbol ((UINTN)(SavedInstructionAddress + Size + (INT16)Data16));
      if (Result == 0) {
        EdbPrintData16 (Data16);
      }
      break;
    case MOVI_DATAWIDTH32:
      CopyMem(&Data32, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT32));
      Result = EdbFindAndPrintSymbol ((UINTN)(SavedInstructionAddress + Size + (INT32)Data32));
      if (Result == 0) {
        EdbPrintData32 (Data32);
      }
      break;
    case MOVI_DATAWIDTH64:
      CopyMem(&Data64, (VOID *)(UINTN)(InstructionAddress), sizeof(UINT64));
      if (sizeof(UINTN) == sizeof(UINT64)) {
        Result = EdbFindAndPrintSymbol ((UINTN)(SavedInstructionAddress + Size + (INT64)Data64));
      } else {
        Result = 0;
      }
      if (Result == 0) {
        EdbPrintData64 (Data64);
      }
      break;
    }

    EdbPostInstructionString ();
  }

  return Size;
}