diff options
| author | Guo Mang <mang.guo@intel.com> | 2017-08-02 09:54:47 +0800 |
|---|---|---|
| committer | Guo Mang <mang.guo@intel.com> | 2017-09-05 19:45:08 +0800 |
| commit | 6c128c65b5ec0e5b8b5a0ccb165f3afd29e485f8 (patch) | |
| tree | 444372d92a0ae8991fe4d15eb3937df43690dfda /MdeModulePkg/Universal/EbcDxe | |
| parent | b207c6434d7a5a4502975d322312e07017e8a8cb (diff) | |
| download | edk2-platforms-6c128c65b5ec0e5b8b5a0ccb165f3afd29e485f8.tar.xz | |
Remove core packages since we can get them from edk2 repository
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Guo Mang <mang.guo@intel.com>
Diffstat (limited to 'MdeModulePkg/Universal/EbcDxe')
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcDxe.inf | 85 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcDxe.uni | bin | 2304 -> 0 bytes | |||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcDxeExtra.uni | bin | 1354 -> 0 bytes | |||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcExecute.c | 5350 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcExecute.h | 339 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcInt.c | 1406 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/EbcInt.h | 278 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.S | 83 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.asm | 207 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ia32/EbcSupport.c | 529 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s | 206 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c | 879 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h | 41 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S | 147 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.asm | 246 | ||||
| -rw-r--r-- | MdeModulePkg/Universal/EbcDxe/X64/EbcSupport.c | 573 |
16 files changed, 0 insertions, 10369 deletions
diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf deleted file mode 100644 index 0dfe005e7b..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf +++ /dev/null @@ -1,85 +0,0 @@ -## @file
-# Module that produces EBC Interprete and EBC Debug Support protocols.
-#
-# This module implements EFI Byte Code (EBC) Virtual Machine that can provide
-# platform and processor-independent mechanisms for loading and executing EFI
-# device drivers.
-#
-# Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
-# 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.
-#
-##
-
-[Defines]
- INF_VERSION = 0x00010005
- BASE_NAME = EbcDxe
- MODULE_UNI_FILE = EbcDxe.uni
- FILE_GUID = 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7
- MODULE_TYPE = DXE_DRIVER
- VERSION_STRING = 1.0
- ENTRY_POINT = InitializeEbcDriver
-
-#
-# The following information is for reference only and not required by the build tools.
-#
-# VALID_ARCHITECTURES = IA32 X64 IPF
-#
-
-[Sources]
- EbcExecute.h
- EbcExecute.c
- EbcInt.h
- EbcInt.c
-
-[Sources.Ia32]
- Ia32/EbcSupport.c
- Ia32/EbcLowLevel.S
- Ia32/EbcLowLevel.asm
-
-[Sources.X64]
- X64/EbcSupport.c
- X64/EbcLowLevel.S
- X64/EbcLowLevel.asm
-
-[Sources.IPF]
- Ipf/EbcSupport.h
- Ipf/EbcSupport.c
- Ipf/EbcLowLevel.s
-
-
-[Packages]
- MdePkg/MdePkg.dec
- MdeModulePkg/MdeModulePkg.dec
-
-[LibraryClasses]
- MemoryAllocationLib
- UefiBootServicesTableLib
- BaseMemoryLib
- UefiDriverEntryPoint
- DebugLib
- BaseLib
-
-
-[Protocols]
- gEfiDebugSupportProtocolGuid ## PRODUCES
- gEfiEbcProtocolGuid ## PRODUCES
- gEfiEbcVmTestProtocolGuid ## SOMETIMES_PRODUCES
- gEfiEbcSimpleDebuggerProtocolGuid ## SOMETIMES_CONSUMES
-
-[Depex]
- TRUE
-
-# [Event]
-#
-# Periodic timer event to support EFI debug support protocol for EBC image.
-#
-# EVENT_TYPE_PERIODIC_TIMER ## CONSUMES
-
-[UserExtensions.TianoCore."ExtraFiles"]
- EbcDxeExtra.uni
\ No newline at end of file diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.uni b/MdeModulePkg/Universal/EbcDxe/EbcDxe.uni Binary files differdeleted file mode 100644 index 2c81a105c4..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcDxe.uni +++ /dev/null diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxeExtra.uni b/MdeModulePkg/Universal/EbcDxe/EbcDxeExtra.uni Binary files differdeleted file mode 100644 index 6a8adee72d..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcDxeExtra.uni +++ /dev/null diff --git a/MdeModulePkg/Universal/EbcDxe/EbcExecute.c b/MdeModulePkg/Universal/EbcDxe/EbcExecute.c deleted file mode 100644 index 433eea250f..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcExecute.c +++ /dev/null @@ -1,5350 +0,0 @@ -/** @file
- Contains code that implements the virtual machine.
-
-Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#include "EbcInt.h"
-#include "EbcExecute.h"
-
-
-//
-// Define some useful data size constants to allow switch statements based on
-// size of operands or data.
-//
-#define DATA_SIZE_INVALID 0
-#define DATA_SIZE_8 1
-#define DATA_SIZE_16 2
-#define DATA_SIZE_32 4
-#define DATA_SIZE_64 8
-#define DATA_SIZE_N 48 // 4 or 8
-//
-// Structure we'll use to dispatch opcodes to execute functions.
-//
-typedef struct {
- EFI_STATUS (*ExecuteFunction) (IN VM_CONTEXT * VmPtr);
-}
-VM_TABLE_ENTRY;
-
-typedef
-UINT64
-(*DATA_MANIP_EXEC_FUNCTION) (
- IN VM_CONTEXT * VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Decode a 16-bit index to determine the offset. Given an index value:
-
- b15 - sign bit
- b14:12 - number of bits in this index assigned to natural units (=a)
- ba:11 - constant units = ConstUnits
- b0:a - natural units = NaturalUnits
-
- Given this info, the offset can be computed by:
- offset = sign_bit * (ConstUnits + NaturalUnits * sizeof(UINTN))
-
- Max offset is achieved with index = 0x7FFF giving an offset of
- 0x27B (32-bit machine) or 0x477 (64-bit machine).
- Min offset is achieved with index =
-
- @param VmPtr A pointer to VM context.
- @param CodeOffset Offset from IP of the location of the 16-bit index
- to decode.
-
- @return The decoded offset.
-
-**/
-INT16
-VmReadIndex16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- );
-
-/**
- Decode a 32-bit index to determine the offset.
-
- @param VmPtr A pointer to VM context.
- @param CodeOffset Offset from IP of the location of the 32-bit index
- to decode.
-
- @return Converted index per EBC VM specification.
-
-**/
-INT32
-VmReadIndex32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- );
-
-/**
- Decode a 64-bit index to determine the offset.
-
- @param VmPtr A pointer to VM context.s
- @param CodeOffset Offset from IP of the location of the 64-bit index
- to decode.
-
- @return Converted index per EBC VM specification
-
-**/
-INT64
-VmReadIndex64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- );
-
-/**
- Reads 8-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 8-bit value from the memory address.
-
-**/
-UINT8
-VmReadMem8 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Reads 16-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 16-bit value from the memory address.
-
-**/
-UINT16
-VmReadMem16 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Reads 32-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 32-bit value from the memory address.
-
-**/
-UINT32
-VmReadMem32 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Reads 64-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 64-bit value from the memory address.
-
-**/
-UINT64
-VmReadMem64 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Read a natural value from memory. May or may not be aligned.
-
- @param VmPtr current VM context
- @param Addr the address to read from
-
- @return The natural value at address Addr.
-
-**/
-UINTN
-VmReadMemN (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Writes 8-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem8 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT8 Data
- );
-
-/**
- Writes 16-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem16 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT16 Data
- );
-
-/**
- Writes 32-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem32 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT32 Data
- );
-
-/**
- Reads 16-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 16-bit value from the code stream.
-
-**/
-UINT16
-VmReadCode16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 32-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 32-bit value from the code stream.
-
-**/
-UINT32
-VmReadCode32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 64-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 64-bit value from the code stream.
-
-**/
-UINT64
-VmReadCode64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 8-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT8
-VmReadImmed8 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 16-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT16
-VmReadImmed16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 32-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT32
-VmReadImmed32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Reads 64-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT64
-VmReadImmed64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- );
-
-/**
- Given an address that EBC is going to read from or write to, return
- an appropriate address that accounts for a gap in the stack.
- The stack for this application looks like this (high addr on top)
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
- The EBC assumes that its arguments are at the top of its stack, which
- is where the VM stack is really. Therefore if the EBC does memory
- accesses into the VM stack area, then we need to convert the address
- to point to the EBC entry point arguments area. Do this here.
-
- @param VmPtr A Pointer to VM context.
- @param Addr Address of interest
-
- @return The unchanged address if it's not in the VM stack region. Otherwise,
- adjust for the stack gap and return the modified address.
-
-**/
-UINTN
-ConvertStackAddr (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- );
-
-/**
- Execute all the EBC data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
- @param IsSignedOp Indicates whether the operand is signed or not.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteDataManip (
- IN VM_CONTEXT *VmPtr,
- IN BOOLEAN IsSignedOp
- );
-
-//
-// Functions that execute VM opcodes
-//
-/**
- Execute the EBC BREAK instruction.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteBREAK (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the JMP instruction.
-
- Instruction syntax:
- JMP64{cs|cc} Immed64
- JMP32{cs|cc} {@}R1 {Immed32|Index32}
-
- Encoding:
- b0.7 - immediate data present
- b0.6 - 1 = 64 bit immediate data
- 0 = 32 bit immediate data
- b1.7 - 1 = conditional
- b1.6 1 = CS (condition set)
- 0 = CC (condition clear)
- b1.4 1 = relative address
- 0 = absolute address
- b1.3 1 = operand1 indirect
- b1.2-0 operand 1
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteJMP (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC JMP8 instruction.
-
- Instruction syntax:
- JMP8{cs|cc} Offset/2
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteJMP8 (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Implements the EBC CALL instruction.
-
- Instruction format:
- CALL64 Immed64
- CALL32 {@}R1 {Immed32|Index32}
- CALLEX64 Immed64
- CALLEX16 {@}R1 {Immed32}
-
- If Rx == R0, then it's a PC relative call to PC = PC + imm32.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCALL (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC RET instruction.
-
- Instruction syntax:
- RET
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteRET (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC CMP instruction.
-
- Instruction syntax:
- CMP[32|64][eq|lte|gte|ulte|ugte] R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCMP (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC CMPI instruction
-
- Instruction syntax:
- CMPI[32|64]{w|d}[eq|lte|gte|ulte|ugte] {@}Rx {Index16}, Immed16|Immed32
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCMPI (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the MOVxx instructions.
-
- Instruction format:
-
- MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32}
- MOVqq {@}R1 {Index64}, {@}R2 {Index64}
-
- Copies contents of [R2] -> [R1], zero extending where required.
-
- First character indicates the size of the move.
- Second character indicates the size of the index(s).
-
- Invalid to have R1 direct with index.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVxx (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC MOVI.
-
- Instruction syntax:
-
- MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64
-
- First variable character specifies the move size
- Second variable character specifies size of the immediate data
-
- Sign-extend the immediate data to the size of the operation, and zero-extend
- if storing to a register.
-
- Operand1 direct with index/immed is invalid.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVI (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC MOV immediate natural. This instruction moves an immediate
- index value into a register or memory location.
-
- Instruction syntax:
-
- MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVIn (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC MOVREL instruction.
- Dest <- Ip + ImmData
-
- Instruction syntax:
-
- MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVREL (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC PUSHn instruction
-
- Instruction syntax:
- PUSHn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePUSHn (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC PUSH instruction.
-
- Instruction syntax:
- PUSH[32|64] {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePUSH (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC POPn instruction.
-
- Instruction syntax:
- POPn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePOPn (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC POP instruction.
-
- Instruction syntax:
- POPn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePOP (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute all the EBC signed data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteSignedDataManip (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute all the EBC unsigned data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteUnsignedDataManip (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC LOADSP instruction.
-
- Instruction syntax:
- LOADSP SP1, R2
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteLOADSP (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC STORESP instruction.
-
- Instruction syntax:
- STORESP Rx, FLAGS|IP
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteSTORESP (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC MOVsnw instruction. This instruction loads a signed
- natural value from memory or register to another memory or register. On
- 32-bit machines, the value gets sign-extended to 64 bits if the destination
- is a register.
-
- Instruction syntax:
-
- MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32}
-
- 0:7 1=>operand1 index present
- 0:6 1=>operand2 index present
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVsnd (
- IN VM_CONTEXT *VmPtr
- );
-
-/**
- Execute the EBC MOVsnw instruction. This instruction loads a signed
- natural value from memory or register to another memory or register. On
- 32-bit machines, the value gets sign-extended to 64 bits if the destination
- is a register.
-
- Instruction syntax:
-
- MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16}
-
- 0:7 1=>operand1 index present
- 0:6 1=>operand2 index present
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVsnw (
- IN VM_CONTEXT *VmPtr
- );
-
-//
-// Data manipulation subfunctions
-//
-/**
- Execute the EBC NOT instruction.s
-
- Instruction syntax:
- NOT[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return ~Op2
-
-**/
-UINT64
-ExecuteNOT (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC NEG instruction.
-
- Instruction syntax:
- NEG[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op2 * -1
-
-**/
-UINT64
-ExecuteNEG (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC ADD instruction.
-
- Instruction syntax:
- ADD[32|64] {@}R1, {@}R2 {Index16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 + Op2
-
-**/
-UINT64
-ExecuteADD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC SUB instruction.
-
- Instruction syntax:
- SUB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 - Op2
-
-**/
-UINT64
-ExecuteSUB (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC MUL instruction.
-
- Instruction syntax:
- SUB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 * Op2
-
-**/
-UINT64
-ExecuteMUL (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC MULU instruction
-
- Instruction syntax:
- MULU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (unsigned)Op1 * (unsigned)Op2
-
-**/
-UINT64
-ExecuteMULU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC DIV instruction.
-
- Instruction syntax:
- DIV[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 / Op2
-
-**/
-UINT64
-ExecuteDIV (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC DIVU instruction
-
- Instruction syntax:
- DIVU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (unsigned)Op1 / (unsigned)Op2
-
-**/
-UINT64
-ExecuteDIVU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC MOD instruction.
-
- Instruction syntax:
- MOD[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 MODULUS Op2
-
-**/
-UINT64
-ExecuteMOD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC MODU instruction.
-
- Instruction syntax:
- MODU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 UNSIGNED_MODULUS Op2
-
-**/
-UINT64
-ExecuteMODU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC AND instruction.
-
- Instruction syntax:
- AND[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 AND Op2
-
-**/
-UINT64
-ExecuteAND (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC OR instruction.
-
- Instruction syntax:
- OR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 OR Op2
-
-**/
-UINT64
-ExecuteOR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC XOR instruction.
-
- Instruction syntax:
- XOR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 XOR Op2
-
-**/
-UINT64
-ExecuteXOR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC SHL shift left instruction.
-
- Instruction syntax:
- SHL[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 << Op2
-
-**/
-UINT64
-ExecuteSHL (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC SHR instruction.
-
- Instruction syntax:
- SHR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 >> Op2 (unsigned operands)
-
-**/
-UINT64
-ExecuteSHR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC ASHR instruction.
-
- Instruction syntax:
- ASHR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 >> Op2 (signed)
-
-**/
-UINT64
-ExecuteASHR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC EXTNDB instruction to sign-extend a byte value.
-
- Instruction syntax:
- EXTNDB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT8)Op2
-
-**/
-UINT64
-ExecuteEXTNDB (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC EXTNDW instruction to sign-extend a 16-bit value.
-
- Instruction syntax:
- EXTNDW[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT16)Op2
-
-**/
-UINT64
-ExecuteEXTNDW (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-/**
- Execute the EBC EXTNDD instruction to sign-extend a 32-bit value.
-
- Instruction syntax:
- EXTNDD[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT32)Op2
-
-**/
-UINT64
-ExecuteEXTNDD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- );
-
-//
-// Once we retrieve the operands for the data manipulation instructions,
-// call these functions to perform the operation.
-//
-CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {
- ExecuteNOT,
- ExecuteNEG,
- ExecuteADD,
- ExecuteSUB,
- ExecuteMUL,
- ExecuteMULU,
- ExecuteDIV,
- ExecuteDIVU,
- ExecuteMOD,
- ExecuteMODU,
- ExecuteAND,
- ExecuteOR,
- ExecuteXOR,
- ExecuteSHL,
- ExecuteSHR,
- ExecuteASHR,
- ExecuteEXTNDB,
- ExecuteEXTNDW,
- ExecuteEXTNDD,
-};
-
-CONST VM_TABLE_ENTRY mVmOpcodeTable[] = {
- { ExecuteBREAK }, // opcode 0x00
- { ExecuteJMP }, // opcode 0x01
- { ExecuteJMP8 }, // opcode 0x02
- { ExecuteCALL }, // opcode 0x03
- { ExecuteRET }, // opcode 0x04
- { ExecuteCMP }, // opcode 0x05 CMPeq
- { ExecuteCMP }, // opcode 0x06 CMPlte
- { ExecuteCMP }, // opcode 0x07 CMPgte
- { ExecuteCMP }, // opcode 0x08 CMPulte
- { ExecuteCMP }, // opcode 0x09 CMPugte
- { ExecuteUnsignedDataManip }, // opcode 0x0A NOT
- { ExecuteSignedDataManip }, // opcode 0x0B NEG
- { ExecuteSignedDataManip }, // opcode 0x0C ADD
- { ExecuteSignedDataManip }, // opcode 0x0D SUB
- { ExecuteSignedDataManip }, // opcode 0x0E MUL
- { ExecuteUnsignedDataManip }, // opcode 0x0F MULU
- { ExecuteSignedDataManip }, // opcode 0x10 DIV
- { ExecuteUnsignedDataManip }, // opcode 0x11 DIVU
- { ExecuteSignedDataManip }, // opcode 0x12 MOD
- { ExecuteUnsignedDataManip }, // opcode 0x13 MODU
- { ExecuteUnsignedDataManip }, // opcode 0x14 AND
- { ExecuteUnsignedDataManip }, // opcode 0x15 OR
- { ExecuteUnsignedDataManip }, // opcode 0x16 XOR
- { ExecuteUnsignedDataManip }, // opcode 0x17 SHL
- { ExecuteUnsignedDataManip }, // opcode 0x18 SHR
- { ExecuteSignedDataManip }, // opcode 0x19 ASHR
- { ExecuteUnsignedDataManip }, // opcode 0x1A EXTNDB
- { ExecuteUnsignedDataManip }, // opcode 0x1B EXTNDW
- { ExecuteUnsignedDataManip }, // opcode 0x1C EXTNDD
- { ExecuteMOVxx }, // opcode 0x1D MOVBW
- { ExecuteMOVxx }, // opcode 0x1E MOVWW
- { ExecuteMOVxx }, // opcode 0x1F MOVDW
- { ExecuteMOVxx }, // opcode 0x20 MOVQW
- { ExecuteMOVxx }, // opcode 0x21 MOVBD
- { ExecuteMOVxx }, // opcode 0x22 MOVWD
- { ExecuteMOVxx }, // opcode 0x23 MOVDD
- { ExecuteMOVxx }, // opcode 0x24 MOVQD
- { ExecuteMOVsnw }, // opcode 0x25 MOVsnw
- { ExecuteMOVsnd }, // opcode 0x26 MOVsnd
- { NULL }, // opcode 0x27
- { ExecuteMOVxx }, // opcode 0x28 MOVqq
- { ExecuteLOADSP }, // opcode 0x29 LOADSP SP1, R2
- { ExecuteSTORESP }, // opcode 0x2A STORESP R1, SP2
- { ExecutePUSH }, // opcode 0x2B PUSH {@}R1 [imm16]
- { ExecutePOP }, // opcode 0x2C POP {@}R1 [imm16]
- { ExecuteCMPI }, // opcode 0x2D CMPIEQ
- { ExecuteCMPI }, // opcode 0x2E CMPILTE
- { ExecuteCMPI }, // opcode 0x2F CMPIGTE
- { ExecuteCMPI }, // opcode 0x30 CMPIULTE
- { ExecuteCMPI }, // opcode 0x31 CMPIUGTE
- { ExecuteMOVxx }, // opcode 0x32 MOVN
- { ExecuteMOVxx }, // opcode 0x33 MOVND
- { NULL }, // opcode 0x34
- { ExecutePUSHn }, // opcode 0x35
- { ExecutePOPn }, // opcode 0x36
- { ExecuteMOVI }, // opcode 0x37 - mov immediate data
- { ExecuteMOVIn }, // opcode 0x38 - mov immediate natural
- { ExecuteMOVREL }, // opcode 0x39 - move data relative to PC
- { NULL }, // opcode 0x3a
- { NULL }, // opcode 0x3b
- { NULL }, // opcode 0x3c
- { NULL }, // opcode 0x3d
- { NULL }, // opcode 0x3e
- { NULL } // opcode 0x3f
-};
-
-//
-// Length of JMP instructions, depending on upper two bits of opcode.
-//
-CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 };
-
-/**
- Given a pointer to a new VM context, execute one or more instructions. This
- function is only used for test purposes via the EBC VM test protocol.
-
- @param This A pointer to the EFI_EBC_VM_TEST_PROTOCOL structure.
- @param VmPtr A pointer to a VM context.
- @param InstructionCount A pointer to a UINTN value holding the number of
- instructions to execute. If it holds value of 0,
- then the instruction to be executed is 1.
-
- @retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
- @retval EFI_SUCCESS All of the instructions are executed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcExecuteInstructions (
- IN EFI_EBC_VM_TEST_PROTOCOL *This,
- IN VM_CONTEXT *VmPtr,
- IN OUT UINTN *InstructionCount
- )
-{
- UINTN ExecFunc;
- EFI_STATUS Status;
- UINTN InstructionsLeft;
- UINTN SavedInstructionCount;
-
- Status = EFI_SUCCESS;
-
- if (*InstructionCount == 0) {
- InstructionsLeft = 1;
- } else {
- InstructionsLeft = *InstructionCount;
- }
-
- SavedInstructionCount = *InstructionCount;
- *InstructionCount = 0;
-
- //
- // Index into the opcode table using the opcode byte for this instruction.
- // This gives you the execute function, which we first test for null, then
- // call it if it's not null.
- //
- while (InstructionsLeft != 0) {
- ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
- if (ExecFunc == (UINTN) NULL) {
- EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);
- return EFI_UNSUPPORTED;
- } else {
- mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr);
- *InstructionCount = *InstructionCount + 1;
- }
-
- //
- // Decrement counter if applicable
- //
- if (SavedInstructionCount != 0) {
- InstructionsLeft--;
- }
- }
-
- return Status;
-}
-
-
-/**
- Execute an EBC image from an entry point or from a published protocol.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
- @retval EFI_SUCCESS All of the instructions are executed successfully.
-
-**/
-EFI_STATUS
-EbcExecute (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINTN ExecFunc;
- UINT8 StackCorrupted;
- EFI_STATUS Status;
- EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL *EbcSimpleDebugger;
-
- mVmPtr = VmPtr;
- EbcSimpleDebugger = NULL;
- Status = EFI_SUCCESS;
- StackCorrupted = 0;
-
- //
- // Make sure the magic value has been put on the stack before we got here.
- //
- if (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE) {
- StackCorrupted = 1;
- }
-
- VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->Gpr[0] + 8);
-
- //
- // Try to get the debug support for EBC
- //
- DEBUG_CODE_BEGIN ();
- Status = gBS->LocateProtocol (
- &gEfiEbcSimpleDebuggerProtocolGuid,
- NULL,
- (VOID **) &EbcSimpleDebugger
- );
- if (EFI_ERROR (Status)) {
- EbcSimpleDebugger = NULL;
- }
- DEBUG_CODE_END ();
-
- //
- // Save the start IP for debug. For example, if we take an exception we
- // can print out the location of the exception relative to the entry point,
- // which could then be used in a disassembly listing to find the problem.
- //
- VmPtr->EntryPoint = (VOID *) VmPtr->Ip;
-
- //
- // We'll wait for this flag to know when we're done. The RET
- // instruction sets it if it runs out of stack.
- //
- VmPtr->StopFlags = 0;
- while ((VmPtr->StopFlags & STOPFLAG_APP_DONE) == 0) {
- //
- // If we've found a simple debugger protocol, call it
- //
- DEBUG_CODE_BEGIN ();
- if (EbcSimpleDebugger != NULL) {
- EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr);
- }
- DEBUG_CODE_END ();
-
- //
- // Use the opcode bits to index into the opcode dispatch table. If the
- // function pointer is null then generate an exception.
- //
- ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;
- if (ExecFunc == (UINTN) NULL) {
- EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);
- Status = EFI_UNSUPPORTED;
- goto Done;
- }
- //
- // The EBC VM is a strongly ordered processor, so perform a fence operation before
- // and after each instruction is executed.
- //
- MemoryFence ();
-
- mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr);
-
- MemoryFence ();
-
- //
- // If the step flag is set, signal an exception and continue. We don't
- // clear it here. Assuming the debugger is responsible for clearing it.
- //
- if (VMFLAG_ISSET (VmPtr, VMFLAGS_STEP)) {
- EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr);
- }
- //
- // Make sure stack has not been corrupted. Only report it once though.
- //
- if ((StackCorrupted == 0) && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) {
- EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);
- StackCorrupted = 1;
- }
- if ((StackCorrupted == 0) && ((UINT64)VmPtr->Gpr[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {
- EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);
- StackCorrupted = 1;
- }
- }
-
-Done:
- mVmPtr = NULL;
-
- return Status;
-}
-
-
-/**
- Execute the MOVxx instructions.
-
- Instruction format:
-
- MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32}
- MOVqq {@}R1 {Index64}, {@}R2 {Index64}
-
- Copies contents of [R2] -> [R1], zero extending where required.
-
- First character indicates the size of the move.
- Second character indicates the size of the index(s).
-
- Invalid to have R1 direct with index.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVxx (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 OpcMasked;
- UINT8 Operands;
- UINT8 Size;
- UINT8 MoveSize;
- INT16 Index16;
- INT32 Index32;
- INT64 Index64Op1;
- INT64 Index64Op2;
- UINT64 Data64;
- UINT64 DataMask;
- UINTN Source;
-
- Opcode = GETOPCODE (VmPtr);
- OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE);
-
- //
- // Get the operands byte so we can get R1 and R2
- //
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Assume no indexes
- //
- Index64Op1 = 0;
- Index64Op2 = 0;
- Data64 = 0;
-
- //
- // Determine if we have an index/immediate data. Base instruction size
- // is 2 (opcode + operands). Add to this size each index specified.
- //
- Size = 2;
- if ((Opcode & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) != 0) {
- //
- // Determine size of the index from the opcode. Then get it.
- //
- if ((OpcMasked <= OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVNW)) {
- //
- // MOVBW, MOVWW, MOVDW, MOVQW, and MOVNW have 16-bit immediate index.
- // Get one or both index values.
- //
- if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- Index64Op1 = (INT64) Index16;
- Size += sizeof (UINT16);
- }
-
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- Index16 = VmReadIndex16 (VmPtr, Size);
- Index64Op2 = (INT64) Index16;
- Size += sizeof (UINT16);
- }
- } else if ((OpcMasked <= OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVND)) {
- //
- // MOVBD, MOVWD, MOVDD, MOVQD, and MOVND have 32-bit immediate index
- //
- if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
- Index32 = VmReadIndex32 (VmPtr, 2);
- Index64Op1 = (INT64) Index32;
- Size += sizeof (UINT32);
- }
-
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- Index32 = VmReadIndex32 (VmPtr, Size);
- Index64Op2 = (INT64) Index32;
- Size += sizeof (UINT32);
- }
- } else if (OpcMasked == OPCODE_MOVQQ) {
- //
- // MOVqq -- only form with a 64-bit index
- //
- if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
- Index64Op1 = VmReadIndex64 (VmPtr, 2);
- Size += sizeof (UINT64);
- }
-
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- Index64Op2 = VmReadIndex64 (VmPtr, Size);
- Size += sizeof (UINT64);
- }
- } else {
- //
- // Obsolete MOVBQ, MOVWQ, MOVDQ, and MOVNQ have 64-bit immediate index
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- }
- //
- // Determine the size of the move, and create a mask for it so we can
- // clear unused bits.
- //
- if ((OpcMasked == OPCODE_MOVBW) || (OpcMasked == OPCODE_MOVBD)) {
- MoveSize = DATA_SIZE_8;
- DataMask = 0xFF;
- } else if ((OpcMasked == OPCODE_MOVWW) || (OpcMasked == OPCODE_MOVWD)) {
- MoveSize = DATA_SIZE_16;
- DataMask = 0xFFFF;
- } else if ((OpcMasked == OPCODE_MOVDW) || (OpcMasked == OPCODE_MOVDD)) {
- MoveSize = DATA_SIZE_32;
- DataMask = 0xFFFFFFFF;
- } else if ((OpcMasked == OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVQQ)) {
- MoveSize = DATA_SIZE_64;
- DataMask = (UINT64)~0;
- } else if ((OpcMasked == OPCODE_MOVNW) || (OpcMasked == OPCODE_MOVND)) {
- MoveSize = DATA_SIZE_N;
- DataMask = (UINT64)~0 >> (64 - 8 * sizeof (UINTN));
- } else {
- //
- // We were dispatched to this function and we don't recognize the opcode
- //
- EbcDebugSignalException (EXCEPT_EBC_UNDEFINED, EXCEPTION_FLAG_FATAL, VmPtr);
- return EFI_UNSUPPORTED;
- }
- //
- // Now get the source address
- //
- if (OPERAND2_INDIRECT (Operands)) {
- //
- // Indirect form @R2. Compute address of operand2
- //
- Source = (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
- //
- // Now get the data from the source. Always 0-extend and let the compiler
- // sign-extend where required.
- //
- switch (MoveSize) {
- case DATA_SIZE_8:
- Data64 = (UINT64) (UINT8) VmReadMem8 (VmPtr, Source);
- break;
-
- case DATA_SIZE_16:
- Data64 = (UINT64) (UINT16) VmReadMem16 (VmPtr, Source);
- break;
-
- case DATA_SIZE_32:
- Data64 = (UINT64) (UINT32) VmReadMem32 (VmPtr, Source);
- break;
-
- case DATA_SIZE_64:
- Data64 = (UINT64) VmReadMem64 (VmPtr, Source);
- break;
-
- case DATA_SIZE_N:
- Data64 = (UINT64) (UINTN) VmReadMemN (VmPtr, Source);
- break;
-
- default:
- //
- // not reached
- //
- break;
- }
- } else {
- //
- // Not indirect source: MOVxx {@}Rx, Ry [Index]
- //
- Data64 = (UINT64) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);
- //
- // Did Operand2 have an index? If so, treat as two signed values since
- // indexes are signed values.
- //
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- //
- // NOTE: need to find a way to fix this, most likely by changing the VM
- // implementation to remove the stack gap. To do that, we'd need to
- // allocate stack space for the VM and actually set the system
- // stack pointer to the allocated buffer when the VM starts.
- //
- // Special case -- if someone took the address of a function parameter
- // then we need to make sure it's not in the stack gap. We can identify
- // this situation if (Operand2 register == 0) && (Operand2 is direct)
- // && (Index applies to Operand2) && (Index > 0) && (Operand1 register != 0)
- // Situations that to be aware of:
- // * stack adjustments at beginning and end of functions R0 = R0 += stacksize
- //
- if ((OPERAND2_REGNUM (Operands) == 0) &&
- (!OPERAND2_INDIRECT (Operands)) &&
- (Index64Op2 > 0) &&
- (OPERAND1_REGNUM (Operands) == 0) &&
- (OPERAND1_INDIRECT (Operands))
- ) {
- Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64);
- }
- }
- }
- //
- // Now write it back
- //
- if (OPERAND1_INDIRECT (Operands)) {
- //
- // Reuse the Source variable to now be dest.
- //
- Source = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index64Op1);
- //
- // Do the write based on the size
- //
- switch (MoveSize) {
- case DATA_SIZE_8:
- VmWriteMem8 (VmPtr, Source, (UINT8) Data64);
- break;
-
- case DATA_SIZE_16:
- VmWriteMem16 (VmPtr, Source, (UINT16) Data64);
- break;
-
- case DATA_SIZE_32:
- VmWriteMem32 (VmPtr, Source, (UINT32) Data64);
- break;
-
- case DATA_SIZE_64:
- VmWriteMem64 (VmPtr, Source, Data64);
- break;
-
- case DATA_SIZE_N:
- VmWriteMemN (VmPtr, Source, (UINTN) Data64);
- break;
-
- default:
- //
- // not reached
- //
- break;
- }
- } else {
- //
- // Operand1 direct.
- // Make sure we didn't have an index on operand1.
- //
- if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // Direct storage in register. Clear unused bits and store back to
- // register.
- //
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC BREAK instruction.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteBREAK (
- IN VM_CONTEXT *VmPtr
- )
-{
- EFI_STATUS Status;
- UINT8 Operands;
- VOID *EbcEntryPoint;
- VOID *Thunk;
- UINT64 U64EbcEntryPoint;
- INT32 Offset;
-
- Thunk = NULL;
- Operands = GETOPERANDS (VmPtr);
- switch (Operands) {
- //
- // Runaway program break. Generate an exception and terminate
- //
- case 0:
- EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
- break;
-
- //
- // Get VM version -- return VM revision number in R7
- //
- case 1:
- //
- // Bits:
- // 63-17 = 0
- // 16-8 = Major version
- // 7-0 = Minor version
- //
- VmPtr->Gpr[7] = GetVmVersion ();
- break;
-
- //
- // Debugger breakpoint
- //
- case 3:
- VmPtr->StopFlags |= STOPFLAG_BREAKPOINT;
- //
- // See if someone has registered a handler
- //
- EbcDebugSignalException (
- EXCEPT_EBC_BREAKPOINT,
- EXCEPTION_FLAG_NONE,
- VmPtr
- );
- break;
-
- //
- // System call, which there are none, so NOP it.
- //
- case 4:
- break;
-
- //
- // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot)
- // "offset from self" pointer to the EBC entry point.
- // After we're done, *(UINT64 *)R7 will be the address of the new thunk.
- //
- case 5:
- Offset = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->Gpr[7]);
- U64EbcEntryPoint = (UINT64) (VmPtr->Gpr[7] + Offset + 4);
- EbcEntryPoint = (VOID *) (UINTN) U64EbcEntryPoint;
-
- //
- // Now create a new thunk
- //
- Status = EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);
- if (EFI_ERROR (Status)) {
- return Status;
- }
-
- //
- // Finally replace the EBC entry point memory with the thunk address
- //
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[7], (UINT64) (UINTN) Thunk);
- break;
-
- //
- // Compiler setting version per value in R7
- //
- case 6:
- VmPtr->CompilerVersion = (UINT32) VmPtr->Gpr[7];
- //
- // Check compiler version against VM version?
- //
- break;
-
- //
- // Unhandled break code. Signal exception.
- //
- default:
- EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);
- break;
- }
- //
- // Advance IP
- //
- VmPtr->Ip += 2;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the JMP instruction.
-
- Instruction syntax:
- JMP64{cs|cc} Immed64
- JMP32{cs|cc} {@}R1 {Immed32|Index32}
-
- Encoding:
- b0.7 - immediate data present
- b0.6 - 1 = 64 bit immediate data
- 0 = 32 bit immediate data
- b1.7 - 1 = conditional
- b1.6 1 = CS (condition set)
- 0 = CC (condition clear)
- b1.4 1 = relative address
- 0 = absolute address
- b1.3 1 = operand1 indirect
- b1.2-0 operand 1
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteJMP (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 CompareSet;
- UINT8 ConditionFlag;
- UINT8 Size;
- UINT8 Operand;
- UINT64 Data64;
- INT32 Index32;
- UINTN Addr;
-
- Operand = GETOPERANDS (VmPtr);
- Opcode = GETOPCODE (VmPtr);
-
- //
- // Get instruction length from the opcode. The upper two bits are used here
- // to index into the length array.
- //
- Size = mJMPLen[(Opcode >> 6) & 0x03];
-
- //
- // Decode instruction conditions
- // If we haven't met the condition, then simply advance the IP and return.
- //
- CompareSet = (UINT8) (((Operand & JMP_M_CS) != 0) ? 1 : 0);
- ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
- if ((Operand & CONDITION_M_CONDITIONAL) != 0) {
- if (CompareSet != ConditionFlag) {
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
- }
- }
- //
- // Check for 64-bit form and do it right away since it's the most
- // straight-forward form.
- //
- if ((Opcode & OPCODE_M_IMMDATA64) != 0) {
- //
- // Double check for immediate-data, which is required. If not there,
- // then signal an exception
- //
- if ((Opcode & OPCODE_M_IMMDATA) == 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_ERROR,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // 64-bit immediate data is full address. Read the immediate data,
- // check for alignment, and jump absolute.
- //
- Data64 = (UINT64) VmReadImmed64 (VmPtr, 2);
- if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) {
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
-
- return EFI_UNSUPPORTED;
- }
-
- //
- // Take jump -- relative or absolute
- //
- if ((Operand & JMP_M_RELATIVE) != 0) {
- VmPtr->Ip += (UINTN) Data64 + Size;
- } else {
- VmPtr->Ip = (VMIP) (UINTN) Data64;
- }
-
- return EFI_SUCCESS;
- }
- //
- // 32-bit forms:
- // Get the index if there is one. May be either an index, or an immediate
- // offset depending on indirect operand.
- // JMP32 @R1 Index32 -- immediate data is an index
- // JMP32 R1 Immed32 -- immedate data is an offset
- //
- if ((Opcode & OPCODE_M_IMMDATA) != 0) {
- if (OPERAND1_INDIRECT (Operand)) {
- Index32 = VmReadIndex32 (VmPtr, 2);
- } else {
- Index32 = VmReadImmed32 (VmPtr, 2);
- }
- } else {
- Index32 = 0;
- }
- //
- // Get the register data. If R == 0, then special case where it's ignored.
- //
- if (OPERAND1_REGNUM (Operand) == 0) {
- Data64 = 0;
- } else {
- Data64 = (UINT64) OPERAND1_REGDATA (VmPtr, Operand);
- }
- //
- // Decode the forms
- //
- if (OPERAND1_INDIRECT (Operand)) {
- //
- // Form: JMP32 @Rx {Index32}
- //
- Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32);
- if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
-
- return EFI_UNSUPPORTED;
- }
-
- if ((Operand & JMP_M_RELATIVE) != 0) {
- VmPtr->Ip += (UINTN) Addr + Size;
- } else {
- VmPtr->Ip = (VMIP) Addr;
- }
- } else {
- //
- // Form: JMP32 Rx {Immed32}
- //
- Addr = (UINTN) (Data64 + Index32);
- if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
-
- return EFI_UNSUPPORTED;
- }
-
- if ((Operand & JMP_M_RELATIVE) != 0) {
- VmPtr->Ip += (UINTN) Addr + Size;
- } else {
- VmPtr->Ip = (VMIP) Addr;
- }
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC JMP8 instruction.
-
- Instruction syntax:
- JMP8{cs|cc} Offset/2
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteJMP8 (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 ConditionFlag;
- UINT8 CompareSet;
- INT8 Offset;
-
- //
- // Decode instruction.
- //
- Opcode = GETOPCODE (VmPtr);
- CompareSet = (UINT8) (((Opcode & JMP_M_CS) != 0) ? 1 : 0);
- ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);
-
- //
- // If we haven't met the condition, then simply advance the IP and return
- //
- if ((Opcode & CONDITION_M_CONDITIONAL) != 0) {
- if (CompareSet != ConditionFlag) {
- VmPtr->Ip += 2;
- return EFI_SUCCESS;
- }
- }
- //
- // Get the offset from the instruction stream. It's relative to the
- // following instruction, and divided by 2.
- //
- Offset = VmReadImmed8 (VmPtr, 1);
- //
- // Want to check for offset == -2 and then raise an exception?
- //
- VmPtr->Ip += (Offset * 2) + 2;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC MOVI.
-
- Instruction syntax:
-
- MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64
-
- First variable character specifies the move size
- Second variable character specifies size of the immediate data
-
- Sign-extend the immediate data to the size of the operation, and zero-extend
- if storing to a register.
-
- Operand1 direct with index/immed is invalid.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVI (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT16 Index16;
- INT64 ImmData64;
- UINT64 Op1;
- UINT64 Mask64;
-
- //
- // Get the opcode and operands byte so we can get R1 and R2
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Get the index (16-bit) if present
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- Size = 4;
- } else {
- Index16 = 0;
- Size = 2;
- }
- //
- // Extract the immediate data. Sign-extend always.
- //
- if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
- ImmData64 = (INT64) (INT16) VmReadImmed16 (VmPtr, Size);
- Size += 2;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
- ImmData64 = (INT64) (INT32) VmReadImmed32 (VmPtr, Size);
- Size += 4;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
- ImmData64 = (INT64) VmReadImmed64 (VmPtr, Size);
- Size += 8;
- } else {
- //
- // Invalid encoding
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // Now write back the result
- //
- if (!OPERAND1_INDIRECT (Operands)) {
- //
- // Operand1 direct. Make sure it didn't have an index.
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // Writing directly to a register. Clear unused bits.
- //
- if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {
- Mask64 = 0x000000FF;
- } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {
- Mask64 = 0x0000FFFF;
- } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {
- Mask64 = 0x00000000FFFFFFFF;
- } else {
- Mask64 = (UINT64)~0;
- }
-
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64;
- } else {
- //
- // Get the address then write back based on size of the move
- //
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
- if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {
- VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64);
- } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {
- VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64);
- } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {
- VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64);
- } else {
- VmWriteMem64 (VmPtr, (UINTN) Op1, (UINT64) ImmData64);
- }
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC MOV immediate natural. This instruction moves an immediate
- index value into a register or memory location.
-
- Instruction syntax:
-
- MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVIn (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT16 Index16;
- INT16 ImmedIndex16;
- INT32 ImmedIndex32;
- INT64 ImmedIndex64;
- UINT64 Op1;
-
- //
- // Get the opcode and operands byte so we can get R1 and R2
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Get the operand1 index (16-bit) if present
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- Size = 4;
- } else {
- Index16 = 0;
- Size = 2;
- }
- //
- // Extract the immediate data and convert to a 64-bit index.
- //
- if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
- ImmedIndex16 = VmReadIndex16 (VmPtr, Size);
- ImmedIndex64 = (INT64) ImmedIndex16;
- Size += 2;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
- ImmedIndex32 = VmReadIndex32 (VmPtr, Size);
- ImmedIndex64 = (INT64) ImmedIndex32;
- Size += 4;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
- ImmedIndex64 = VmReadIndex64 (VmPtr, Size);
- Size += 8;
- } else {
- //
- // Invalid encoding
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // Now write back the result
- //
- if (!OPERAND1_INDIRECT (Operands)) {
- //
- // Check for MOVIn R1 Index16, Immed (not indirect, with index), which
- // is illegal
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
-
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = ImmedIndex64;
- } else {
- //
- // Get the address
- //
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
- VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN)(INTN) ImmedIndex64);
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC MOVREL instruction.
- Dest <- Ip + ImmData
-
- Instruction syntax:
-
- MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVREL (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT16 Index16;
- INT64 ImmData64;
- UINT64 Op1;
- UINT64 Op2;
-
- //
- // Get the opcode and operands byte so we can get R1 and R2
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Get the Operand 1 index (16-bit) if present
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- Size = 4;
- } else {
- Index16 = 0;
- Size = 2;
- }
- //
- // Get the immediate data.
- //
- if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {
- ImmData64 = (INT64) VmReadImmed16 (VmPtr, Size);
- Size += 2;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {
- ImmData64 = (INT64) VmReadImmed32 (VmPtr, Size);
- Size += 4;
- } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {
- ImmData64 = VmReadImmed64 (VmPtr, Size);
- Size += 8;
- } else {
- //
- // Invalid encoding
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
- //
- // Compute the value and write back the result
- //
- Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size);
- if (!OPERAND1_INDIRECT (Operands)) {
- //
- // Check for illegal combination of operand1 direct with immediate data
- //
- if ((Operands & MOVI_M_IMMDATA) != 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
-
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2;
- } else {
- //
- // Get the address = [Rx] + Index16
- // Write back the result. Always a natural size write, since
- // we're talking addresses here.
- //
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
- VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2);
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC MOVsnw instruction. This instruction loads a signed
- natural value from memory or register to another memory or register. On
- 32-bit machines, the value gets sign-extended to 64 bits if the destination
- is a register.
-
- Instruction syntax:
-
- MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16}
-
- 0:7 1=>operand1 index present
- 0:6 1=>operand2 index present
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVsnw (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT16 Op1Index;
- INT16 Op2Index;
- UINT64 Op2;
-
- //
- // Get the opcode and operand bytes
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- Op1Index = Op2Index = 0;
-
- //
- // Get the indexes if present.
- //
- Size = 2;
- if ((Opcode & OPCODE_M_IMMED_OP1) !=0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Op1Index = VmReadIndex16 (VmPtr, 2);
- } else {
- //
- // Illegal form operand1 direct with index: MOVsnw R1 Index16, {@}R2
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
-
- Size += sizeof (UINT16);
- }
-
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- if (OPERAND2_INDIRECT (Operands)) {
- Op2Index = VmReadIndex16 (VmPtr, Size);
- } else {
- Op2Index = VmReadImmed16 (VmPtr, Size);
- }
-
- Size += sizeof (UINT16);
- }
- //
- // Get the data from the source.
- //
- Op2 = (UINT64)(INT64)(INTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);
- if (OPERAND2_INDIRECT (Operands)) {
- Op2 = (UINT64)(INT64)(INTN)VmReadMemN (VmPtr, (UINTN) Op2);
- }
- //
- // Now write back the result.
- //
- if (!OPERAND1_INDIRECT (Operands)) {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;
- } else {
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC MOVsnw instruction. This instruction loads a signed
- natural value from memory or register to another memory or register. On
- 32-bit machines, the value gets sign-extended to 64 bits if the destination
- is a register.
-
- Instruction syntax:
-
- MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32}
-
- 0:7 1=>operand1 index present
- 0:6 1=>operand2 index present
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteMOVsnd (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT32 Op1Index;
- INT32 Op2Index;
- UINT64 Op2;
-
- //
- // Get the opcode and operand bytes
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- Op1Index = Op2Index = 0;
-
- //
- // Get the indexes if present.
- //
- Size = 2;
- if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Op1Index = VmReadIndex32 (VmPtr, 2);
- } else {
- //
- // Illegal form operand1 direct with index: MOVsnd R1 Index16,..
- //
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return EFI_UNSUPPORTED;
- }
-
- Size += sizeof (UINT32);
- }
-
- if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {
- if (OPERAND2_INDIRECT (Operands)) {
- Op2Index = VmReadIndex32 (VmPtr, Size);
- } else {
- Op2Index = VmReadImmed32 (VmPtr, Size);
- }
-
- Size += sizeof (UINT32);
- }
- //
- // Get the data from the source.
- //
- Op2 = (UINT64)(INT64)(INTN)(INT64)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);
- if (OPERAND2_INDIRECT (Operands)) {
- Op2 = (UINT64)(INT64)(INTN)(INT64)VmReadMemN (VmPtr, (UINTN) Op2);
- }
- //
- // Now write back the result.
- //
- if (!OPERAND1_INDIRECT (Operands)) {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;
- } else {
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC PUSHn instruction
-
- Instruction syntax:
- PUSHn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePUSHn (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- INT16 Index16;
- UINTN DataN;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Get index if present
- //
- if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- VmPtr->Ip += 4;
- } else {
- Index16 = 0;
- VmPtr->Ip += 2;
- }
- //
- // Get the data to push
- //
- if (OPERAND1_INDIRECT (Operands)) {
- DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
- } else {
- DataN = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16);
- }
- //
- // Adjust the stack down.
- //
- VmPtr->Gpr[0] -= sizeof (UINTN);
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], DataN);
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC PUSH instruction.
-
- Instruction syntax:
- PUSH[32|64] {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePUSH (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT32 Data32;
- UINT64 Data64;
- INT16 Index16;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
- //
- // Get immediate index if present, then advance the IP.
- //
- if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- VmPtr->Ip += 4;
- } else {
- Index16 = 0;
- VmPtr->Ip += 2;
- }
- //
- // Get the data to push
- //
- if ((Opcode & PUSHPOP_M_64) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
- } else {
- Data64 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
- }
- //
- // Adjust the stack down, then write back the data
- //
- VmPtr->Gpr[0] -= sizeof (UINT64);
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], Data64);
- } else {
- //
- // 32-bit data
- //
- if (OPERAND1_INDIRECT (Operands)) {
- Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));
- } else {
- Data32 = (UINT32) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;
- }
- //
- // Adjust the stack down and write the data
- //
- VmPtr->Gpr[0] -= sizeof (UINT32);
- VmWriteMem32 (VmPtr, (UINTN) VmPtr->Gpr[0], Data32);
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC POPn instruction.
-
- Instruction syntax:
- POPn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePOPn (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- INT16 Index16;
- UINTN DataN;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
- //
- // Get immediate data if present, and advance the IP
- //
- if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- VmPtr->Ip += 4;
- } else {
- Index16 = 0;
- VmPtr->Ip += 2;
- }
- //
- // Read the data off the stack, then adjust the stack pointer
- //
- DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);
- VmPtr->Gpr[0] += sizeof (UINTN);
- //
- // Do the write-back
- //
- if (OPERAND1_INDIRECT (Operands)) {
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);
- } else {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) ((UINTN) DataN + Index16);
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC POP instruction.
-
- Instruction syntax:
- POPn {@}R1 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecutePOP (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- INT16 Index16;
- INT32 Data32;
- UINT64 Data64;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
- //
- // Get immediate data if present, and advance the IP.
- //
- if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {
- if (OPERAND1_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- VmPtr->Ip += 4;
- } else {
- Index16 = 0;
- VmPtr->Ip += 2;
- }
- //
- // Get the data off the stack, then write it to the appropriate location
- //
- if ((Opcode & PUSHPOP_M_64) != 0) {
- //
- // Read the data off the stack, then adjust the stack pointer
- //
- Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);
- VmPtr->Gpr[0] += sizeof (UINT64);
- //
- // Do the write-back
- //
- if (OPERAND1_INDIRECT (Operands)) {
- VmWriteMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);
- } else {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 + Index16;
- }
- } else {
- //
- // 32-bit pop. Read it off the stack and adjust the stack pointer
- //
- Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->Gpr[0]);
- VmPtr->Gpr[0] += sizeof (UINT32);
- //
- // Do the write-back
- //
- if (OPERAND1_INDIRECT (Operands)) {
- VmWriteMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);
- } else {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;
- }
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Implements the EBC CALL instruction.
-
- Instruction format:
- CALL64 Immed64
- CALL32 {@}R1 {Immed32|Index32}
- CALLEX64 Immed64
- CALLEX16 {@}R1 {Immed32}
-
- If Rx == R0, then it's a PC relative call to PC = PC + imm32.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCALL (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- INT32 Immed32;
- UINT8 Size;
- INT64 Immed64;
- VOID *FramePtr;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
- //
- // Assign these as well to avoid compiler warnings
- //
- Immed64 = 0;
- Immed32 = 0;
-
- FramePtr = VmPtr->FramePtr;
- //
- // Determine the instruction size, and get immediate data if present
- //
- if ((Opcode & OPCODE_M_IMMDATA) != 0) {
- if ((Opcode & OPCODE_M_IMMDATA64) != 0) {
- Immed64 = VmReadImmed64 (VmPtr, 2);
- Size = 10;
- } else {
- //
- // If register operand is indirect, then the immediate data is an index
- //
- if (OPERAND1_INDIRECT (Operands)) {
- Immed32 = VmReadIndex32 (VmPtr, 2);
- } else {
- Immed32 = VmReadImmed32 (VmPtr, 2);
- }
-
- Size = 6;
- }
- } else {
- Size = 2;
- }
- //
- // If it's a call to EBC, adjust the stack pointer down 16 bytes and
- // put our return address and frame pointer on the VM stack.
- //
- if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {
- VmPtr->Gpr[0] -= 8;
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
- VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
- VmPtr->Gpr[0] -= 8;
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));
- }
- //
- // If 64-bit data, then absolute jump only
- //
- if ((Opcode & OPCODE_M_IMMDATA64) != 0) {
- //
- // Native or EBC call?
- //
- if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {
- VmPtr->Ip = (VMIP) (UINTN) Immed64;
- } else {
- //
- // Call external function, get the return value, and advance the IP
- //
- EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);
- }
- } else {
- //
- // Get the register data. If operand1 == 0, then ignore register and
- // take immediate data as relative or absolute address.
- // Compiler should take care of upper bits if 32-bit machine.
- //
- if (OPERAND1_REGNUM (Operands) != 0) {
- Immed64 = (UINT64) (UINTN) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
- }
- //
- // Get final address
- //
- if (OPERAND1_INDIRECT (Operands)) {
- Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32));
- } else {
- Immed64 += Immed32;
- }
- //
- // Now determine if external call, and then if relative or absolute
- //
- if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {
- //
- // EBC call. Relative or absolute? If relative, then it's relative to the
- // start of the next instruction.
- //
- if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {
- VmPtr->Ip += Immed64 + Size;
- } else {
- VmPtr->Ip = (VMIP) (UINTN) Immed64;
- }
- } else {
- //
- // Native call. Relative or absolute?
- //
- if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {
- EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->Gpr[0], FramePtr, Size);
- } else {
- if ((VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) != 0) {
- CpuBreakpoint ();
- }
-
- EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);
- }
- }
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC RET instruction.
-
- Instruction syntax:
- RET
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteRET (
- IN VM_CONTEXT *VmPtr
- )
-{
- //
- // If we're at the top of the stack, then simply set the done
- // flag and return
- //
- if (VmPtr->StackRetAddr == (UINT64) VmPtr->Gpr[0]) {
- VmPtr->StopFlags |= STOPFLAG_APP_DONE;
- } else {
- //
- // Pull the return address off the VM app's stack and set the IP
- // to it
- //
- if (!IS_ALIGNED ((UINTN) VmPtr->Gpr[0], sizeof (UINT16))) {
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- }
- //
- // Restore the IP and frame pointer from the stack
- //
- VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);
- VmPtr->Gpr[0] += 8;
- VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);
- VmPtr->Gpr[0] += 8;
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC CMP instruction.
-
- Instruction syntax:
- CMP[32|64][eq|lte|gte|ulte|ugte] R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCMP (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT16 Index16;
- UINT32 Flag;
- INT64 Op2;
- INT64 Op1;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
- //
- // Get the register data we're going to compare to
- //
- Op1 = VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
- //
- // Get immediate data
- //
- if ((Opcode & OPCODE_M_IMMDATA) != 0) {
- if (OPERAND2_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- Size = 4;
- } else {
- Index16 = 0;
- Size = 2;
- }
- //
- // Now get Op2
- //
- if (OPERAND2_INDIRECT (Operands)) {
- if ((Opcode & OPCODE_M_64BIT) != 0) {
- Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16));
- } else {
- //
- // 32-bit operations. 0-extend the values for all cases.
- //
- Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));
- }
- } else {
- Op2 = VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;
- }
- //
- // Now do the compare
- //
- Flag = 0;
- if ((Opcode & OPCODE_M_64BIT) != 0) {
- //
- // 64-bit compares
- //
- switch (Opcode & OPCODE_M_OPCODE) {
- case OPCODE_CMPEQ:
- if (Op1 == Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPLTE:
- if (Op1 <= Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPGTE:
- if (Op1 >= Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPULTE:
- if ((UINT64) Op1 <= (UINT64) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPUGTE:
- if ((UINT64) Op1 >= (UINT64) Op2) {
- Flag = 1;
- }
- break;
-
- default:
- ASSERT (0);
- }
- } else {
- //
- // 32-bit compares
- //
- switch (Opcode & OPCODE_M_OPCODE) {
- case OPCODE_CMPEQ:
- if ((INT32) Op1 == (INT32) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPLTE:
- if ((INT32) Op1 <= (INT32) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPGTE:
- if ((INT32) Op1 >= (INT32) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPULTE:
- if ((UINT32) Op1 <= (UINT32) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPUGTE:
- if ((UINT32) Op1 >= (UINT32) Op2) {
- Flag = 1;
- }
- break;
-
- default:
- ASSERT (0);
- }
- }
- //
- // Now set the flag accordingly for the comparison
- //
- if (Flag != 0) {
- VMFLAG_SET (VmPtr, VMFLAGS_CC);
- } else {
- VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);
- }
- //
- // Advance the IP
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC CMPI instruction
-
- Instruction syntax:
- CMPI[32|64]{w|d}[eq|lte|gte|ulte|ugte] {@}Rx {Index16}, Immed16|Immed32
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteCMPI (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Opcode;
- UINT8 Operands;
- UINT8 Size;
- INT64 Op1;
- INT64 Op2;
- INT16 Index16;
- UINT32 Flag;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Get operand1 index if present
- //
- Size = 2;
- if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- Size += 2;
- } else {
- Index16 = 0;
- }
- //
- // Get operand1 data we're going to compare to
- //
- Op1 = (INT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
- if (OPERAND1_INDIRECT (Operands)) {
- //
- // Indirect operand1. Fetch 32 or 64-bit value based on compare size.
- //
- if ((Opcode & OPCODE_M_CMPI64) != 0) {
- Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16);
- } else {
- Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16);
- }
- } else {
- //
- // Better not have been an index with direct. That is, CMPI R1 Index,...
- // is illegal.
- //
- if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_ERROR,
- VmPtr
- );
- VmPtr->Ip += Size;
- return EFI_UNSUPPORTED;
- }
- }
- //
- // Get immediate data -- 16- or 32-bit sign extended
- //
- if ((Opcode & OPCODE_M_CMPI32_DATA) != 0) {
- Op2 = (INT64) VmReadImmed32 (VmPtr, Size);
- Size += 4;
- } else {
- //
- // 16-bit immediate data. Sign extend always.
- //
- Op2 = (INT64) ((INT16) VmReadImmed16 (VmPtr, Size));
- Size += 2;
- }
- //
- // Now do the compare
- //
- Flag = 0;
- if ((Opcode & OPCODE_M_CMPI64) != 0) {
- //
- // 64 bit comparison
- //
- switch (Opcode & OPCODE_M_OPCODE) {
- case OPCODE_CMPIEQ:
- if (Op1 == (INT64) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPILTE:
- if (Op1 <= (INT64) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIGTE:
- if (Op1 >= (INT64) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIULTE:
- if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIUGTE:
- if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) {
- Flag = 1;
- }
- break;
-
- default:
- ASSERT (0);
- }
- } else {
- //
- // 32-bit comparisons
- //
- switch (Opcode & OPCODE_M_OPCODE) {
- case OPCODE_CMPIEQ:
- if ((INT32) Op1 == Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPILTE:
- if ((INT32) Op1 <= Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIGTE:
- if ((INT32) Op1 >= Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIULTE:
- if ((UINT32) Op1 <= (UINT32) Op2) {
- Flag = 1;
- }
- break;
-
- case OPCODE_CMPIUGTE:
- if ((UINT32) Op1 >= (UINT32) Op2) {
- Flag = 1;
- }
- break;
-
- default:
- ASSERT (0);
- }
- }
- //
- // Now set the flag accordingly for the comparison
- //
- if (Flag != 0) {
- VMFLAG_SET (VmPtr, VMFLAGS_CC);
- } else {
- VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);
- }
- //
- // Advance the IP
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC NOT instruction.s
-
- Instruction syntax:
- NOT[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return ~Op2
-
-**/
-UINT64
-ExecuteNOT (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return ~Op2;
-}
-
-
-/**
- Execute the EBC NEG instruction.
-
- Instruction syntax:
- NEG[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op2 * -1
-
-**/
-UINT64
-ExecuteNEG (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return ~Op2 + 1;
-}
-
-
-/**
- Execute the EBC ADD instruction.
-
- Instruction syntax:
- ADD[32|64] {@}R1, {@}R2 {Index16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 + Op2
-
-**/
-UINT64
-ExecuteADD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return Op1 + Op2;
-}
-
-
-/**
- Execute the EBC SUB instruction.
-
- Instruction syntax:
- SUB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 - Op2
-
-**/
-UINT64
-ExecuteSUB (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2));
- } else {
- return (UINT64) ((INT64) ((INT32) Op1 - (INT32) Op2));
- }
-}
-
-
-/**
- Execute the EBC MUL instruction.
-
- Instruction syntax:
- SUB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 * Op2
-
-**/
-UINT64
-ExecuteMUL (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return MultS64x64 ((INT64)Op1, (INT64)Op2);
- } else {
- return (UINT64) ((INT64) ((INT32) Op1 * (INT32) Op2));
- }
-}
-
-
-/**
- Execute the EBC MULU instruction
-
- Instruction syntax:
- MULU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (unsigned)Op1 * (unsigned)Op2
-
-**/
-UINT64
-ExecuteMULU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return MultU64x64 (Op1, Op2);
- } else {
- return (UINT64) ((UINT32) Op1 * (UINT32) Op2);
- }
-}
-
-
-/**
- Execute the EBC DIV instruction.
-
- Instruction syntax:
- DIV[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 / Op2
-
-**/
-UINT64
-ExecuteDIV (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- INT64 Remainder;
-
- //
- // Check for divide-by-0
- //
- if (Op2 == 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_DIVIDE_ERROR,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
-
- return 0;
- } else {
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder));
- } else {
- return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2));
- }
- }
-}
-
-
-/**
- Execute the EBC DIVU instruction
-
- Instruction syntax:
- DIVU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (unsigned)Op1 / (unsigned)Op2
-
-**/
-UINT64
-ExecuteDIVU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- UINT64 Remainder;
-
- //
- // Check for divide-by-0
- //
- if (Op2 == 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_DIVIDE_ERROR,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return 0;
- } else {
- //
- // Get the destination register
- //
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return (UINT64) (DivU64x64Remainder (Op1, Op2, &Remainder));
- } else {
- return (UINT64) ((UINT32) Op1 / (UINT32) Op2);
- }
- }
-}
-
-
-/**
- Execute the EBC MOD instruction.
-
- Instruction syntax:
- MOD[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 MODULUS Op2
-
-**/
-UINT64
-ExecuteMOD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- INT64 Remainder;
-
- //
- // Check for divide-by-0
- //
- if (Op2 == 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_DIVIDE_ERROR,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return 0;
- } else {
- DivS64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder);
- return Remainder;
- }
-}
-
-
-/**
- Execute the EBC MODU instruction.
-
- Instruction syntax:
- MODU[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 UNSIGNED_MODULUS Op2
-
-**/
-UINT64
-ExecuteMODU (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- UINT64 Remainder;
-
- //
- // Check for divide-by-0
- //
- if (Op2 == 0) {
- EbcDebugSignalException (
- EXCEPT_EBC_DIVIDE_ERROR,
- EXCEPTION_FLAG_FATAL,
- VmPtr
- );
- return 0;
- } else {
- DivU64x64Remainder (Op1, Op2, &Remainder);
- return Remainder;
- }
-}
-
-
-/**
- Execute the EBC AND instruction.
-
- Instruction syntax:
- AND[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 AND Op2
-
-**/
-UINT64
-ExecuteAND (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return Op1 & Op2;
-}
-
-
-/**
- Execute the EBC OR instruction.
-
- Instruction syntax:
- OR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 OR Op2
-
-**/
-UINT64
-ExecuteOR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return Op1 | Op2;
-}
-
-
-/**
- Execute the EBC XOR instruction.
-
- Instruction syntax:
- XOR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 XOR Op2
-
-**/
-UINT64
-ExecuteXOR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- return Op1 ^ Op2;
-}
-
-
-/**
- Execute the EBC SHL shift left instruction.
-
- Instruction syntax:
- SHL[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 << Op2
-
-**/
-UINT64
-ExecuteSHL (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return LShiftU64 (Op1, (UINTN)Op2);
- } else {
- return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2));
- }
-}
-
-
-/**
- Execute the EBC SHR instruction.
-
- Instruction syntax:
- SHR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 >> Op2 (unsigned operands)
-
-**/
-UINT64
-ExecuteSHR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return RShiftU64 (Op1, (UINTN)Op2);
- } else {
- return (UINT64) ((UINT32) Op1 >> (UINT32) Op2);
- }
-}
-
-
-/**
- Execute the EBC ASHR instruction.
-
- Instruction syntax:
- ASHR[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return Op1 >> Op2 (signed)
-
-**/
-UINT64
-ExecuteASHR (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {
- return ARShiftU64 (Op1, (UINTN)Op2);
- } else {
- return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2));
- }
-}
-
-
-/**
- Execute the EBC EXTNDB instruction to sign-extend a byte value.
-
- Instruction syntax:
- EXTNDB[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT8)Op2
-
-**/
-UINT64
-ExecuteEXTNDB (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- INT8 Data8;
- INT64 Data64;
- //
- // Convert to byte, then return as 64-bit signed value to let compiler
- // sign-extend the value
- //
- Data8 = (INT8) Op2;
- Data64 = (INT64) Data8;
-
- return (UINT64) Data64;
-}
-
-
-/**
- Execute the EBC EXTNDW instruction to sign-extend a 16-bit value.
-
- Instruction syntax:
- EXTNDW[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT16)Op2
-
-**/
-UINT64
-ExecuteEXTNDW (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- INT16 Data16;
- INT64 Data64;
- //
- // Convert to word, then return as 64-bit signed value to let compiler
- // sign-extend the value
- //
- Data16 = (INT16) Op2;
- Data64 = (INT64) Data16;
-
- return (UINT64) Data64;
-}
-//
-// Execute the EBC EXTNDD instruction.
-//
-// Format: EXTNDD {@}Rx, {@}Ry [Index16|Immed16]
-// EXTNDD Dest, Source
-//
-// Operation: Dest <- SignExtended((DWORD)Source))
-//
-
-/**
- Execute the EBC EXTNDD instruction to sign-extend a 32-bit value.
-
- Instruction syntax:
- EXTNDD[32|64] {@}R1, {@}R2 {Index16|Immed16}
-
- @param VmPtr A pointer to a VM context.
- @param Op1 Operand 1 from the instruction
- @param Op2 Operand 2 from the instruction
-
- @return (INT64)(INT32)Op2
-
-**/
-UINT64
-ExecuteEXTNDD (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Op1,
- IN UINT64 Op2
- )
-{
- INT32 Data32;
- INT64 Data64;
- //
- // Convert to 32-bit value, then return as 64-bit signed value to let compiler
- // sign-extend the value
- //
- Data32 = (INT32) Op2;
- Data64 = (INT64) Data32;
-
- return (UINT64) Data64;
-}
-
-
-/**
- Execute all the EBC signed data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteSignedDataManip (
- IN VM_CONTEXT *VmPtr
- )
-{
- //
- // Just call the data manipulation function with a flag indicating this
- // is a signed operation.
- //
- return ExecuteDataManip (VmPtr, TRUE);
-}
-
-
-/**
- Execute all the EBC unsigned data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteUnsignedDataManip (
- IN VM_CONTEXT *VmPtr
- )
-{
- //
- // Just call the data manipulation function with a flag indicating this
- // is not a signed operation.
- //
- return ExecuteDataManip (VmPtr, FALSE);
-}
-
-
-/**
- Execute all the EBC data manipulation instructions.
- Since the EBC data manipulation instructions all have the same basic form,
- they can share the code that does the fetch of operands and the write-back
- of the result. This function performs the fetch of the operands (even if
- both are not needed to be fetched, like NOT instruction), dispatches to the
- appropriate subfunction, then writes back the returned result.
-
- Format:
- INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}
-
- @param VmPtr A pointer to VM context.
- @param IsSignedOp Indicates whether the operand is signed or not.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteDataManip (
- IN VM_CONTEXT *VmPtr,
- IN BOOLEAN IsSignedOp
- )
-{
- UINT8 Opcode;
- INT16 Index16;
- UINT8 Operands;
- UINT8 Size;
- UINT64 Op1;
- UINT64 Op2;
- INTN DataManipDispatchTableIndex;
-
- //
- // Get opcode and operands
- //
- Opcode = GETOPCODE (VmPtr);
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Determine if we have immediate data by the opcode
- //
- if ((Opcode & DATAMANIP_M_IMMDATA) != 0) {
- //
- // Index16 if Ry is indirect, or Immed16 if Ry direct.
- //
- if (OPERAND2_INDIRECT (Operands)) {
- Index16 = VmReadIndex16 (VmPtr, 2);
- } else {
- Index16 = VmReadImmed16 (VmPtr, 2);
- }
-
- Size = 4;
- } else {
- Index16 = 0;
- Size = 2;
- }
- //
- // Now get operand2 (source). It's of format {@}R2 {Index16|Immed16}
- //
- Op2 = (UINT64) VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;
- if (OPERAND2_INDIRECT (Operands)) {
- //
- // Indirect form: @R2 Index16. Fetch as 32- or 64-bit data
- //
- if ((Opcode & DATAMANIP_M_64) != 0) {
- Op2 = VmReadMem64 (VmPtr, (UINTN) Op2);
- } else {
- //
- // Read as signed value where appropriate.
- //
- if (IsSignedOp) {
- Op2 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op2));
- } else {
- Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2);
- }
- }
- } else {
- if ((Opcode & DATAMANIP_M_64) == 0) {
- if (IsSignedOp) {
- Op2 = (UINT64) (INT64) ((INT32) Op2);
- } else {
- Op2 = (UINT64) ((UINT32) Op2);
- }
- }
- }
- //
- // Get operand1 (destination and sometimes also an actual operand)
- // of form {@}R1
- //
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
- if (OPERAND1_INDIRECT (Operands)) {
- if ((Opcode & DATAMANIP_M_64) != 0) {
- Op1 = VmReadMem64 (VmPtr, (UINTN) Op1);
- } else {
- if (IsSignedOp) {
- Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1));
- } else {
- Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1);
- }
- }
- } else {
- if ((Opcode & DATAMANIP_M_64) == 0) {
- if (IsSignedOp) {
- Op1 = (UINT64) (INT64) ((INT32) Op1);
- } else {
- Op1 = (UINT64) ((UINT32) Op1);
- }
- }
- }
- //
- // Dispatch to the computation function
- //
- DataManipDispatchTableIndex = (Opcode & OPCODE_M_OPCODE) - OPCODE_NOT;
- if ((DataManipDispatchTableIndex < 0) ||
- (DataManipDispatchTableIndex >= sizeof (mDataManipDispatchTable) / sizeof (mDataManipDispatchTable[0]))) {
- EbcDebugSignalException (
- EXCEPT_EBC_INVALID_OPCODE,
- EXCEPTION_FLAG_ERROR,
- VmPtr
- );
- //
- // Advance and return
- //
- VmPtr->Ip += Size;
- return EFI_UNSUPPORTED;
- } else {
- Op2 = mDataManipDispatchTable[DataManipDispatchTableIndex](VmPtr, Op1, Op2);
- }
- //
- // Write back the result.
- //
- if (OPERAND1_INDIRECT (Operands)) {
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];
- if ((Opcode & DATAMANIP_M_64) != 0) {
- VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);
- } else {
- VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);
- }
- } else {
- //
- // Storage back to a register. Write back, clearing upper bits (as per
- // the specification) if 32-bit operation.
- //
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;
- if ((Opcode & DATAMANIP_M_64) == 0) {
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF;
- }
- }
- //
- // Advance the instruction pointer
- //
- VmPtr->Ip += Size;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC LOADSP instruction.
-
- Instruction syntax:
- LOADSP SP1, R2
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteLOADSP (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Operands;
-
- //
- // Get the operands
- //
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Do the operation
- //
- switch (OPERAND1_REGNUM (Operands)) {
- //
- // Set flags
- //
- case 0:
- //
- // Spec states that this instruction will not modify reserved bits in
- // the flags register.
- //
- VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);
- break;
-
- default:
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_WARNING,
- VmPtr
- );
- VmPtr->Ip += 2;
- return EFI_UNSUPPORTED;
- }
-
- VmPtr->Ip += 2;
- return EFI_SUCCESS;
-}
-
-
-/**
- Execute the EBC STORESP instruction.
-
- Instruction syntax:
- STORESP Rx, FLAGS|IP
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported.
- @retval EFI_SUCCESS The instruction is executed successfully.
-
-**/
-EFI_STATUS
-ExecuteSTORESP (
- IN VM_CONTEXT *VmPtr
- )
-{
- UINT8 Operands;
-
- //
- // Get the operands
- //
- Operands = GETOPERANDS (VmPtr);
-
- //
- // Do the operation
- //
- switch (OPERAND2_REGNUM (Operands)) {
- //
- // Get flags
- //
- case 0:
- //
- // Retrieve the value in the flags register, then clear reserved bits
- //
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID);
- break;
-
- //
- // Get IP -- address of following instruction
- //
- case 1:
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;
- break;
-
- default:
- EbcDebugSignalException (
- EXCEPT_EBC_INSTRUCTION_ENCODING,
- EXCEPTION_FLAG_WARNING,
- VmPtr
- );
- VmPtr->Ip += 2;
- return EFI_UNSUPPORTED;
- break;
- }
-
- VmPtr->Ip += 2;
- return EFI_SUCCESS;
-}
-
-
-/**
- Decode a 16-bit index to determine the offset. Given an index value:
-
- b15 - sign bit
- b14:12 - number of bits in this index assigned to natural units (=a)
- ba:11 - constant units = ConstUnits
- b0:a - natural units = NaturalUnits
-
- Given this info, the offset can be computed by:
- offset = sign_bit * (ConstUnits + NaturalUnits * sizeof(UINTN))
-
- Max offset is achieved with index = 0x7FFF giving an offset of
- 0x27B (32-bit machine) or 0x477 (64-bit machine).
- Min offset is achieved with index =
-
- @param VmPtr A pointer to VM context.
- @param CodeOffset Offset from IP of the location of the 16-bit index
- to decode.
-
- @return The decoded offset.
-
-**/
-INT16
-VmReadIndex16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- )
-{
- UINT16 Index;
- INT16 Offset;
- INT16 ConstUnits;
- INT16 NaturalUnits;
- INT16 NBits;
- INT16 Mask;
-
- //
- // First read the index from the code stream
- //
- Index = VmReadCode16 (VmPtr, CodeOffset);
-
- //
- // Get the mask for NaturalUnits. First get the number of bits from the index.
- //
- NBits = (INT16) ((Index & 0x7000) >> 12);
-
- //
- // Scale it for 16-bit indexes
- //
- NBits *= 2;
-
- //
- // Now using the number of bits, create a mask.
- //
- Mask = (INT16) ((INT16)~0 << NBits);
-
- //
- // Now using the mask, extract NaturalUnits from the lower bits of the index.
- //
- NaturalUnits = (INT16) (Index &~Mask);
-
- //
- // Now compute ConstUnits
- //
- ConstUnits = (INT16) (((Index &~0xF000) & Mask) >> NBits);
-
- Offset = (INT16) (NaturalUnits * sizeof (UINTN) + ConstUnits);
-
- //
- // Now set the sign
- //
- if ((Index & 0x8000) != 0) {
- //
- // Do it the hard way to work around a bogus compiler warning
- //
- // Offset = -1 * Offset;
- //
- Offset = (INT16) ((INT32) Offset * -1);
- }
-
- return Offset;
-}
-
-
-/**
- Decode a 32-bit index to determine the offset.
-
- @param VmPtr A pointer to VM context.
- @param CodeOffset Offset from IP of the location of the 32-bit index
- to decode.
-
- @return Converted index per EBC VM specification.
-
-**/
-INT32
-VmReadIndex32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- )
-{
- UINT32 Index;
- INT32 Offset;
- INT32 ConstUnits;
- INT32 NaturalUnits;
- INT32 NBits;
- INT32 Mask;
-
- Index = VmReadImmed32 (VmPtr, CodeOffset);
-
- //
- // Get the mask for NaturalUnits. First get the number of bits from the index.
- //
- NBits = (Index & 0x70000000) >> 28;
-
- //
- // Scale it for 32-bit indexes
- //
- NBits *= 4;
-
- //
- // Now using the number of bits, create a mask.
- //
- Mask = (INT32)~0 << NBits;
-
- //
- // Now using the mask, extract NaturalUnits from the lower bits of the index.
- //
- NaturalUnits = Index &~Mask;
-
- //
- // Now compute ConstUnits
- //
- ConstUnits = ((Index &~0xF0000000) & Mask) >> NBits;
-
- Offset = NaturalUnits * sizeof (UINTN) + ConstUnits;
-
- //
- // Now set the sign
- //
- if ((Index & 0x80000000) != 0) {
- Offset = Offset * -1;
- }
-
- return Offset;
-}
-
-
-/**
- Decode a 64-bit index to determine the offset.
-
- @param VmPtr A pointer to VM context.s
- @param CodeOffset Offset from IP of the location of the 64-bit index
- to decode.
-
- @return Converted index per EBC VM specification
-
-**/
-INT64
-VmReadIndex64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 CodeOffset
- )
-{
- UINT64 Index;
- INT64 Offset;
- INT64 ConstUnits;
- INT64 NaturalUnits;
- INT64 NBits;
- INT64 Mask;
-
- Index = VmReadCode64 (VmPtr, CodeOffset);
-
- //
- // Get the mask for NaturalUnits. First get the number of bits from the index.
- //
- NBits = RShiftU64 ((Index & 0x7000000000000000ULL), 60);
-
- //
- // Scale it for 64-bit indexes (multiply by 8 by shifting left 3)
- //
- NBits = LShiftU64 ((UINT64)NBits, 3);
-
- //
- // Now using the number of bits, create a mask.
- //
- Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits));
-
- //
- // Now using the mask, extract NaturalUnits from the lower bits of the index.
- //
- NaturalUnits = Index &~Mask;
-
- //
- // Now compute ConstUnits
- //
- ConstUnits = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits);
-
- Offset = MultU64x64 ((UINT64) NaturalUnits, sizeof (UINTN)) + ConstUnits;
-
- //
- // Now set the sign
- //
- if ((Index & 0x8000000000000000ULL) != 0) {
- Offset = MultS64x64 (Offset, -1);
- }
-
- return Offset;
-}
-
-
-/**
- Writes 8-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem8 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT8 Data
- )
-{
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
- *(UINT8 *) Addr = Data;
- return EFI_SUCCESS;
-}
-
-/**
- Writes 16-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem16 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT16 Data
- )
-{
- EFI_STATUS Status;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
-
- //
- // Do a simple write if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT16))) {
- *(UINT16 *) Addr = Data;
- } else {
- //
- // Write as two bytes
- //
- MemoryFence ();
- if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8) Data)) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8) (Data >> 8))) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Writes 32-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem32 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT32 Data
- )
-{
- EFI_STATUS Status;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
-
- //
- // Do a simple write if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT32))) {
- *(UINT32 *) Addr = Data;
- } else {
- //
- // Write as two words
- //
- MemoryFence ();
- if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16) Data)) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16) (Data >> 16))) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Writes 64-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem64 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT64 Data
- )
-{
- EFI_STATUS Status;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
-
- //
- // Do a simple write if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT64))) {
- *(UINT64 *) Addr = Data;
- } else {
- //
- // Write as two 32-bit words
- //
- MemoryFence ();
- if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32) Data)) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32) RShiftU64(Data, 32))) != EFI_SUCCESS) {
- return Status;
- }
-
- MemoryFence ();
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- Writes UINTN data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMemN (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINTN Data
- )
-{
- EFI_STATUS Status;
- UINTN Index;
-
- Status = EFI_SUCCESS;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
-
- //
- // Do a simple write if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINTN))) {
- *(UINTN *) Addr = Data;
- } else {
- for (Index = 0; Index < sizeof (UINTN) / sizeof (UINT32); Index++) {
- MemoryFence ();
- Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32) Data);
- MemoryFence ();
- Data = (UINTN) RShiftU64 ((UINT64)Data, 32);
- }
- }
-
- return Status;
-}
-
-
-/**
- Reads 8-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT8
-VmReadImmed8 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- //
- // Simply return the data in flat memory space
- //
- return * (INT8 *) (VmPtr->Ip + Offset);
-}
-
-/**
- Reads 16-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT16
-VmReadImmed16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (INT16))) {
- return * (INT16 *) (VmPtr->Ip + Offset);
- } else {
- //
- // All code word reads should be aligned
- //
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_WARNING,
- VmPtr
- );
- }
- //
- // Return unaligned data
- //
- return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));
-}
-
-
-/**
- Reads 32-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT32
-VmReadImmed32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- UINT32 Data;
-
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {
- return * (INT32 *) (VmPtr->Ip + Offset);
- }
- //
- // Return unaligned data
- //
- Data = (UINT32) VmReadCode16 (VmPtr, Offset);
- Data |= (UINT32)(VmReadCode16 (VmPtr, Offset + 2) << 16);
- return Data;
-}
-
-
-/**
- Reads 64-bit immediate value at the offset.
-
- This routine is called by the EBC execute
- functions to read EBC immediate values from the code stream.
- Since we can't assume alignment, each tries to read in the biggest
- chunks size available, but will revert to smaller reads if necessary.
-
- @param VmPtr A pointer to a VM context.
- @param Offset offset from IP of the code bytes to read.
-
- @return Signed data of the requested size from the specified address.
-
-**/
-INT64
-VmReadImmed64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- UINT64 Data64;
- UINT32 Data32;
- UINT8 *Ptr;
-
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {
- return * (UINT64 *) (VmPtr->Ip + Offset);
- }
- //
- // Return unaligned data.
- //
- Ptr = (UINT8 *) &Data64;
- Data32 = VmReadCode32 (VmPtr, Offset);
- *(UINT32 *) Ptr = Data32;
- Ptr += sizeof (Data32);
- Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
- *(UINT32 *) Ptr = Data32;
- return Data64;
-}
-
-
-/**
- Reads 16-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 16-bit value from the code stream.
-
-**/
-UINT16
-VmReadCode16 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT16))) {
- return * (UINT16 *) (VmPtr->Ip + Offset);
- } else {
- //
- // All code word reads should be aligned
- //
- EbcDebugSignalException (
- EXCEPT_EBC_ALIGNMENT_CHECK,
- EXCEPTION_FLAG_WARNING,
- VmPtr
- );
- }
- //
- // Return unaligned data
- //
- return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));
-}
-
-
-/**
- Reads 32-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 32-bit value from the code stream.
-
-**/
-UINT32
-VmReadCode32 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- UINT32 Data;
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {
- return * (UINT32 *) (VmPtr->Ip + Offset);
- }
- //
- // Return unaligned data
- //
- Data = (UINT32) VmReadCode16 (VmPtr, Offset);
- Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16);
- return Data;
-}
-
-
-/**
- Reads 64-bit unsigned data from the code stream.
-
- This routine provides the ability to read raw unsigned data from the code
- stream.
-
- @param VmPtr A pointer to VM context
- @param Offset Offset from current IP to the raw data to read.
-
- @return The raw unsigned 64-bit value from the code stream.
-
-**/
-UINT64
-VmReadCode64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT32 Offset
- )
-{
- UINT64 Data64;
- UINT32 Data32;
- UINT8 *Ptr;
-
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {
- return * (UINT64 *) (VmPtr->Ip + Offset);
- }
- //
- // Return unaligned data.
- //
- Ptr = (UINT8 *) &Data64;
- Data32 = VmReadCode32 (VmPtr, Offset);
- *(UINT32 *) Ptr = Data32;
- Ptr += sizeof (Data32);
- Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));
- *(UINT32 *) Ptr = Data32;
- return Data64;
-}
-
-
-/**
- Reads 8-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 8-bit value from the memory address.
-
-**/
-UINT8
-VmReadMem8 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
- //
- // Simply return the data in flat memory space
- //
- return * (UINT8 *) Addr;
-}
-
-/**
- Reads 16-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 16-bit value from the memory address.
-
-**/
-UINT16
-VmReadMem16 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT16))) {
- return * (UINT16 *) Addr;
- }
- //
- // Return unaligned data
- //
- return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8));
-}
-
-/**
- Reads 32-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 32-bit value from the memory address.
-
-**/
-UINT32
-VmReadMem32 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- UINT32 Data;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT32))) {
- return * (UINT32 *) Addr;
- }
- //
- // Return unaligned data
- //
- Data = (UINT32) VmReadMem16 (VmPtr, Addr);
- Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16);
- return Data;
-}
-
-/**
- Reads 64-bit data form the memory address.
-
- @param VmPtr A pointer to VM context.
- @param Addr The memory address.
-
- @return The 64-bit value from the memory address.
-
-**/
-UINT64
-VmReadMem64 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- UINT64 Data;
- UINT32 Data32;
-
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
-
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINT64))) {
- return * (UINT64 *) Addr;
- }
- //
- // Return unaligned data. Assume little endian.
- //
- Data32 = VmReadMem32 (VmPtr, Addr);
- Data = (UINT64) VmReadMem32 (VmPtr, Addr + sizeof (UINT32));
- Data = LShiftU64 (Data, 32) | Data32;
- return Data;
-}
-
-
-/**
- Given an address that EBC is going to read from or write to, return
- an appropriate address that accounts for a gap in the stack.
- The stack for this application looks like this (high addr on top)
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
- The EBC assumes that its arguments are at the top of its stack, which
- is where the VM stack is really. Therefore if the EBC does memory
- accesses into the VM stack area, then we need to convert the address
- to point to the EBC entry point arguments area. Do this here.
-
- @param VmPtr A Pointer to VM context.
- @param Addr Address of interest
-
- @return The unchanged address if it's not in the VM stack region. Otherwise,
- adjust for the stack gap and return the modified address.
-
-**/
-UINTN
-ConvertStackAddr (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));
- return Addr;
-}
-
-
-/**
- Read a natural value from memory. May or may not be aligned.
-
- @param VmPtr current VM context
- @param Addr the address to read from
-
- @return The natural value at address Addr.
-
-**/
-UINTN
-VmReadMemN (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr
- )
-{
- UINTN Data;
- volatile UINT32 Size;
- UINT8 *FromPtr;
- UINT8 *ToPtr;
- //
- // Convert the address if it's in the stack gap
- //
- Addr = ConvertStackAddr (VmPtr, Addr);
- //
- // Read direct if aligned
- //
- if (IS_ALIGNED (Addr, sizeof (UINTN))) {
- return * (UINTN *) Addr;
- }
- //
- // Return unaligned data
- //
- Data = 0;
- FromPtr = (UINT8 *) Addr;
- ToPtr = (UINT8 *) &Data;
-
- for (Size = 0; Size < sizeof (Data); Size++) {
- *ToPtr = *FromPtr;
- ToPtr++;
- FromPtr++;
- }
-
- return Data;
-}
-
-/**
- Returns the version of the EBC virtual machine.
-
- @return The 64-bit version of EBC virtual machine.
-
-**/
-UINT64
-GetVmVersion (
- VOID
- )
-{
- return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));
-}
diff --git a/MdeModulePkg/Universal/EbcDxe/EbcExecute.h b/MdeModulePkg/Universal/EbcDxe/EbcExecute.h deleted file mode 100644 index bdc70b1d43..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcExecute.h +++ /dev/null @@ -1,339 +0,0 @@ -/** @file
- Header file for Virtual Machine support. Contains EBC defines that can
- be of use to a disassembler for the most part. Also provides function
- prototypes for VM functions.
-
-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#ifndef _EBC_EXECUTE_H_
-#define _EBC_EXECUTE_H_
-
-//
-// VM major/minor version
-//
-#define VM_MAJOR_VERSION 1
-#define VM_MINOR_VERSION 0
-
-//
-// Macros to check and set alignment
-//
-#define ASSERT_ALIGNED(addr, size) ASSERT (!((UINT32) (addr) & (size - 1)))
-#define IS_ALIGNED(addr, size) !((UINT32) (addr) & (size - 1))
-
-//
-// Define a macro to get the operand. Then we can change it to be either a
-// direct read or have it call a function to read memory.
-//
-#define GETOPERANDS(pVM) (UINT8) (*(UINT8 *) (pVM->Ip + 1))
-#define GETOPCODE(pVM) (UINT8) (*(UINT8 *) pVM->Ip)
-
-//
-// Bit masks for opcode encodings
-//
-#define OPCODE_M_OPCODE 0x3F // bits of interest for first level decode
-#define OPCODE_M_IMMDATA 0x80
-#define OPCODE_M_IMMDATA64 0x40
-#define OPCODE_M_64BIT 0x40 // for CMP
-#define OPCODE_M_RELADDR 0x10 // for CALL instruction
-#define OPCODE_M_CMPI32_DATA 0x80 // for CMPI
-#define OPCODE_M_CMPI64 0x40 // for CMPI 32 or 64 bit comparison
-#define OPERAND_M_MOVIN_N 0x80
-#define OPERAND_M_CMPI_INDEX 0x10
-
-//
-// Masks for instructions that encode presence of indexes for operand1 and/or
-// operand2.
-//
-#define OPCODE_M_IMMED_OP1 0x80
-#define OPCODE_M_IMMED_OP2 0x40
-
-//
-// Bit masks for operand encodings
-//
-#define OPERAND_M_INDIRECT1 0x08
-#define OPERAND_M_INDIRECT2 0x80
-#define OPERAND_M_OP1 0x07
-#define OPERAND_M_OP2 0x70
-
-//
-// Masks for data manipulation instructions
-//
-#define DATAMANIP_M_64 0x40 // 64-bit width operation
-#define DATAMANIP_M_IMMDATA 0x80
-
-//
-// For MOV instructions, need a mask for the opcode when immediate
-// data applies to R2.
-//
-#define OPCODE_M_IMMED_OP2 0x40
-
-//
-// The MOVI/MOVIn instructions use bit 6 of operands byte to indicate
-// if an index is present. Then bits 4 and 5 are used to indicate the width
-// of the move.
-//
-#define MOVI_M_IMMDATA 0x40
-#define MOVI_M_DATAWIDTH 0xC0
-#define MOVI_DATAWIDTH16 0x40
-#define MOVI_DATAWIDTH32 0x80
-#define MOVI_DATAWIDTH64 0xC0
-#define MOVI_M_MOVEWIDTH 0x30
-#define MOVI_MOVEWIDTH8 0x00
-#define MOVI_MOVEWIDTH16 0x10
-#define MOVI_MOVEWIDTH32 0x20
-#define MOVI_MOVEWIDTH64 0x30
-
-//
-// Masks for CALL instruction encodings
-//
-#define OPERAND_M_RELATIVE_ADDR 0x10
-#define OPERAND_M_NATIVE_CALL 0x20
-
-//
-// Masks for decoding push/pop instructions
-//
-#define PUSHPOP_M_IMMDATA 0x80 // opcode bit indicating immediate data
-#define PUSHPOP_M_64 0x40 // opcode bit indicating 64-bit operation
-//
-// Mask for operand of JMP instruction
-//
-#define JMP_M_RELATIVE 0x10
-#define JMP_M_CONDITIONAL 0x80
-#define JMP_M_CS 0x40
-
-//
-// Macros to determine if a given operand is indirect
-//
-#define OPERAND1_INDIRECT(op) ((op) & OPERAND_M_INDIRECT1)
-#define OPERAND2_INDIRECT(op) ((op) & OPERAND_M_INDIRECT2)
-
-//
-// Macros to extract the operands from second byte of instructions
-//
-#define OPERAND1_REGNUM(op) ((op) & OPERAND_M_OP1)
-#define OPERAND2_REGNUM(op) (((op) & OPERAND_M_OP2) >> 4)
-
-#define OPERAND1_CHAR(op) ('0' + OPERAND1_REGNUM (op))
-#define OPERAND2_CHAR(op) ('0' + OPERAND2_REGNUM (op))
-
-#define OPERAND1_REGDATA(pvm, op) pvm->Gpr[OPERAND1_REGNUM (op)]
-#define OPERAND2_REGDATA(pvm, op) pvm->Gpr[OPERAND2_REGNUM (op)]
-
-//
-// Condition masks usually for byte 1 encodings of code
-//
-#define CONDITION_M_CONDITIONAL 0x80
-#define CONDITION_M_CS 0x40
-
-//
-// Bits in the VM->StopFlags field
-//
-#define STOPFLAG_APP_DONE 0x0001
-#define STOPFLAG_BREAKPOINT 0x0002
-#define STOPFLAG_INVALID_BREAK 0x0004
-#define STOPFLAG_BREAK_ON_CALLEX 0x0008
-
-//
-// Masks for working with the VM flags register
-//
-#define VMFLAGS_CC 0x0001 // condition flag
-#define VMFLAGS_STEP 0x0002 // step instruction mode
-#define VMFLAGS_ALL_VALID (VMFLAGS_CC | VMFLAGS_STEP)
-
-//
-// Macros for operating on the VM flags register
-//
-#define VMFLAG_SET(pVM, Flag) (pVM->Flags |= (Flag))
-#define VMFLAG_ISSET(pVM, Flag) ((pVM->Flags & (Flag)) ? 1 : 0)
-#define VMFLAG_CLEAR(pVM, Flag) (pVM->Flags &= ~(Flag))
-
-//
-// Debug macro
-//
-#define EBCMSG(s) gST->ConOut->OutputString (gST->ConOut, s)
-
-//
-// Define OPCODES
-//
-#define OPCODE_BREAK 0x00
-#define OPCODE_JMP 0x01
-#define OPCODE_JMP8 0x02
-#define OPCODE_CALL 0x03
-#define OPCODE_RET 0x04
-#define OPCODE_CMPEQ 0x05
-#define OPCODE_CMPLTE 0x06
-#define OPCODE_CMPGTE 0x07
-#define OPCODE_CMPULTE 0x08
-#define OPCODE_CMPUGTE 0x09
-#define OPCODE_NOT 0x0A
-#define OPCODE_NEG 0x0B
-#define OPCODE_ADD 0x0C
-#define OPCODE_SUB 0x0D
-#define OPCODE_MUL 0x0E
-#define OPCODE_MULU 0x0F
-#define OPCODE_DIV 0x10
-#define OPCODE_DIVU 0x11
-#define OPCODE_MOD 0x12
-#define OPCODE_MODU 0x13
-#define OPCODE_AND 0x14
-#define OPCODE_OR 0x15
-#define OPCODE_XOR 0x16
-#define OPCODE_SHL 0x17
-#define OPCODE_SHR 0x18
-#define OPCODE_ASHR 0x19
-#define OPCODE_EXTNDB 0x1A
-#define OPCODE_EXTNDW 0x1B
-#define OPCODE_EXTNDD 0x1C
-#define OPCODE_MOVBW 0x1D
-#define OPCODE_MOVWW 0x1E
-#define OPCODE_MOVDW 0x1F
-#define OPCODE_MOVQW 0x20
-#define OPCODE_MOVBD 0x21
-#define OPCODE_MOVWD 0x22
-#define OPCODE_MOVDD 0x23
-#define OPCODE_MOVQD 0x24
-#define OPCODE_MOVSNW 0x25 // Move signed natural with word index
-#define OPCODE_MOVSND 0x26 // Move signed natural with dword index
-//
-// #define OPCODE_27 0x27
-//
-#define OPCODE_MOVQQ 0x28 // Does this go away?
-#define OPCODE_LOADSP 0x29
-#define OPCODE_STORESP 0x2A
-#define OPCODE_PUSH 0x2B
-#define OPCODE_POP 0x2C
-#define OPCODE_CMPIEQ 0x2D
-#define OPCODE_CMPILTE 0x2E
-#define OPCODE_CMPIGTE 0x2F
-#define OPCODE_CMPIULTE 0x30
-#define OPCODE_CMPIUGTE 0x31
-#define OPCODE_MOVNW 0x32
-#define OPCODE_MOVND 0x33
-//
-// #define OPCODE_34 0x34
-//
-#define OPCODE_PUSHN 0x35
-#define OPCODE_POPN 0x36
-#define OPCODE_MOVI 0x37
-#define OPCODE_MOVIN 0x38
-#define OPCODE_MOVREL 0x39
-
-/**
- Execute an EBC image from an entry point or from a published protocol.
-
- @param VmPtr A pointer to a VM context.
-
- @retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
- @retval EFI_SUCCESS All of the instructions are executed successfully.
-
-**/
-EFI_STATUS
-EbcExecute (
- IN VM_CONTEXT *VmPtr
- );
-
-
-
-/**
- Returns the version of the EBC virtual machine.
-
- @return The 64-bit version of EBC virtual machine.
-
-**/
-UINT64
-GetVmVersion (
- VOID
- );
-
-/**
- Writes UINTN data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMemN (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINTN Data
- );
-
-/**
- Writes 64-bit data to memory address.
-
- This routine is called by the EBC data
- movement instructions that write to memory. Since these writes
- may be to the stack, which looks like (high address on top) this,
-
- [EBC entry point arguments]
- [VM stack]
- [EBC stack]
-
- we need to detect all attempts to write to the EBC entry point argument
- stack area and adjust the address (which will initially point into the
- VM stack) to point into the EBC entry point arguments.
-
- @param VmPtr A pointer to a VM context.
- @param Addr Address to write to.
- @param Data Value to write to Addr.
-
- @retval EFI_SUCCESS The instruction is executed successfully.
- @retval Other Some error occurs when writing data to the address.
-
-**/
-EFI_STATUS
-VmWriteMem64 (
- IN VM_CONTEXT *VmPtr,
- IN UINTN Addr,
- IN UINT64 Data
- );
-
-/**
- Given a pointer to a new VM context, execute one or more instructions. This
- function is only used for test purposes via the EBC VM test protocol.
-
- @param This A pointer to the EFI_EBC_VM_TEST_PROTOCOL structure.
- @param VmPtr A pointer to a VM context.
- @param InstructionCount A pointer to a UINTN value holding the number of
- instructions to execute. If it holds value of 0,
- then the instruction to be executed is 1.
-
- @retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
- @retval EFI_SUCCESS All of the instructions are executed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcExecuteInstructions (
- IN EFI_EBC_VM_TEST_PROTOCOL *This,
- IN VM_CONTEXT *VmPtr,
- IN OUT UINTN *InstructionCount
- );
-
-#endif // ifndef _EBC_EXECUTE_H_
diff --git a/MdeModulePkg/Universal/EbcDxe/EbcInt.c b/MdeModulePkg/Universal/EbcDxe/EbcInt.c deleted file mode 100644 index 549e0dd8dc..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcInt.c +++ /dev/null @@ -1,1406 +0,0 @@ -/** @file
- Top level module for the EBC virtual machine implementation.
- Provides auxiliary support routines for the VM. That is, routines
- that are not particularly related to VM execution of EBC instructions.
-
-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#include "EbcInt.h"
-#include "EbcExecute.h"
-
-//
-// We'll keep track of all thunks we create in a linked list. Each
-// thunk is tied to an image handle, so we have a linked list of
-// image handles, with each having a linked list of thunks allocated
-// to that image handle.
-//
-typedef struct _EBC_THUNK_LIST EBC_THUNK_LIST;
-struct _EBC_THUNK_LIST {
- VOID *ThunkBuffer;
- EBC_THUNK_LIST *Next;
-};
-
-typedef struct _EBC_IMAGE_LIST EBC_IMAGE_LIST;
-struct _EBC_IMAGE_LIST {
- EBC_IMAGE_LIST *Next;
- EFI_HANDLE ImageHandle;
- EBC_THUNK_LIST *ThunkList;
-};
-
-/**
- This routine is called by the core when an image is being unloaded from
- memory. Basically we now have the opportunity to do any necessary cleanup.
- Typically this will include freeing any memory allocated for thunk-creation.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param ImageHandle Handle of image for which the thunk is being
- created.
-
- @retval EFI_INVALID_PARAMETER The ImageHandle passed in was not found in the
- internal list of EBC image handles.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcUnloadImage (
- IN EFI_EBC_PROTOCOL *This,
- IN EFI_HANDLE ImageHandle
- );
-
-/**
- This is the top-level routine plugged into the EBC protocol. Since thunks
- are very processor-specific, from here we dispatch directly to the very
- processor-specific routine EbcCreateThunks().
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param ImageHandle Handle of image for which the thunk is being
- created. The EBC interpreter may use this to
- keep track of any resource allocations
- performed in loading and executing the image.
- @param EbcEntryPoint Address of the actual EBC entry point or
- protocol service the thunk should call.
- @param Thunk Returned pointer to a thunk created.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_INVALID_PARAMETER Image entry point is not 2-byte aligned.
- @retval EFI_OUT_OF_RESOURCES Memory could not be allocated for the thunk.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcCreateThunk (
- IN EFI_EBC_PROTOCOL *This,
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk
- );
-
-/**
- Called to get the version of the interpreter.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param Version Pointer to where to store the returned version
- of the interpreter.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_INVALID_PARAMETER Version pointer is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcGetVersion (
- IN EFI_EBC_PROTOCOL *This,
- IN OUT UINT64 *Version
- );
-
-/**
- To install default Callback function for the VM interpreter.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval Others Some error occurs when creating periodic event.
-
-**/
-EFI_STATUS
-EFIAPI
-InitializeEbcCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This
- );
-
-/**
- The default Exception Callback for the VM interpreter.
- In this function, we report status code, and print debug information
- about EBC_CONTEXT, then dead loop.
-
- @param InterruptType Interrupt type.
- @param SystemContext EBC system context.
-
-**/
-VOID
-EFIAPI
-CommonEbcExceptionHandler (
- IN EFI_EXCEPTION_TYPE InterruptType,
- IN EFI_SYSTEM_CONTEXT SystemContext
- );
-
-/**
- The periodic callback function for EBC VM interpreter, which is used
- to support the EFI debug support protocol.
-
- @param Event The Periodic Callback Event.
- @param Context It should be the address of VM_CONTEXT pointer.
-
-**/
-VOID
-EFIAPI
-EbcPeriodicNotifyFunction (
- IN EFI_EVENT Event,
- IN VOID *Context
- );
-
-/**
- The VM interpreter calls this function on a periodic basis to support
- the EFI debug support protocol.
-
- @param VmPtr Pointer to a VM context for passing info to the
- debugger.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugPeriodic (
- IN VM_CONTEXT *VmPtr
- );
-
-//
-// These two functions and the GUID are used to produce an EBC test protocol.
-// This functionality is definitely not required for execution.
-//
-/**
- Produces an EBC VM test protocol that can be used for regression tests.
-
- @param IHandle Handle on which to install the protocol.
-
- @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-InitEbcVmTestProtocol (
- IN EFI_HANDLE *IHandle
- );
-
-/**
- Returns the EFI_UNSUPPORTED Status.
-
- @return EFI_UNSUPPORTED This function always return EFI_UNSUPPORTED status.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcVmTestUnsupported (
- VOID
- );
-
-/**
- Registers a callback function that the EBC interpreter calls to flush the
- processor instruction cache following creation of thunks.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param Flush Pointer to a function of type EBC_ICACH_FLUSH.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcRegisterICacheFlush (
- IN EFI_EBC_PROTOCOL *This,
- IN EBC_ICACHE_FLUSH Flush
- );
-
-/**
- This EBC debugger protocol service is called by the debug agent
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param MaxProcessorIndex Pointer to a caller-allocated UINTN in which the
- maximum supported processor index is returned.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugGetMaximumProcessorIndex (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- OUT UINTN *MaxProcessorIndex
- );
-
-/**
- This protocol service is called by the debug agent to register a function
- for us to call on a periodic basis.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param PeriodicCallback A pointer to a function of type
- PERIODIC_CALLBACK that is the main periodic
- entry point of the debug agent. It receives as a
- parameter a pointer to the full context of the
- interrupted execution thread.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_ALREADY_STARTED Non-NULL PeriodicCallback parameter when a
- callback function was previously registered.
- @retval EFI_INVALID_PARAMETER Null PeriodicCallback parameter when no
- callback function was previously registered.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugRegisterPeriodicCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN EFI_PERIODIC_CALLBACK PeriodicCallback
- );
-
-/**
- This protocol service is called by the debug agent to register a function
- for us to call when we detect an exception.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param ExceptionCallback A pointer to a function of type
- EXCEPTION_CALLBACK that is called when the
- processor exception specified by ExceptionType
- occurs. Passing NULL unregisters any previously
- registered function associated with
- ExceptionType.
- @param ExceptionType Specifies which processor exception to hook.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_ALREADY_STARTED Non-NULL ExceptionCallback parameter when a
- callback function was previously registered.
- @retval EFI_INVALID_PARAMETER ExceptionType parameter is negative or exceeds
- MAX_EBC_EXCEPTION.
- @retval EFI_INVALID_PARAMETER Null ExceptionCallback parameter when no
- callback function was previously registered.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugRegisterExceptionCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN EFI_EXCEPTION_CALLBACK ExceptionCallback,
- IN EFI_EXCEPTION_TYPE ExceptionType
- );
-
-/**
- This EBC debugger protocol service is called by the debug agent. Required
- for DebugSupport compliance but is only stubbed out for EBC.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param Start StartSpecifies the physical base of the memory
- range to be invalidated.
- @param Length Specifies the minimum number of bytes in the
- processor's instruction cache to invalidate.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugInvalidateInstructionCache (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN VOID *Start,
- IN UINT64 Length
- );
-
-//
-// We have one linked list of image handles for the whole world. Since
-// there should only be one interpreter, make them global. They must
-// also be global since the execution of an EBC image does not provide
-// a This pointer.
-//
-EBC_IMAGE_LIST *mEbcImageList = NULL;
-
-//
-// Callback function to flush the icache after thunk creation
-//
-EBC_ICACHE_FLUSH mEbcICacheFlush;
-
-//
-// These get set via calls by the debug agent
-//
-EFI_PERIODIC_CALLBACK mDebugPeriodicCallback = NULL;
-EFI_EXCEPTION_CALLBACK mDebugExceptionCallback[MAX_EBC_EXCEPTION + 1] = {NULL};
-
-VOID *mStackBuffer[MAX_STACK_NUM];
-EFI_HANDLE mStackBufferIndex[MAX_STACK_NUM];
-UINTN mStackNum = 0;
-
-//
-// Event for Periodic callback
-//
-EFI_EVENT mEbcPeriodicEvent;
-VM_CONTEXT *mVmPtr = NULL;
-
-
-/**
- Initializes the VM EFI interface. Allocates memory for the VM interface
- and registers the VM protocol.
-
- @param ImageHandle EFI image handle.
- @param SystemTable Pointer to the EFI system table.
-
- @return Standard EFI status code.
-
-**/
-EFI_STATUS
-EFIAPI
-InitializeEbcDriver (
- IN EFI_HANDLE ImageHandle,
- IN EFI_SYSTEM_TABLE *SystemTable
- )
-{
- EFI_EBC_PROTOCOL *EbcProtocol;
- EFI_EBC_PROTOCOL *OldEbcProtocol;
- EFI_STATUS Status;
- EFI_DEBUG_SUPPORT_PROTOCOL *EbcDebugProtocol;
- EFI_HANDLE *HandleBuffer;
- UINTN NumHandles;
- UINTN Index;
- BOOLEAN Installed;
-
- EbcProtocol = NULL;
- EbcDebugProtocol = NULL;
-
- //
- // Allocate memory for our protocol. Then fill in the blanks.
- //
- EbcProtocol = AllocatePool (sizeof (EFI_EBC_PROTOCOL));
-
- if (EbcProtocol == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
-
- EbcProtocol->CreateThunk = EbcCreateThunk;
- EbcProtocol->UnloadImage = EbcUnloadImage;
- EbcProtocol->RegisterICacheFlush = EbcRegisterICacheFlush;
- EbcProtocol->GetVersion = EbcGetVersion;
- mEbcICacheFlush = NULL;
-
- //
- // Find any already-installed EBC protocols and uninstall them
- //
- Installed = FALSE;
- HandleBuffer = NULL;
- Status = gBS->LocateHandleBuffer (
- ByProtocol,
- &gEfiEbcProtocolGuid,
- NULL,
- &NumHandles,
- &HandleBuffer
- );
- if (Status == EFI_SUCCESS) {
- //
- // Loop through the handles
- //
- for (Index = 0; Index < NumHandles; Index++) {
- Status = gBS->HandleProtocol (
- HandleBuffer[Index],
- &gEfiEbcProtocolGuid,
- (VOID **) &OldEbcProtocol
- );
- if (Status == EFI_SUCCESS) {
- if (gBS->ReinstallProtocolInterface (
- HandleBuffer[Index],
- &gEfiEbcProtocolGuid,
- OldEbcProtocol,
- EbcProtocol
- ) == EFI_SUCCESS) {
- Installed = TRUE;
- }
- }
- }
- }
-
- if (HandleBuffer != NULL) {
- FreePool (HandleBuffer);
- HandleBuffer = NULL;
- }
- //
- // Add the protocol so someone can locate us if we haven't already.
- //
- if (!Installed) {
- Status = gBS->InstallProtocolInterface (
- &ImageHandle,
- &gEfiEbcProtocolGuid,
- EFI_NATIVE_INTERFACE,
- EbcProtocol
- );
- if (EFI_ERROR (Status)) {
- FreePool (EbcProtocol);
- return Status;
- }
- }
-
- Status = InitEBCStack();
- if (EFI_ERROR(Status)) {
- goto ErrorExit;
- }
-
- //
- // Allocate memory for our debug protocol. Then fill in the blanks.
- //
- EbcDebugProtocol = AllocatePool (sizeof (EFI_DEBUG_SUPPORT_PROTOCOL));
-
- if (EbcDebugProtocol == NULL) {
- goto ErrorExit;
- }
-
- EbcDebugProtocol->Isa = IsaEbc;
- EbcDebugProtocol->GetMaximumProcessorIndex = EbcDebugGetMaximumProcessorIndex;
- EbcDebugProtocol->RegisterPeriodicCallback = EbcDebugRegisterPeriodicCallback;
- EbcDebugProtocol->RegisterExceptionCallback = EbcDebugRegisterExceptionCallback;
- EbcDebugProtocol->InvalidateInstructionCache = EbcDebugInvalidateInstructionCache;
-
- //
- // Add the protocol so the debug agent can find us
- //
- Status = gBS->InstallProtocolInterface (
- &ImageHandle,
- &gEfiDebugSupportProtocolGuid,
- EFI_NATIVE_INTERFACE,
- EbcDebugProtocol
- );
- //
- // This is recoverable, so free the memory and continue.
- //
- if (EFI_ERROR (Status)) {
- FreePool (EbcDebugProtocol);
- goto ErrorExit;
- }
- //
- // Install EbcDebugSupport Protocol Successfully
- // Now we need to initialize the Ebc default Callback
- //
- Status = InitializeEbcCallback (EbcDebugProtocol);
-
- //
- // Produce a VM test interface protocol. Not required for execution.
- //
- DEBUG_CODE_BEGIN ();
- InitEbcVmTestProtocol (&ImageHandle);
- DEBUG_CODE_END ();
-
- return EFI_SUCCESS;
-
-ErrorExit:
- FreeEBCStack();
- HandleBuffer = NULL;
- Status = gBS->LocateHandleBuffer (
- ByProtocol,
- &gEfiEbcProtocolGuid,
- NULL,
- &NumHandles,
- &HandleBuffer
- );
- if (Status == EFI_SUCCESS) {
- //
- // Loop through the handles
- //
- for (Index = 0; Index < NumHandles; Index++) {
- Status = gBS->HandleProtocol (
- HandleBuffer[Index],
- &gEfiEbcProtocolGuid,
- (VOID **) &OldEbcProtocol
- );
- if (Status == EFI_SUCCESS) {
- gBS->UninstallProtocolInterface (
- HandleBuffer[Index],
- &gEfiEbcProtocolGuid,
- OldEbcProtocol
- );
- }
- }
- }
-
- if (HandleBuffer != NULL) {
- FreePool (HandleBuffer);
- HandleBuffer = NULL;
- }
-
- FreePool (EbcProtocol);
-
- return Status;
-}
-
-
-/**
- This is the top-level routine plugged into the EBC protocol. Since thunks
- are very processor-specific, from here we dispatch directly to the very
- processor-specific routine EbcCreateThunks().
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param ImageHandle Handle of image for which the thunk is being
- created. The EBC interpreter may use this to
- keep track of any resource allocations
- performed in loading and executing the image.
- @param EbcEntryPoint Address of the actual EBC entry point or
- protocol service the thunk should call.
- @param Thunk Returned pointer to a thunk created.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_INVALID_PARAMETER Image entry point is not 2-byte aligned.
- @retval EFI_OUT_OF_RESOURCES Memory could not be allocated for the thunk.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcCreateThunk (
- IN EFI_EBC_PROTOCOL *This,
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk
- )
-{
- EFI_STATUS Status;
-
- Status = EbcCreateThunks (
- ImageHandle,
- EbcEntryPoint,
- Thunk,
- FLAG_THUNK_ENTRY_POINT
- );
- return Status;
-}
-
-
-/**
- This EBC debugger protocol service is called by the debug agent
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param MaxProcessorIndex Pointer to a caller-allocated UINTN in which the
- maximum supported processor index is returned.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugGetMaximumProcessorIndex (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- OUT UINTN *MaxProcessorIndex
- )
-{
- *MaxProcessorIndex = 0;
- return EFI_SUCCESS;
-}
-
-
-/**
- This protocol service is called by the debug agent to register a function
- for us to call on a periodic basis.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param PeriodicCallback A pointer to a function of type
- PERIODIC_CALLBACK that is the main periodic
- entry point of the debug agent. It receives as a
- parameter a pointer to the full context of the
- interrupted execution thread.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_ALREADY_STARTED Non-NULL PeriodicCallback parameter when a
- callback function was previously registered.
- @retval EFI_INVALID_PARAMETER Null PeriodicCallback parameter when no
- callback function was previously registered.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugRegisterPeriodicCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN EFI_PERIODIC_CALLBACK PeriodicCallback
- )
-{
- if ((mDebugPeriodicCallback == NULL) && (PeriodicCallback == NULL)) {
- return EFI_INVALID_PARAMETER;
- }
- if ((mDebugPeriodicCallback != NULL) && (PeriodicCallback != NULL)) {
- return EFI_ALREADY_STARTED;
- }
-
- mDebugPeriodicCallback = PeriodicCallback;
- return EFI_SUCCESS;
-}
-
-
-/**
- This protocol service is called by the debug agent to register a function
- for us to call when we detect an exception.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param ExceptionCallback A pointer to a function of type
- EXCEPTION_CALLBACK that is called when the
- processor exception specified by ExceptionType
- occurs. Passing NULL unregisters any previously
- registered function associated with
- ExceptionType.
- @param ExceptionType Specifies which processor exception to hook.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_ALREADY_STARTED Non-NULL ExceptionCallback parameter when a
- callback function was previously registered.
- @retval EFI_INVALID_PARAMETER ExceptionType parameter is negative or exceeds
- MAX_EBC_EXCEPTION.
- @retval EFI_INVALID_PARAMETER Null ExceptionCallback parameter when no
- callback function was previously registered.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugRegisterExceptionCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN EFI_EXCEPTION_CALLBACK ExceptionCallback,
- IN EFI_EXCEPTION_TYPE ExceptionType
- )
-{
- if ((ExceptionType < 0) || (ExceptionType > MAX_EBC_EXCEPTION)) {
- return EFI_INVALID_PARAMETER;
- }
- if ((mDebugExceptionCallback[ExceptionType] == NULL) && (ExceptionCallback == NULL)) {
- return EFI_INVALID_PARAMETER;
- }
- if ((mDebugExceptionCallback[ExceptionType] != NULL) && (ExceptionCallback != NULL)) {
- return EFI_ALREADY_STARTED;
- }
- mDebugExceptionCallback[ExceptionType] = ExceptionCallback;
- return EFI_SUCCESS;
-}
-
-
-/**
- This EBC debugger protocol service is called by the debug agent. Required
- for DebugSupport compliance but is only stubbed out for EBC.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
- @param ProcessorIndex Specifies which processor the callback function
- applies to.
- @param Start StartSpecifies the physical base of the memory
- range to be invalidated.
- @param Length Specifies the minimum number of bytes in the
- processor's instruction cache to invalidate.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugInvalidateInstructionCache (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This,
- IN UINTN ProcessorIndex,
- IN VOID *Start,
- IN UINT64 Length
- )
-{
- return EFI_SUCCESS;
-}
-
-
-/**
- The VM interpreter calls this function when an exception is detected.
-
- @param ExceptionType Specifies the processor exception detected.
- @param ExceptionFlags Specifies the exception context.
- @param VmPtr Pointer to a VM context for passing info to the
- EFI debugger.
-
- @retval EFI_SUCCESS This function completed successfully.
-
-**/
-EFI_STATUS
-EbcDebugSignalException (
- IN EFI_EXCEPTION_TYPE ExceptionType,
- IN EXCEPTION_FLAGS ExceptionFlags,
- IN VM_CONTEXT *VmPtr
- )
-{
- EFI_SYSTEM_CONTEXT_EBC EbcContext;
- EFI_SYSTEM_CONTEXT SystemContext;
-
- ASSERT ((ExceptionType >= 0) && (ExceptionType <= MAX_EBC_EXCEPTION));
- //
- // Save the exception in the context passed in
- //
- VmPtr->ExceptionFlags |= ExceptionFlags;
- VmPtr->LastException = (UINTN) ExceptionType;
- //
- // If it's a fatal exception, then flag it in the VM context in case an
- // attached debugger tries to return from it.
- //
- if ((ExceptionFlags & EXCEPTION_FLAG_FATAL) != 0) {
- VmPtr->StopFlags |= STOPFLAG_APP_DONE;
- }
-
- //
- // If someone's registered for exception callbacks, then call them.
- //
- // EBC driver will register default exception callback to report the
- // status code via the status code API
- //
- if (mDebugExceptionCallback[ExceptionType] != NULL) {
-
- //
- // Initialize the context structure
- //
- EbcContext.R0 = (UINT64) VmPtr->Gpr[0];
- EbcContext.R1 = (UINT64) VmPtr->Gpr[1];
- EbcContext.R2 = (UINT64) VmPtr->Gpr[2];
- EbcContext.R3 = (UINT64) VmPtr->Gpr[3];
- EbcContext.R4 = (UINT64) VmPtr->Gpr[4];
- EbcContext.R5 = (UINT64) VmPtr->Gpr[5];
- EbcContext.R6 = (UINT64) VmPtr->Gpr[6];
- EbcContext.R7 = (UINT64) VmPtr->Gpr[7];
- EbcContext.Ip = (UINT64)(UINTN)VmPtr->Ip;
- EbcContext.Flags = VmPtr->Flags;
- EbcContext.ControlFlags = 0;
- SystemContext.SystemContextEbc = &EbcContext;
-
- mDebugExceptionCallback[ExceptionType] (ExceptionType, SystemContext);
- //
- // Restore the context structure and continue to execute
- //
- VmPtr->Gpr[0] = EbcContext.R0;
- VmPtr->Gpr[1] = EbcContext.R1;
- VmPtr->Gpr[2] = EbcContext.R2;
- VmPtr->Gpr[3] = EbcContext.R3;
- VmPtr->Gpr[4] = EbcContext.R4;
- VmPtr->Gpr[5] = EbcContext.R5;
- VmPtr->Gpr[6] = EbcContext.R6;
- VmPtr->Gpr[7] = EbcContext.R7;
- VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip;
- VmPtr->Flags = EbcContext.Flags;
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- To install default Callback function for the VM interpreter.
-
- @param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL
- instance.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval Others Some error occurs when creating periodic event.
-
-**/
-EFI_STATUS
-EFIAPI
-InitializeEbcCallback (
- IN EFI_DEBUG_SUPPORT_PROTOCOL *This
- )
-{
- INTN Index;
- EFI_STATUS Status;
-
- //
- // For ExceptionCallback
- //
- for (Index = 0; Index <= MAX_EBC_EXCEPTION; Index++) {
- EbcDebugRegisterExceptionCallback (
- This,
- 0,
- CommonEbcExceptionHandler,
- Index
- );
- }
-
- //
- // For PeriodicCallback
- //
- Status = gBS->CreateEvent (
- EVT_TIMER | EVT_NOTIFY_SIGNAL,
- TPL_NOTIFY,
- EbcPeriodicNotifyFunction,
- &mVmPtr,
- &mEbcPeriodicEvent
- );
- if (EFI_ERROR(Status)) {
- return Status;
- }
-
- Status = gBS->SetTimer (
- mEbcPeriodicEvent,
- TimerPeriodic,
- EBC_VM_PERIODIC_CALLBACK_RATE
- );
- if (EFI_ERROR(Status)) {
- return Status;
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- The default Exception Callback for the VM interpreter.
- In this function, we report status code, and print debug information
- about EBC_CONTEXT, then dead loop.
-
- @param InterruptType Interrupt type.
- @param SystemContext EBC system context.
-
-**/
-VOID
-EFIAPI
-CommonEbcExceptionHandler (
- IN EFI_EXCEPTION_TYPE InterruptType,
- IN EFI_SYSTEM_CONTEXT SystemContext
- )
-{
- //
- // We print debug information to let user know what happen.
- //
- DEBUG ((
- EFI_D_ERROR,
- "EBC Interrupter Version - 0x%016lx\n",
- (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)))
- ));
- DEBUG ((
- EFI_D_ERROR,
- "Exception Type - 0x%016lx\n",
- (UINT64)(UINTN)InterruptType
- ));
- DEBUG ((
- EFI_D_ERROR,
- " R0 - 0x%016lx, R1 - 0x%016lx\n",
- SystemContext.SystemContextEbc->R0,
- SystemContext.SystemContextEbc->R1
- ));
- DEBUG ((
- EFI_D_ERROR,
- " R2 - 0x%016lx, R3 - 0x%016lx\n",
- SystemContext.SystemContextEbc->R2,
- SystemContext.SystemContextEbc->R3
- ));
- DEBUG ((
- EFI_D_ERROR,
- " R4 - 0x%016lx, R5 - 0x%016lx\n",
- SystemContext.SystemContextEbc->R4,
- SystemContext.SystemContextEbc->R5
- ));
- DEBUG ((
- EFI_D_ERROR,
- " R6 - 0x%016lx, R7 - 0x%016lx\n",
- SystemContext.SystemContextEbc->R6,
- SystemContext.SystemContextEbc->R7
- ));
- DEBUG ((
- EFI_D_ERROR,
- " Flags - 0x%016lx\n",
- SystemContext.SystemContextEbc->Flags
- ));
- DEBUG ((
- EFI_D_ERROR,
- " ControlFlags - 0x%016lx\n",
- SystemContext.SystemContextEbc->ControlFlags
- ));
- DEBUG ((
- EFI_D_ERROR,
- " Ip - 0x%016lx\n\n",
- SystemContext.SystemContextEbc->Ip
- ));
-
- //
- // We deadloop here to make it easy to debug this issue.
- //
- CpuDeadLoop ();
-
- return ;
-}
-
-
-/**
- The periodic callback function for EBC VM interpreter, which is used
- to support the EFI debug support protocol.
-
- @param Event The Periodic Callback Event.
- @param Context It should be the address of VM_CONTEXT pointer.
-
-**/
-VOID
-EFIAPI
-EbcPeriodicNotifyFunction (
- IN EFI_EVENT Event,
- IN VOID *Context
- )
-{
- VM_CONTEXT *VmPtr;
-
- VmPtr = *(VM_CONTEXT **)Context;
-
- if (VmPtr != NULL) {
- EbcDebugPeriodic (VmPtr);
- }
-
- return ;
-}
-
-
-/**
- The VM interpreter calls this function on a periodic basis to support
- the EFI debug support protocol.
-
- @param VmPtr Pointer to a VM context for passing info to the
- debugger.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcDebugPeriodic (
- IN VM_CONTEXT *VmPtr
- )
-{
- EFI_SYSTEM_CONTEXT_EBC EbcContext;
- EFI_SYSTEM_CONTEXT SystemContext;
-
- //
- // If someone's registered for periodic callbacks, then call them.
- //
- if (mDebugPeriodicCallback != NULL) {
-
- //
- // Initialize the context structure
- //
- EbcContext.R0 = (UINT64) VmPtr->Gpr[0];
- EbcContext.R1 = (UINT64) VmPtr->Gpr[1];
- EbcContext.R2 = (UINT64) VmPtr->Gpr[2];
- EbcContext.R3 = (UINT64) VmPtr->Gpr[3];
- EbcContext.R4 = (UINT64) VmPtr->Gpr[4];
- EbcContext.R5 = (UINT64) VmPtr->Gpr[5];
- EbcContext.R6 = (UINT64) VmPtr->Gpr[6];
- EbcContext.R7 = (UINT64) VmPtr->Gpr[7];
- EbcContext.Ip = (UINT64)(UINTN)VmPtr->Ip;
- EbcContext.Flags = VmPtr->Flags;
- EbcContext.ControlFlags = 0;
- SystemContext.SystemContextEbc = &EbcContext;
-
- mDebugPeriodicCallback (SystemContext);
-
- //
- // Restore the context structure and continue to execute
- //
- VmPtr->Gpr[0] = EbcContext.R0;
- VmPtr->Gpr[1] = EbcContext.R1;
- VmPtr->Gpr[2] = EbcContext.R2;
- VmPtr->Gpr[3] = EbcContext.R3;
- VmPtr->Gpr[4] = EbcContext.R4;
- VmPtr->Gpr[5] = EbcContext.R5;
- VmPtr->Gpr[6] = EbcContext.R6;
- VmPtr->Gpr[7] = EbcContext.R7;
- VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip;
- VmPtr->Flags = EbcContext.Flags;
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- This routine is called by the core when an image is being unloaded from
- memory. Basically we now have the opportunity to do any necessary cleanup.
- Typically this will include freeing any memory allocated for thunk-creation.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param ImageHandle Handle of image for which the thunk is being
- created.
-
- @retval EFI_INVALID_PARAMETER The ImageHandle passed in was not found in the
- internal list of EBC image handles.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcUnloadImage (
- IN EFI_EBC_PROTOCOL *This,
- IN EFI_HANDLE ImageHandle
- )
-{
- EBC_THUNK_LIST *ThunkList;
- EBC_THUNK_LIST *NextThunkList;
- EBC_IMAGE_LIST *ImageList;
- EBC_IMAGE_LIST *PrevImageList;
- //
- // First go through our list of known image handles and see if we've already
- // created an image list element for this image handle.
- //
- ReturnEBCStackByHandle(ImageHandle);
- PrevImageList = NULL;
- for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {
- if (ImageList->ImageHandle == ImageHandle) {
- break;
- }
- //
- // Save the previous so we can connect the lists when we remove this one
- //
- PrevImageList = ImageList;
- }
-
- if (ImageList == NULL) {
- return EFI_INVALID_PARAMETER;
- }
- //
- // Free up all the thunk buffers and thunks list elements for this image
- // handle.
- //
- ThunkList = ImageList->ThunkList;
- while (ThunkList != NULL) {
- NextThunkList = ThunkList->Next;
- FreePool (ThunkList->ThunkBuffer);
- FreePool (ThunkList);
- ThunkList = NextThunkList;
- }
- //
- // Now remove this image list element from the chain
- //
- if (PrevImageList == NULL) {
- //
- // Remove from head
- //
- mEbcImageList = ImageList->Next;
- } else {
- PrevImageList->Next = ImageList->Next;
- }
- //
- // Now free up the image list element
- //
- FreePool (ImageList);
- return EFI_SUCCESS;
-}
-
-
-/**
- Add a thunk to our list of thunks for a given image handle.
- Also flush the instruction cache since we've written thunk code
- to memory that will be executed eventually.
-
- @param ImageHandle The image handle to which the thunk is tied.
- @param ThunkBuffer The buffer that has been created/allocated.
- @param ThunkSize The size of the thunk memory allocated.
-
- @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EbcAddImageThunk (
- IN EFI_HANDLE ImageHandle,
- IN VOID *ThunkBuffer,
- IN UINT32 ThunkSize
- )
-{
- EBC_THUNK_LIST *ThunkList;
- EBC_IMAGE_LIST *ImageList;
- EFI_STATUS Status;
-
- //
- // It so far so good, then flush the instruction cache
- //
- if (mEbcICacheFlush != NULL) {
- Status = mEbcICacheFlush ((EFI_PHYSICAL_ADDRESS) (UINTN) ThunkBuffer, ThunkSize);
- if (EFI_ERROR (Status)) {
- return Status;
- }
- }
- //
- // Go through our list of known image handles and see if we've already
- // created a image list element for this image handle.
- //
- for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {
- if (ImageList->ImageHandle == ImageHandle) {
- break;
- }
- }
-
- if (ImageList == NULL) {
- //
- // Allocate a new one
- //
- ImageList = AllocatePool (sizeof (EBC_IMAGE_LIST));
-
- if (ImageList == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
-
- ImageList->ThunkList = NULL;
- ImageList->ImageHandle = ImageHandle;
- ImageList->Next = mEbcImageList;
- mEbcImageList = ImageList;
- }
- //
- // Ok, now create a new thunk element to add to the list
- //
- ThunkList = AllocatePool (sizeof (EBC_THUNK_LIST));
-
- if (ThunkList == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
- //
- // Add it to the head of the list
- //
- ThunkList->Next = ImageList->ThunkList;
- ThunkList->ThunkBuffer = ThunkBuffer;
- ImageList->ThunkList = ThunkList;
- return EFI_SUCCESS;
-}
-
-/**
- Registers a callback function that the EBC interpreter calls to flush the
- processor instruction cache following creation of thunks.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param Flush Pointer to a function of type EBC_ICACH_FLUSH.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcRegisterICacheFlush (
- IN EFI_EBC_PROTOCOL *This,
- IN EBC_ICACHE_FLUSH Flush
- )
-{
- mEbcICacheFlush = Flush;
- return EFI_SUCCESS;
-}
-
-/**
- Called to get the version of the interpreter.
-
- @param This A pointer to the EFI_EBC_PROTOCOL instance.
- @param Version Pointer to where to store the returned version
- of the interpreter.
-
- @retval EFI_SUCCESS The function completed successfully.
- @retval EFI_INVALID_PARAMETER Version pointer is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcGetVersion (
- IN EFI_EBC_PROTOCOL *This,
- IN OUT UINT64 *Version
- )
-{
- if (Version == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
- *Version = GetVmVersion ();
- return EFI_SUCCESS;
-}
-
-/**
- Returns the stack index and buffer assosicated with the Handle parameter.
-
- @param Handle The EFI handle as the index to the EBC stack.
- @param StackBuffer A pointer to hold the returned stack buffer.
- @param BufferIndex A pointer to hold the returned stack index.
-
- @retval EFI_OUT_OF_RESOURCES The Handle parameter does not correspond to any
- existing EBC stack.
- @retval EFI_SUCCESS The stack index and buffer were found and
- returned to the caller.
-
-**/
-EFI_STATUS
-GetEBCStack(
- IN EFI_HANDLE Handle,
- OUT VOID **StackBuffer,
- OUT UINTN *BufferIndex
- )
-{
- UINTN Index;
- EFI_TPL OldTpl;
- OldTpl = gBS->RaiseTPL(TPL_HIGH_LEVEL);
- for (Index = 0; Index < mStackNum; Index ++) {
- if (mStackBufferIndex[Index] == NULL) {
- mStackBufferIndex[Index] = Handle;
- break;
- }
- }
- gBS->RestoreTPL(OldTpl);
- if (Index == mStackNum) {
- return EFI_OUT_OF_RESOURCES;
- }
- *BufferIndex = Index;
- *StackBuffer = mStackBuffer[Index];
- return EFI_SUCCESS;
-}
-
-/**
- Returns from the EBC stack by stack Index.
-
- @param Index Specifies which EBC stack to return from.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-ReturnEBCStack(
- IN UINTN Index
- )
-{
- mStackBufferIndex[Index] = NULL;
- return EFI_SUCCESS;
-}
-
-/**
- Returns from the EBC stack associated with the Handle parameter.
-
- @param Handle Specifies the EFI handle to find the EBC stack with.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-ReturnEBCStackByHandle(
- IN EFI_HANDLE Handle
- )
-{
- UINTN Index;
- for (Index = 0; Index < mStackNum; Index ++) {
- if (mStackBufferIndex[Index] == Handle) {
- break;
- }
- }
- if (Index == mStackNum) {
- return EFI_NOT_FOUND;
- }
- mStackBufferIndex[Index] = NULL;
- return EFI_SUCCESS;
-}
-
-/**
- Allocates memory to hold all the EBC stacks.
-
- @retval EFI_SUCCESS The EBC stacks were allocated successfully.
- @retval EFI_OUT_OF_RESOURCES Not enough memory available for EBC stacks.
-
-**/
-EFI_STATUS
-InitEBCStack (
- VOID
- )
-{
- for (mStackNum = 0; mStackNum < MAX_STACK_NUM; mStackNum ++) {
- mStackBuffer[mStackNum] = AllocatePool(STACK_POOL_SIZE);
- mStackBufferIndex[mStackNum] = NULL;
- if (mStackBuffer[mStackNum] == NULL) {
- break;
- }
- }
- if (mStackNum == 0) {
- return EFI_OUT_OF_RESOURCES;
- }
- return EFI_SUCCESS;
-}
-
-
-/**
- Free all EBC stacks allocated before.
-
- @retval EFI_SUCCESS All the EBC stacks were freed.
-
-**/
-EFI_STATUS
-FreeEBCStack(
- VOID
- )
-{
- UINTN Index;
- for (Index = 0; Index < mStackNum; Index ++) {
- FreePool(mStackBuffer[Index]);
- }
- return EFI_SUCCESS;
-}
-
-/**
- Produces an EBC VM test protocol that can be used for regression tests.
-
- @param IHandle Handle on which to install the protocol.
-
- @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-InitEbcVmTestProtocol (
- IN EFI_HANDLE *IHandle
- )
-{
- EFI_HANDLE Handle;
- EFI_STATUS Status;
- EFI_EBC_VM_TEST_PROTOCOL *EbcVmTestProtocol;
-
- //
- // Allocate memory for the protocol, then fill in the fields
- //
- EbcVmTestProtocol = AllocatePool (sizeof (EFI_EBC_VM_TEST_PROTOCOL));
- if (EbcVmTestProtocol == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
- EbcVmTestProtocol->Execute = (EBC_VM_TEST_EXECUTE) EbcExecuteInstructions;
-
- DEBUG_CODE_BEGIN ();
- EbcVmTestProtocol->Assemble = (EBC_VM_TEST_ASM) EbcVmTestUnsupported;
- EbcVmTestProtocol->Disassemble = (EBC_VM_TEST_DASM) EbcVmTestUnsupported;
- DEBUG_CODE_END ();
-
- //
- // Publish the protocol
- //
- Handle = NULL;
- Status = gBS->InstallProtocolInterface (&Handle, &gEfiEbcVmTestProtocolGuid, EFI_NATIVE_INTERFACE, EbcVmTestProtocol);
- if (EFI_ERROR (Status)) {
- FreePool (EbcVmTestProtocol);
- }
- return Status;
-}
-
-
-/**
- Returns the EFI_UNSUPPORTED Status.
-
- @return EFI_UNSUPPORTED This function always return EFI_UNSUPPORTED status.
-
-**/
-EFI_STATUS
-EFIAPI
-EbcVmTestUnsupported (
- VOID
- )
-{
- return EFI_UNSUPPORTED;
-}
-
diff --git a/MdeModulePkg/Universal/EbcDxe/EbcInt.h b/MdeModulePkg/Universal/EbcDxe/EbcInt.h deleted file mode 100644 index 01ac441215..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/EbcInt.h +++ /dev/null @@ -1,278 +0,0 @@ -/** @file
- Main routines for the EBC interpreter. Includes the initialization and
- main interpreter routines.
-
-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#ifndef _EBC_INT_H_
-#define _EBC_INT_H_
-
-
-#include <Uefi.h>
-
-#include <Protocol/DebugSupport.h>
-#include <Protocol/Ebc.h>
-#include <Protocol/EbcVmTest.h>
-#include <Protocol/EbcSimpleDebugger.h>
-
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/UefiDriverEntryPoint.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/MemoryAllocationLib.h>
-
-extern VM_CONTEXT *mVmPtr;
-
-//
-// Bits of exception flags field of VM context
-//
-#define EXCEPTION_FLAG_FATAL 0x80000000 // can't continue
-#define EXCEPTION_FLAG_ERROR 0x40000000 // bad, but try to continue
-#define EXCEPTION_FLAG_WARNING 0x20000000 // harmless problem
-#define EXCEPTION_FLAG_NONE 0x00000000 // for normal return
-//
-// Flags passed to the internal create-thunks function.
-//
-#define FLAG_THUNK_ENTRY_POINT 0x01 // thunk for an image entry point
-#define FLAG_THUNK_PROTOCOL 0x00 // thunk for an EBC protocol service
-//
-// Put this value at the bottom of the VM's stack gap so we can check it on
-// occasion to make sure the stack has not been corrupted.
-//
-#define VM_STACK_KEY_VALUE 0xDEADBEEF
-
-/**
- Create thunks for an EBC image entry point, or an EBC protocol service.
-
- @param ImageHandle Image handle for the EBC image. If not null, then
- we're creating a thunk for an image entry point.
- @param EbcEntryPoint Address of the EBC code that the thunk is to call
- @param Thunk Returned thunk we create here
- @param Flags Flags indicating options for creating the thunk
-
- @retval EFI_SUCCESS The thunk was created successfully.
- @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not 16-bit
- aligned.
- @retval EFI_OUT_OF_RESOURCES There is not enough memory to created the EBC
- Thunk.
- @retval EFI_BUFFER_TOO_SMALL EBC_THUNK_SIZE is not larger enough.
-
-**/
-EFI_STATUS
-EbcCreateThunks (
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk,
- IN UINT32 Flags
- );
-
-/**
- Add a thunk to our list of thunks for a given image handle.
- Also flush the instruction cache since we've written thunk code
- to memory that will be executed eventually.
-
- @param ImageHandle The image handle to which the thunk is tied.
- @param ThunkBuffer The buffer that has been created/allocated.
- @param ThunkSize The size of the thunk memory allocated.
-
- @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-EbcAddImageThunk (
- IN EFI_HANDLE ImageHandle,
- IN VOID *ThunkBuffer,
- IN UINT32 ThunkSize
- );
-
-//
-// The interpreter calls these when an exception is detected,
-// or as a periodic callback.
-//
-/**
- The VM interpreter calls this function when an exception is detected.
-
- @param ExceptionType Specifies the processor exception detected.
- @param ExceptionFlags Specifies the exception context.
- @param VmPtr Pointer to a VM context for passing info to the
- EFI debugger.
-
- @retval EFI_SUCCESS This function completed successfully.
-
-**/
-EFI_STATUS
-EbcDebugSignalException (
- IN EFI_EXCEPTION_TYPE ExceptionType,
- IN EXCEPTION_FLAGS ExceptionFlags,
- IN VM_CONTEXT *VmPtr
- );
-
-//
-// Define a constant of how often to call the debugger periodic callback
-// function.
-//
-#define EFI_TIMER_UNIT_1MS (1000 * 10)
-#define EBC_VM_PERIODIC_CALLBACK_RATE (1000 * EFI_TIMER_UNIT_1MS)
-#define STACK_POOL_SIZE (1024 * 1020)
-#define MAX_STACK_NUM 4
-
-//
-// External low level functions that are native-processor dependent
-//
-/**
- The VM thunk code stuffs an EBC entry point into a processor
- register. Since we can't use inline assembly to get it from
- the interpreter C code, stuff it into the return value
- register and return.
-
- @return The contents of the register in which the entry point is passed.
-
-**/
-UINTN
-EFIAPI
-EbcLLGetEbcEntryPoint (
- VOID
- );
-
-/**
- This function is called to execute an EBC CALLEX instruction.
- This instruction requires that we thunk out to external native
- code. For x64, we switch stacks, copy the arguments to the stack
- and jump to the specified function.
- On return, we restore the stack pointer to its original location.
- Destroys no working registers.
-
- @param CallAddr The function address.
- @param EbcSp The new EBC stack pointer.
- @param FramePtr The frame pointer.
-
- @return The unmodified value returned by the native code.
-
-**/
-INT64
-EFIAPI
-EbcLLCALLEXNative (
- IN UINTN CallAddr,
- IN UINTN EbcSp,
- IN VOID *FramePtr
- );
-
-/**
- This function is called to execute an EBC CALLEX instruction.
- The function check the callee's content to see whether it is common native
- code or a thunk to another piece of EBC code.
- If the callee is common native code, use EbcLLCAllEXASM to manipulate,
- otherwise, set the VM->IP to target EBC code directly to avoid another VM
- be startup which cost time and stack space.
-
- @param VmPtr Pointer to a VM context.
- @param FuncAddr Callee's address
- @param NewStackPointer New stack pointer after the call
- @param FramePtr New frame pointer after the call
- @param Size The size of call instruction
-
-**/
-VOID
-EbcLLCALLEX (
- IN VM_CONTEXT *VmPtr,
- IN UINTN FuncAddr,
- IN UINTN NewStackPointer,
- IN VOID *FramePtr,
- IN UINT8 Size
- );
-
-/**
- Returns the stack index and buffer assosicated with the Handle parameter.
-
- @param Handle The EFI handle as the index to the EBC stack.
- @param StackBuffer A pointer to hold the returned stack buffer.
- @param BufferIndex A pointer to hold the returned stack index.
-
- @retval EFI_OUT_OF_RESOURCES The Handle parameter does not correspond to any
- existing EBC stack.
- @retval EFI_SUCCESS The stack index and buffer were found and
- returned to the caller.
-
-**/
-EFI_STATUS
-GetEBCStack(
- IN EFI_HANDLE Handle,
- OUT VOID **StackBuffer,
- OUT UINTN *BufferIndex
- );
-
-/**
- Returns from the EBC stack by stack Index.
-
- @param Index Specifies which EBC stack to return from.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-ReturnEBCStack(
- IN UINTN Index
- );
-
-/**
- Allocates memory to hold all the EBC stacks.
-
- @retval EFI_SUCCESS The EBC stacks were allocated successfully.
- @retval EFI_OUT_OF_RESOURCES Not enough memory available for EBC stacks.
-
-**/
-EFI_STATUS
-InitEBCStack (
- VOID
- );
-
-/**
- Free all EBC stacks allocated before.
-
- @retval EFI_SUCCESS All the EBC stacks were freed.
-
-**/
-EFI_STATUS
-FreeEBCStack(
- VOID
- );
-
-/**
- Returns from the EBC stack associated with the Handle parameter.
-
- @param Handle Specifies the EFI handle to find the EBC stack with.
-
- @retval EFI_SUCCESS The function completed successfully.
-
-**/
-EFI_STATUS
-ReturnEBCStackByHandle(
- IN EFI_HANDLE Handle
- );
-
-typedef struct {
- EFI_EBC_PROTOCOL *This;
- VOID *EntryPoint;
- EFI_HANDLE ImageHandle;
- VM_CONTEXT VmContext;
-} EFI_EBC_THUNK_DATA;
-
-#define EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('e', 'b', 'c', 'p')
-
-
-#define EBC_PROTOCOL_PRIVATE_DATA_FROM_THIS(a) \
- CR(a, EBC_PROTOCOL_PRIVATE_DATA, EbcProtocol, EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE)
-
-
-#endif // #ifndef _EBC_INT_H_
diff --git a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.S b/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.S deleted file mode 100644 index caf8d40ffb..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.S +++ /dev/null @@ -1,83 +0,0 @@ -#/** @file
-#
-# Low level IA32 specific EBC support routines.
-#
-# Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
-# 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.
-#
-#**/
-
-ASM_GLOBAL ASM_PFX(CopyMem)
-ASM_GLOBAL ASM_PFX(EbcInterpret)
-ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint)
-
-ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative)
-ASM_PFX(EbcLLCALLEXNative):
- push %ebp
- push %ebx
- mov %esp,%ebp
- mov 0xc(%esp),%ecx
- mov 0x14(%esp),%eax
- mov 0x10(%esp),%edx
- sub %edx,%eax
- sub %eax,%esp
- mov %esp,%ebx
- push %ecx
- push %eax
- push %edx
- push %ebx
- call ASM_PFX(CopyMem)
- pop %eax
- pop %eax
- pop %eax
- pop %ecx
- call *%ecx
- mov %ebp,%esp
- mov %ebp,%esp
- pop %ebx
- pop %ebp
- ret
-
-ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret)
-ASM_PFX(EbcLLEbcInterpret):
- # Construct new stack
- push %ebp
- mov %esp, %ebp
- push %esi
- push %edi
- sub $0x40, %esp
- push %eax
- mov %ebp, %esi
- add $0x8, %esi
- mov %esp, %edi
- add $0x4, %edi
- mov $0x10, %ecx
- rep movsd
-
- # call C-code
- call ASM_PFX(EbcInterpret)
- add $0x44, %esp
- pop %edi
- pop %esi
- pop %ebp
- ret
-
-ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint)
-ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
- # Construct new stack
- mov %eax, -0xC(%esp)
- mov 0x4(%esp), %eax
- mov %eax, -0x8(%esp)
- mov 0x8(%esp), %eax
- mov %eax, -0x4(%esp)
- # call C-code
- sub $0xC, %esp
- call ASM_PFX(ExecuteEbcImageEntryPoint)
- add $0xC, %esp
- ret
diff --git a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.asm b/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.asm deleted file mode 100644 index b16fda69fa..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.asm +++ /dev/null @@ -1,207 +0,0 @@ -;/** @file
-;
-; This code provides low level routines that support the Virtual Machine
-; for option ROMs.
-;
-; Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-; 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.
-;
-;**/
-
- page ,132
- title VM ASSEMBLY LANGUAGE ROUTINES
-
-;---------------------------------------------------------------------------
-; Equate files needed.
-;---------------------------------------------------------------------------
-
-.XLIST
-
-.LIST
-
-;---------------------------------------------------------------------------
-; Assembler options
-;---------------------------------------------------------------------------
-
-.686p
-.model flat, C
-.code
-CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD
-EbcInterpret PROTO
-ExecuteEbcImageEntryPoint PROTO
-
-;****************************************************************************
-; EbcLLCALLEXNative
-;
-; This function is called to execute an EBC CALLEX instruction
-; to native code.
-; This instruction requires that we thunk out to external native
-; code. For IA32, we simply switch stacks and jump to the
-; specified function. On return, we restore the stack pointer
-; to its original location.
-;
-; Destroys no working registers.
-;****************************************************************************
-; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
-EbcLLCALLEXNative PROC PUBLIC
- push ebp
- push ebx
- mov ebp, esp ; standard function prolog
-
- ; Get function address in a register
- ; mov ecx, FuncAddr => mov ecx, dword ptr [FuncAddr]
- mov ecx, dword ptr [esp]+0Ch
-
- ; Set stack pointer to new value
- ; mov eax, NewStackPointer => mov eax, dword ptr [NewSp]
- mov eax, dword ptr [esp] + 14h
- mov edx, dword ptr [esp] + 10h
- sub eax, edx
- sub esp, eax
- mov ebx, esp
- push ecx
- push eax
- push edx
- push ebx
- call CopyMem
- pop eax
- pop eax
- pop eax
- pop ecx
-
- ; Now call the external routine
- call ecx
-
- ; ebp is preserved by the callee. In this function it
- ; equals the original esp, so set them equal
- mov esp, ebp
-
- ; Standard function epilog
- mov esp, ebp
- pop ebx
- pop ebp
- ret
-EbcLLCALLEXNative ENDP
-
-;****************************************************************************
-; EbcLLEbcInterpret
-;
-; Begin executing an EBC image.
-;****************************************************************************
-; UINT64 EbcLLEbcInterpret(VOID)
-EbcLLEbcInterpret PROC PUBLIC
- ;
- ;; mov eax, 0xca112ebc
- ;; mov eax, EbcEntryPoint
- ;; mov ecx, EbcLLEbcInterpret
- ;; jmp ecx
- ;
- ; Caller uses above instruction to jump here
- ; The stack is below:
- ; +-----------+
- ; | RetAddr |
- ; +-----------+
- ; |EntryPoint | (EAX)
- ; +-----------+
- ; | Arg1 | <- EDI
- ; +-----------+
- ; | Arg2 |
- ; +-----------+
- ; | ... |
- ; +-----------+
- ; | Arg16 |
- ; +-----------+
- ; | EDI |
- ; +-----------+
- ; | ESI |
- ; +-----------+
- ; | EBP | <- EBP
- ; +-----------+
- ; | RetAddr | <- ESP is here
- ; +-----------+
- ; | Arg1 | <- ESI
- ; +-----------+
- ; | Arg2 |
- ; +-----------+
- ; | ... |
- ; +-----------+
- ; | Arg16 |
- ; +-----------+
- ;
-
- ; Construct new stack
- push ebp
- mov ebp, esp
- push esi
- push edi
- sub esp, 40h
- push eax
- mov esi, ebp
- add esi, 8
- mov edi, esp
- add edi, 4
- mov ecx, 16
- rep movsd
-
- ; call C-code
- call EbcInterpret
- add esp, 44h
- pop edi
- pop esi
- pop ebp
- ret
-EbcLLEbcInterpret ENDP
-
-;****************************************************************************
-; EbcLLExecuteEbcImageEntryPoint
-;
-; Begin executing an EBC image.
-;****************************************************************************
-; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)
-EbcLLExecuteEbcImageEntryPoint PROC PUBLIC
- ;
- ;; mov eax, 0xca112ebc
- ;; mov eax, EbcEntryPoint
- ;; mov ecx, EbcLLExecuteEbcImageEntryPoint
- ;; jmp ecx
- ;
- ; Caller uses above instruction to jump here
- ; The stack is below:
- ; +-----------+
- ; | RetAddr |
- ; +-----------+
- ; |EntryPoint | (EAX)
- ; +-----------+
- ; |ImageHandle|
- ; +-----------+
- ; |SystemTable|
- ; +-----------+
- ; | RetAddr | <- ESP is here
- ; +-----------+
- ; |ImageHandle|
- ; +-----------+
- ; |SystemTable|
- ; +-----------+
- ;
-
- ; Construct new stack
- mov [esp - 0Ch], eax
- mov eax, [esp + 04h]
- mov [esp - 08h], eax
- mov eax, [esp + 08h]
- mov [esp - 04h], eax
-
- ; call C-code
- sub esp, 0Ch
- call ExecuteEbcImageEntryPoint
- add esp, 0Ch
- ret
-EbcLLExecuteEbcImageEntryPoint ENDP
-
-END
diff --git a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcSupport.c b/MdeModulePkg/Universal/EbcDxe/Ia32/EbcSupport.c deleted file mode 100644 index bddfbf630d..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ia32/EbcSupport.c +++ /dev/null @@ -1,529 +0,0 @@ -/** @file
- This module contains EBC support routines that are customized based on
- the target ia32 processor.
-
-Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#include "EbcInt.h"
-#include "EbcExecute.h"
-
-//
-// NOTE: This is the stack size allocated for the interpreter
-// when it executes an EBC image. The requirements can change
-// based on whether or not a debugger is present, and other
-// platform-specific configurations.
-//
-#define VM_STACK_SIZE (1024 * 4)
-
-#define STACK_REMAIN_SIZE (1024 * 4)
-
-//
-// This is instruction buffer used to create EBC thunk
-//
-#define EBC_ENTRYPOINT_SIGNATURE 0xAFAFAFAF
-#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE 0xFAFAFAFA
-UINT8 mInstructionBufferTemplate[] = {
- //
- // Add a magic code here to help the VM recognize the thunk..
- // mov eax, 0xca112ebc => B8 BC 2E 11 CA
- //
- 0xB8, 0xBC, 0x2E, 0x11, 0xCA,
- //
- // Add code bytes to load up a processor register with the EBC entry point.
- // mov eax, EbcEntryPoint => B8 XX XX XX XX (To be fixed at runtime)
- // These 4 bytes of the thunk entry is the address of the EBC
- // entry point.
- //
- 0xB8,
- (UINT8)(EBC_ENTRYPOINT_SIGNATURE & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
- //
- // Stick in a load of ecx with the address of appropriate VM function.
- // mov ecx, EbcLLEbcInterpret => B9 XX XX XX XX (To be fixed at runtime)
- //
- 0xB9,
- (UINT8)(EBC_LL_EBC_ENTRYPOINT_SIGNATURE & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
- //
- // Stick in jump opcode bytes
- // jmp ecx => FF E1
- //
- 0xFF, 0xE1,
-};
-
-/**
- Begin executing an EBC image.
- This is used for Ebc Thunk call.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcLLEbcInterpret (
- VOID
- );
-
-/**
- Begin executing an EBC image.
- This is used for Ebc image entrypoint.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcLLExecuteEbcImageEntryPoint (
- VOID
- );
-
-/**
- This function is called to execute an EBC CALLEX instruction.
- The function check the callee's content to see whether it is common native
- code or a thunk to another piece of EBC code.
- If the callee is common native code, use EbcLLCAllEXASM to manipulate,
- otherwise, set the VM->IP to target EBC code directly to avoid another VM
- be startup which cost time and stack space.
-
- @param VmPtr Pointer to a VM context.
- @param FuncAddr Callee's address
- @param NewStackPointer New stack pointer after the call
- @param FramePtr New frame pointer after the call
- @param Size The size of call instruction
-
-**/
-VOID
-EbcLLCALLEX (
- IN VM_CONTEXT *VmPtr,
- IN UINTN FuncAddr,
- IN UINTN NewStackPointer,
- IN VOID *FramePtr,
- IN UINT8 Size
- )
-{
- UINTN IsThunk;
- UINTN TargetEbcAddr;
- UINT8 InstructionBuffer[sizeof(mInstructionBufferTemplate)];
- UINTN Index;
- UINTN IndexOfEbcEntrypoint;
-
- IsThunk = 1;
- TargetEbcAddr = 0;
- IndexOfEbcEntrypoint = 0;
-
- //
- // Processor specific code to check whether the callee is a thunk to EBC.
- //
- CopyMem (InstructionBuffer, (VOID *)FuncAddr, sizeof(InstructionBuffer));
- //
- // Fill the signature according to mInstructionBufferTemplate
- //
- for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
- if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&InstructionBuffer[Index] = EBC_ENTRYPOINT_SIGNATURE;
- IndexOfEbcEntrypoint = Index;
- }
- if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&InstructionBuffer[Index] = EBC_LL_EBC_ENTRYPOINT_SIGNATURE;
- }
- }
- //
- // Check if we need thunk to native
- //
- if (CompareMem (InstructionBuffer, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate)) != 0) {
- IsThunk = 0;
- }
-
- if (IsThunk == 1){
- //
- // The callee is a thunk to EBC, adjust the stack pointer down 16 bytes and
- // put our return address and frame pointer on the VM stack.
- // Then set the VM's IP to new EBC code.
- //
- VmPtr->Gpr[0] -= 8;
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
- VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
- VmPtr->Gpr[0] -= 8;
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));
-
- CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + IndexOfEbcEntrypoint, sizeof(UINTN));
- VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
- } else {
- //
- // The callee is not a thunk to EBC, call native code,
- // and get return value.
- //
- VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
-
- //
- // Advance the IP.
- //
- VmPtr->Ip += Size;
- }
-}
-
-
-/**
- Begin executing an EBC image.
-
- This is a thunk function. Microsoft x64 compiler only provide fast_call
- calling convention, so the first four arguments are passed by rcx, rdx,
- r8, and r9, while other arguments are passed in stack.
-
- @param EntryPoint The entrypoint of EBC code.
- @param Arg1 The 1st argument.
- @param Arg2 The 2nd argument.
- @param Arg3 The 3rd argument.
- @param Arg4 The 4th argument.
- @param Arg5 The 5th argument.
- @param Arg6 The 6th argument.
- @param Arg7 The 7th argument.
- @param Arg8 The 8th argument.
- @param Arg9 The 9th argument.
- @param Arg10 The 10th argument.
- @param Arg11 The 11th argument.
- @param Arg12 The 12th argument.
- @param Arg13 The 13th argument.
- @param Arg14 The 14th argument.
- @param Arg15 The 15th argument.
- @param Arg16 The 16th argument.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcInterpret (
- IN UINTN EntryPoint,
- IN UINTN Arg1,
- IN UINTN Arg2,
- IN UINTN Arg3,
- IN UINTN Arg4,
- IN UINTN Arg5,
- IN UINTN Arg6,
- IN UINTN Arg7,
- IN UINTN Arg8,
- IN UINTN Arg9,
- IN UINTN Arg10,
- IN UINTN Arg11,
- IN UINTN Arg12,
- IN UINTN Arg13,
- IN UINTN Arg14,
- IN UINTN Arg15,
- IN UINTN Arg16
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
-
- //
- // Get the EBC entry point
- //
- Addr = EntryPoint;
-
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
-
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
- //
- // Initialize the stack pointer for the EBC. Get the current system stack
- // pointer and adjust it down by the max needed for the interpreter.
- //
-
- //
- // Align the stack on a natural boundary
- //
-
- //
- // Allocate stack pool
- //
- Status = GetEBCStack((EFI_HANDLE)-1, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN)VmContext.Gpr[0];
- VmContext.Gpr[0] &= ~((VM_REGISTER)(sizeof (UINTN) - 1));
- VmContext.Gpr[0] -= sizeof (UINTN);
-
- //
- // Put a magic value in the stack gap, then adjust down again
- //
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
- VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
-
- //
- // For IA32, this is where we say our return address is
- //
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg16;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg15;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg14;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg13;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg12;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg11;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg10;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg9;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg8;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg7;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg6;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg5;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg4;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg3;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg2;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg1;
- VmContext.Gpr[0] -= 16;
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
-
- //
- // We need to keep track of where the EBC stack starts. This way, if the EBC
- // accesses any stack variables above its initial stack setting, then we know
- // it's accessing variables passed into it, which means the data is on the
- // VM's stack.
- // When we're called, on the stack (high to low) we have the parameters, the
- // return address, then the saved ebp. Save the pointer to the return address.
- // EBC code knows that's there, so should look above it for function parameters.
- // The offset is the size of locals (VMContext + Addr + saved ebp).
- // Note that the interpreter assumes there is a 16 bytes of return address on
- // the stack too, so adjust accordingly.
- // VmContext.HighStackBottom = (UINTN)(Addr + sizeof (VmContext) + sizeof (Addr));
- //
-
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
-
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Begin executing an EBC image.
-
- @param EntryPoint The entrypoint of EBC code.
- @param ImageHandle image handle for the EBC application we're executing
- @param SystemTable standard system table passed into an driver's entry
- point
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-ExecuteEbcImageEntryPoint (
- IN UINTN EntryPoint,
- IN EFI_HANDLE ImageHandle,
- IN EFI_SYSTEM_TABLE *SystemTable
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
-
- //
- // Get the EBC entry point
- //
- Addr = EntryPoint;
-
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
-
- //
- // Save the image handle so we can track the thunks created for this image
- //
- VmContext.ImageHandle = ImageHandle;
- VmContext.SystemTable = SystemTable;
-
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
-
- //
- // Initialize the stack pointer for the EBC. Get the current system stack
- // pointer and adjust it down by the max needed for the interpreter.
- //
-
- //
- // Allocate stack pool
- //
- Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN)VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
-
- //
- // Put a magic value in the stack gap, then adjust down again
- //
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
- VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
-
- //
- // Align the stack on a natural boundary
- // VmContext.Gpr[0] &= ~(sizeof(UINTN) - 1);
- //
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) SystemTable;
- VmContext.Gpr[0] -= sizeof (UINTN);
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) ImageHandle;
-
- VmContext.Gpr[0] -= 16;
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
- //
- // VM pushes 16-bytes for return address. Simulate that here.
- //
-
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
-
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Create thunks for an EBC image entry point, or an EBC protocol service.
-
- @param ImageHandle Image handle for the EBC image. If not null, then
- we're creating a thunk for an image entry point.
- @param EbcEntryPoint Address of the EBC code that the thunk is to call
- @param Thunk Returned thunk we create here
- @param Flags Flags indicating options for creating the thunk
-
- @retval EFI_SUCCESS The thunk was created successfully.
- @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not 16-bit
- aligned.
- @retval EFI_OUT_OF_RESOURCES There is not enough memory to created the EBC
- Thunk.
- @retval EFI_BUFFER_TOO_SMALL EBC_THUNK_SIZE is not larger enough.
-
-**/
-EFI_STATUS
-EbcCreateThunks (
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk,
- IN UINT32 Flags
- )
-{
- UINT8 *Ptr;
- UINT8 *ThunkBase;
- UINT32 Index;
- INT32 ThunkSize;
-
- //
- // Check alignment of pointer to EBC code
- //
- if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
- return EFI_INVALID_PARAMETER;
- }
-
- ThunkSize = sizeof(mInstructionBufferTemplate);
-
- Ptr = AllocatePool (sizeof(mInstructionBufferTemplate));
-
- if (Ptr == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
- //
- // Print(L"Allocate TH: 0x%X\n", (UINT32)Ptr);
- //
- // Save the start address so we can add a pointer to it to a list later.
- //
- ThunkBase = Ptr;
-
- //
- // Give them the address of our buffer we're going to fix up
- //
- *Thunk = (VOID *) Ptr;
-
- //
- // Copy whole thunk instruction buffer template
- //
- CopyMem (Ptr, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate));
-
- //
- // Patch EbcEntryPoint and EbcLLEbcInterpret
- //
- for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
- if (*(UINTN *)&Ptr[Index] == EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcEntryPoint;
- }
- if (*(UINTN *)&Ptr[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
- if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcLLExecuteEbcImageEntryPoint;
- } else {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcLLEbcInterpret;
- }
- }
- }
-
- //
- // Add the thunk to the list for this image. Do this last since the add
- // function flushes the cache for us.
- //
- EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
-
- return EFI_SUCCESS;
-}
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s deleted file mode 100644 index 4ae24dee7d..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s +++ /dev/null @@ -1,206 +0,0 @@ -///** @file
-//
-// Contains low level routines for the Virtual Machine implementation
-// on an Itanium-based platform.
-//
-// Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-// 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.
-//
-//**/
-
-.file "EbcLowLevel.s"
-
-#define PROCEDURE_ENTRY(name) .##text; \
- .##type name, @function; \
- .##proc name; \
-name::
-
-#define PROCEDURE_EXIT(name) .##endp name
-
-// Note: use of NESTED_SETUP requires number of locals (l) >= 3
-
-#define NESTED_SETUP(i,l,o,r) \
- alloc loc1=ar##.##pfs,i,l,o,r ;\
- mov loc0=b0
-
-#define NESTED_RETURN \
- mov b0=loc0 ;\
- mov ar##.##pfs=loc1 ;;\
- br##.##ret##.##dpnt b0;;
-
-.type CopyMem, @function;
-
-//-----------------------------------------------------------------------------
-//++
-// EbcAsmLLCALLEX
-//
-// Implements the low level EBC CALLEX instruction. Sets up the
-// stack pointer, does the spill of function arguments, and
-// calls the native function. On return it restores the original
-// stack pointer and returns to the caller.
-//
-// Arguments :
-//
-// On Entry :
-// in0 = Address of native code to call
-// in1 = New stack pointer
-//
-// Return Value:
-//
-// As per static calling conventions.
-//
-//--
-//---------------------------------------------------------------------------
-;// void EbcAsmLLCALLEX (UINTN FunctionAddr, UINTN EbcStackPointer)
-PROCEDURE_ENTRY(EbcAsmLLCALLEX)
- NESTED_SETUP (2,6,8,0)
-
- // NESTED_SETUP uses loc0 and loc1 for context save
-
- //
- // Save a copy of the EBC VM stack pointer
- //
- mov r8 = in1;;
-
- //
- // Copy stack arguments from EBC stack into registers.
- // Assume worst case and copy 8.
- //
- ld8 out0 = [r8], 8;;
- ld8 out1 = [r8], 8;;
- ld8 out2 = [r8], 8;;
- ld8 out3 = [r8], 8;;
- ld8 out4 = [r8], 8;;
- ld8 out5 = [r8], 8;;
- ld8 out6 = [r8], 8;;
- ld8 out7 = [r8], 8;;
-
- //
- // Save the original stack pointer
- //
- mov loc2 = r12;
-
- //
- // Save the gp
- //
- or loc3 = r1, r0
-
- //
- // Set the new aligned stack pointer. Reserve space for the required
- // 16-bytes of scratch area as well.
- //
- add r12 = 48, in1
-
- //
- // Now call the function. Load up the function address from the descriptor
- // pointed to by in0. Then get the gp from the descriptor at the following
- // address in the descriptor.
- //
- ld8 r31 = [in0], 8;;
- ld8 r30 = [in0];;
- mov b1 = r31
- mov r1 = r30
- (p0) br.call.dptk.many b0 = b1;;
-
- //
- // Restore the original stack pointer and gp
- //
- mov r12 = loc2
- or r1 = loc3, r0
-
- //
- // Now return
- //
- NESTED_RETURN
-
-PROCEDURE_EXIT(EbcAsmLLCALLEX)
-
-//-----------------------------------------------------------------------------
-//++
-// EbcLLCALLEXNative
-//
-// This function is called to execute an EBC CALLEX instruction.
-// This instruction requires that we thunk out to external native
-// code. On return, we restore the stack pointer to its original location.
-// Destroys no working registers. For IPF, at least 8 register slots
-// must be allocated on the stack frame to support any number of
-// arguments beiung passed to the external native function. The
-// size of the stack frame is FramePtr - EbcSp. If this size is less
-// than 64-bytes, the amount of stack frame allocated is rounded up
-// to 64-bytes
-//
-// Arguments On Entry :
-// in0 = CallAddr The function address.
-// in1 = EbcSp The new EBC stack pointer.
-// in2 = FramePtr The frame pointer.
-//
-// Return Value:
-// None
-//
-// C Function Prototype:
-// VOID
-// EFIAPI
-// EbcLLCALLEXNative (
-// IN UINTN CallAddr,
-// IN UINTN EbcSp,
-// IN VOID *FramePtr
-// );
-//--
-//---------------------------------------------------------------------------
-
-PROCEDURE_ENTRY(EbcLLCALLEXNative)
- NESTED_SETUP (3,6,3,0)
-
- mov loc2 = in2;; // loc2 = in2 = FramePtr
- mov loc3 = in1;; // loc3 = in1 = EbcSp
- sub loc2 = loc2, loc3;; // loc2 = loc2 - loc3 = FramePtr - EbcSp
- mov out2 = loc2;; // out2 = loc2 = FramePtr - EbcSp
- mov loc4 = 0x40;; // loc4 = 0x40
- cmp.leu p6 = out2, loc4;; // IF out2 < loc4 THEN P6=1 ELSE P6=0; IF (FramePtr - EbcSp) < 0x40 THEN P6 = 1 ELSE P6=0
- (p6) mov loc2 = loc4;; // IF P6==1 THEN loc2 = loc4 = 0x40
- mov loc4 = r12;; // save sp
- or loc5 = r1, r0 // save gp
-
- sub r12 = r12, loc2;; // sp = sp - loc2 = sp - MAX (0x40, FramePtr - EbcSp)
-
- and r12 = -0x10, r12 // Round sp down to the nearest 16-byte boundary
- mov out1 = in1;; // out1 = EbcSp
- mov out0 = r12;; // out0 = sp
- adds r12 = -0x8, r12
- (p0) br.call.dptk.many b0 = CopyMem;; // CopyMem (sp, EbcSp, (FramePtr - EbcSp))
- adds r12 = 0x8, r12
-
- mov out0 = in0;; // out0 = CallAddr
- mov out1 = r12;; // out1 = sp
- (p0) br.call.dptk.many b0 = EbcAsmLLCALLEX;; // EbcAsmLLCALLEX (CallAddr, sp)
- mov r12 = loc4;; // restore sp
- or r1 = loc5, r0 // restore gp
-
- NESTED_RETURN
-PROCEDURE_EXIT(EbcLLCALLEXNative)
-
-
-//
-// UINTN EbcLLGetEbcEntryPoint(VOID)
-//
-// Description:
-// Simply return, so that the caller retrieves the return register
-// contents (R8). That's where the thunk-to-ebc code stuffed the
-// EBC entry point.
-//
-PROCEDURE_ENTRY(EbcLLGetEbcEntryPoint)
- br.ret.sptk b0 ;;
-PROCEDURE_EXIT(EbcLLGetEbcEntryPoint)
-
-
-
-
-
-
-
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c deleted file mode 100644 index 23b6c1bd84..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c +++ /dev/null @@ -1,879 +0,0 @@ -/** @file
- This module contains EBC support routines that are customized based on
- the target processor.
-
-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#include "EbcInt.h"
-#include "EbcExecute.h"
-#include "EbcSupport.h"
-
-/**
- Given raw bytes of Itanium based code, format them into a bundle and
- write them out.
-
- @param MemPtr pointer to memory location to write the bundles
- to.
- @param Template 5-bit template.
- @param Slot0 Instruction slot 0 data for the bundle.
- @param Slot1 Instruction slot 1 data for the bundle.
- @param Slot2 Instruction slot 2 data for the bundle.
-
- @retval EFI_INVALID_PARAMETER Pointer is not aligned
- @retval EFI_INVALID_PARAMETER No more than 5 bits in template
- @retval EFI_INVALID_PARAMETER More than 41 bits used in code
- @retval EFI_SUCCESS All data is written.
-
-**/
-EFI_STATUS
-WriteBundle (
- IN VOID *MemPtr,
- IN UINT8 Template,
- IN UINT64 Slot0,
- IN UINT64 Slot1,
- IN UINT64 Slot2
- );
-
-/**
- Pushes a 64 bit unsigned value to the VM stack.
-
- @param VmPtr The pointer to current VM context.
- @param Arg The value to be pushed.
-
-**/
-VOID
-PushU64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Arg
- )
-{
- //
- // Advance the VM stack down, and then copy the argument to the stack.
- // Hope it's aligned.
- //
- VmPtr->Gpr[0] -= sizeof (UINT64);
- *(UINT64 *) VmPtr->Gpr[0] = Arg;
-}
-
-/**
- Begin executing an EBC image. The address of the entry point is passed
- in via a processor register, so we'll need to make a call to get the
- value.
-
- This is a thunk function. Microsoft x64 compiler only provide fast_call
- calling convention, so the first four arguments are passed by rcx, rdx,
- r8, and r9, while other arguments are passed in stack.
-
- @param Arg1 The 1st argument.
- @param ... The variable arguments list.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcInterpret (
- UINT64 Arg1,
- ...
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
- VA_LIST List;
- UINT64 Arg2;
- UINT64 Arg3;
- UINT64 Arg4;
- UINT64 Arg5;
- UINT64 Arg6;
- UINT64 Arg7;
- UINT64 Arg8;
- UINT64 Arg9;
- UINT64 Arg10;
- UINT64 Arg11;
- UINT64 Arg12;
- UINT64 Arg13;
- UINT64 Arg14;
- UINT64 Arg15;
- UINT64 Arg16;
- //
- // Get the EBC entry point from the processor register. Make sure you don't
- // call any functions before this or you could mess up the register the
- // entry point is passed in.
- //
- Addr = EbcLLGetEbcEntryPoint ();
- //
- // Need the args off the stack.
- //
- VA_START (List, Arg1);
- Arg2 = VA_ARG (List, UINT64);
- Arg3 = VA_ARG (List, UINT64);
- Arg4 = VA_ARG (List, UINT64);
- Arg5 = VA_ARG (List, UINT64);
- Arg6 = VA_ARG (List, UINT64);
- Arg7 = VA_ARG (List, UINT64);
- Arg8 = VA_ARG (List, UINT64);
- Arg9 = VA_ARG (List, UINT64);
- Arg10 = VA_ARG (List, UINT64);
- Arg11 = VA_ARG (List, UINT64);
- Arg12 = VA_ARG (List, UINT64);
- Arg13 = VA_ARG (List, UINT64);
- Arg14 = VA_ARG (List, UINT64);
- Arg15 = VA_ARG (List, UINT64);
- Arg16 = VA_ARG (List, UINT64);
- VA_END (List);
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
- //
- // Initialize the stack pointer for the EBC. Get the current system stack
- // pointer and adjust it down by the max needed for the interpreter.
- //
- //
- // NOTE: Eventually we should have the interpreter allocate memory
- // for stack space which it will use during its execution. This
- // would likely improve performance because the interpreter would
- // no longer be required to test each memory access and adjust
- // those reading from the stack gap.
- //
- // For IPF, the stack looks like (assuming 10 args passed)
- // arg10
- // arg9 (Bottom of high stack)
- // [ stack gap for interpreter execution ]
- // [ magic value for detection of stack corruption ]
- // arg8 (Top of low stack)
- // arg7....
- // arg1
- // [ 64-bit return address ]
- // [ ebc stack ]
- // If the EBC accesses memory in the stack gap, then we assume that it's
- // actually trying to access args9 and greater. Therefore we need to
- // adjust memory accesses in this region to point above the stack gap.
- //
- //
- // Now adjust the EBC stack pointer down to leave a gap for interpreter
- // execution. Then stuff a magic value there.
- //
-
- Status = GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
-
-
- PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
- VmContext.StackMagicPtr = (UINTN *) VmContext.Gpr[0];
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
- //
- // Push the EBC arguments on the stack. Does not matter that they may not
- // all be valid.
- //
- PushU64 (&VmContext, Arg16);
- PushU64 (&VmContext, Arg15);
- PushU64 (&VmContext, Arg14);
- PushU64 (&VmContext, Arg13);
- PushU64 (&VmContext, Arg12);
- PushU64 (&VmContext, Arg11);
- PushU64 (&VmContext, Arg10);
- PushU64 (&VmContext, Arg9);
- PushU64 (&VmContext, Arg8);
- PushU64 (&VmContext, Arg7);
- PushU64 (&VmContext, Arg6);
- PushU64 (&VmContext, Arg5);
- PushU64 (&VmContext, Arg4);
- PushU64 (&VmContext, Arg3);
- PushU64 (&VmContext, Arg2);
- PushU64 (&VmContext, Arg1);
- //
- // Push a bogus return address on the EBC stack because the
- // interpreter expects one there. For stack alignment purposes on IPF,
- // EBC return addresses are always 16 bytes. Push a bogus value as well.
- //
- PushU64 (&VmContext, 0);
- PushU64 (&VmContext, 0xDEADBEEFDEADBEEF);
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Begin executing an EBC image. The address of the entry point is passed
- in via a processor register, so we'll need to make a call to get the
- value.
-
- @param ImageHandle image handle for the EBC application we're executing
- @param SystemTable standard system table passed into an driver's entry
- point
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-ExecuteEbcImageEntryPoint (
- IN EFI_HANDLE ImageHandle,
- IN EFI_SYSTEM_TABLE *SystemTable
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
-
- //
- // Get the EBC entry point from the processor register. Make sure you don't
- // call any functions before this or you could mess up the register the
- // entry point is passed in.
- //
- Addr = EbcLLGetEbcEntryPoint ();
-
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
-
- //
- // Save the image handle so we can track the thunks created for this image
- //
- VmContext.ImageHandle = ImageHandle;
- VmContext.SystemTable = SystemTable;
-
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
-
- //
- // Get the stack pointer. This is the bottom of the upper stack.
- //
-
- Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
-
-
- //
- // Allocate stack space for the interpreter. Then put a magic value
- // at the bottom so we can detect stack corruption.
- //
- PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
- VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
-
- //
- // When we thunk to external native code, we copy the last 8 qwords from
- // the EBC stack into the processor registers, and adjust the stack pointer
- // up. If the caller is not passing 8 parameters, then we've moved the
- // stack pointer up into the stack gap. If this happens, then the caller
- // can mess up the stack gap contents (in particular our magic value).
- // Therefore, leave another gap below the magic value. Pick 10 qwords down,
- // just as a starting point.
- //
- VmContext.Gpr[0] -= 10 * sizeof (UINT64);
-
- //
- // Align the stack pointer such that after pushing the system table,
- // image handle, and return address on the stack, it's aligned on a 16-byte
- // boundary as required for IPF.
- //
- VmContext.Gpr[0] &= (INT64)~0x0f;
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
- //
- // Simply copy the image handle and system table onto the EBC stack.
- // Greatly simplifies things by not having to spill the args
- //
- PushU64 (&VmContext, (UINT64) SystemTable);
- PushU64 (&VmContext, (UINT64) ImageHandle);
-
- //
- // Interpreter assumes 64-bit return address is pushed on the stack.
- // IPF does not do this so pad the stack accordingly. Also, a
- // "return address" is 16 bytes as required for IPF stack alignments.
- //
- PushU64 (&VmContext, (UINT64) 0);
- PushU64 (&VmContext, (UINT64) 0x1234567887654321);
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
-
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
-
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Create thunks for an EBC image entry point, or an EBC protocol service.
-
- @param ImageHandle Image handle for the EBC image. If not null, then
- we're creating a thunk for an image entry point.
- @param EbcEntryPoint Address of the EBC code that the thunk is to call
- @param Thunk Returned thunk we create here
- @param Flags Flags indicating options for creating the thunk
-
- @retval EFI_SUCCESS The thunk was created successfully.
- @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not 16-bit
- aligned.
- @retval EFI_OUT_OF_RESOURCES There is not enough memory to created the EBC
- Thunk.
- @retval EFI_BUFFER_TOO_SMALL EBC_THUNK_SIZE is not larger enough.
-
-**/
-EFI_STATUS
-EbcCreateThunks (
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk,
- IN UINT32 Flags
- )
-{
- UINT8 *Ptr;
- UINT8 *ThunkBase;
- UINT64 Addr;
- UINT64 Code[3]; // Code in a bundle
- UINT64 RegNum; // register number for MOVL
- UINT64 BitI; // bits of MOVL immediate data
- UINT64 BitIc; // bits of MOVL immediate data
- UINT64 BitImm5c; // bits of MOVL immediate data
- UINT64 BitImm9d; // bits of MOVL immediate data
- UINT64 BitImm7b; // bits of MOVL immediate data
- UINT64 Br; // branch register for loading and jumping
- UINT64 *Data64Ptr;
- UINT32 ThunkSize;
- UINT32 Size;
-
- //
- // Check alignment of pointer to EBC code, which must always be aligned
- // on a 2-byte boundary.
- //
- if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
- return EFI_INVALID_PARAMETER;
- }
- //
- // Allocate memory for the thunk. Make the (most likely incorrect) assumption
- // that the returned buffer is not aligned, so round up to the next
- // alignment size.
- //
- Size = EBC_THUNK_SIZE + EBC_THUNK_ALIGNMENT - 1;
- ThunkSize = Size;
- Ptr = AllocatePool (Size);
-
- if (Ptr == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
- //
- // Save the start address of the buffer.
- //
- ThunkBase = Ptr;
-
- //
- // Make sure it's aligned for code execution. If not, then
- // round up.
- //
- if ((UINT32) (UINTN) Ptr & (EBC_THUNK_ALIGNMENT - 1)) {
- Ptr = (UINT8 *) (((UINTN) Ptr + (EBC_THUNK_ALIGNMENT - 1)) &~ (UINT64) (EBC_THUNK_ALIGNMENT - 1));
- }
- //
- // Return the pointer to the thunk to the caller to user as the
- // image entry point.
- //
- *Thunk = (VOID *) Ptr;
-
- //
- // Clear out the thunk entry
- // ZeroMem(Ptr, Size);
- //
- // For IPF, when you do a call via a function pointer, the function pointer
- // actually points to a function descriptor which consists of a 64-bit
- // address of the function, followed by a 64-bit gp for the function being
- // called. See the the Software Conventions and Runtime Architecture Guide
- // for details.
- // So first off in our thunk, create a descriptor for our actual thunk code.
- // This means we need to create a pointer to the thunk code (which follows
- // the descriptor we're going to create), followed by the gp of the Vm
- // interpret function we're going to eventually execute.
- //
- Data64Ptr = (UINT64 *) Ptr;
-
- //
- // Write the function's entry point (which is our thunk code that follows
- // this descriptor we're creating).
- //
- *Data64Ptr = (UINT64) (Data64Ptr + 2);
- //
- // Get the gp from the descriptor for EbcInterpret and stuff it in our thunk
- // descriptor.
- //
- *(Data64Ptr + 1) = *(UINT64 *) ((UINT64 *) (UINTN) EbcInterpret + 1);
- //
- // Advance our thunk data pointer past the descriptor. Since the
- // descriptor consists of 16 bytes, the pointer is still aligned for
- // IPF code execution (on 16-byte boundary).
- //
- Ptr += sizeof (UINT64) * 2;
-
- //
- // *************************** MAGIC BUNDLE ********************************
- //
- // Write magic code bundle for: movl r8 = 0xca112ebcca112ebc to help the VM
- // to recognize it is a thunk.
- //
- Addr = (UINT64) 0xCA112EBCCA112EBC;
-
- //
- // Now generate the code bytes. First is nop.m 0x0
- //
- Code[0] = OPCODE_NOP;
-
- //
- // Next is simply Addr[62:22] (41 bits) of the address
- //
- Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
-
- //
- // Extract bits from the address for insertion into the instruction
- // i = Addr[63:63]
- //
- BitI = RShiftU64 (Addr, 63) & 0x01;
- //
- // ic = Addr[21:21]
- //
- BitIc = RShiftU64 (Addr, 21) & 0x01;
- //
- // imm5c = Addr[20:16] for 5 bits
- //
- BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
- //
- // imm9d = Addr[15:7] for 9 bits
- //
- BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
- //
- // imm7b = Addr[6:0] for 7 bits
- //
- BitImm7b = Addr & 0x7F;
-
- //
- // The EBC entry point will be put into r8, so r8 can be used here
- // temporary. R8 is general register and is auto-serialized.
- //
- RegNum = 8;
-
- //
- // Next is jumbled data, including opcode and rest of address
- //
- Code[2] = LShiftU64 (BitImm7b, 13);
- Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
- Code[2] = Code[2] | LShiftU64 (BitIc, 21);
- Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
- Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
- Code[2] = Code[2] | LShiftU64 (BitI, 36);
- Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
- Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
-
- WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
-
- //
- // *************************** FIRST BUNDLE ********************************
- //
- // Write code bundle for: movl r8 = EBC_ENTRY_POINT so we pass
- // the ebc entry point in to the interpreter function via a processor
- // register.
- // Note -- we could easily change this to pass in a pointer to a structure
- // that contained, among other things, the EBC image's entry point. But
- // for now pass it directly.
- //
- Ptr += 16;
- Addr = (UINT64) EbcEntryPoint;
-
- //
- // Now generate the code bytes. First is nop.m 0x0
- //
- Code[0] = OPCODE_NOP;
-
- //
- // Next is simply Addr[62:22] (41 bits) of the address
- //
- Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
-
- //
- // Extract bits from the address for insertion into the instruction
- // i = Addr[63:63]
- //
- BitI = RShiftU64 (Addr, 63) & 0x01;
- //
- // ic = Addr[21:21]
- //
- BitIc = RShiftU64 (Addr, 21) & 0x01;
- //
- // imm5c = Addr[20:16] for 5 bits
- //
- BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
- //
- // imm9d = Addr[15:7] for 9 bits
- //
- BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
- //
- // imm7b = Addr[6:0] for 7 bits
- //
- BitImm7b = Addr & 0x7F;
-
- //
- // Put the EBC entry point in r8, which is the location of the return value
- // for functions.
- //
- RegNum = 8;
-
- //
- // Next is jumbled data, including opcode and rest of address
- //
- Code[2] = LShiftU64 (BitImm7b, 13);
- Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
- Code[2] = Code[2] | LShiftU64 (BitIc, 21);
- Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
- Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
- Code[2] = Code[2] | LShiftU64 (BitI, 36);
- Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
- Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
-
- WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
-
- //
- // *************************** NEXT BUNDLE *********************************
- //
- // Write code bundle for:
- // movl rx = offset_of(EbcInterpret|ExecuteEbcImageEntryPoint)
- //
- // Advance pointer to next bundle, then compute the offset from this bundle
- // to the address of the entry point of the interpreter.
- //
- Ptr += 16;
- if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
- Addr = (UINT64) ExecuteEbcImageEntryPoint;
- } else {
- Addr = (UINT64) EbcInterpret;
- }
- //
- // Indirection on Itanium-based systems
- //
- Addr = *(UINT64 *) Addr;
-
- //
- // Now write the code to load the offset into a register
- //
- Code[0] = OPCODE_NOP;
-
- //
- // Next is simply Addr[62:22] (41 bits) of the address
- //
- Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
-
- //
- // Extract bits from the address for insertion into the instruction
- // i = Addr[63:63]
- //
- BitI = RShiftU64 (Addr, 63) & 0x01;
- //
- // ic = Addr[21:21]
- //
- BitIc = RShiftU64 (Addr, 21) & 0x01;
- //
- // imm5c = Addr[20:16] for 5 bits
- //
- BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
- //
- // imm9d = Addr[15:7] for 9 bits
- //
- BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
- //
- // imm7b = Addr[6:0] for 7 bits
- //
- BitImm7b = Addr & 0x7F;
-
- //
- // Put it in r31, a scratch register
- //
- RegNum = 31;
-
- //
- // Next is jumbled data, including opcode and rest of address
- //
- Code[2] = LShiftU64(BitImm7b, 13);
- Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
- Code[2] = Code[2] | LShiftU64 (BitIc, 21);
- Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
- Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
- Code[2] = Code[2] | LShiftU64 (BitI, 36);
- Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
- Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
-
- WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
-
- //
- // *************************** NEXT BUNDLE *********************************
- //
- // Load branch register with EbcInterpret() function offset from the bundle
- // address: mov b6 = RegNum
- //
- // See volume 3 page 4-29 of the Arch. Software Developer's Manual.
- //
- // Advance pointer to next bundle
- //
- Ptr += 16;
- Code[0] = OPCODE_NOP;
- Code[1] = OPCODE_NOP;
- Code[2] = OPCODE_MOV_BX_RX;
-
- //
- // Pick a branch register to use. Then fill in the bits for the branch
- // register and user register (same user register as previous bundle).
- //
- Br = 6;
- Code[2] |= LShiftU64 (Br, 6);
- Code[2] |= LShiftU64 (RegNum, 13);
- WriteBundle ((VOID *) Ptr, 0x0d, Code[0], Code[1], Code[2]);
-
- //
- // *************************** NEXT BUNDLE *********************************
- //
- // Now do the branch: (p0) br.cond.sptk.few b6
- //
- // Advance pointer to next bundle.
- // Fill in the bits for the branch register (same reg as previous bundle)
- //
- Ptr += 16;
- Code[0] = OPCODE_NOP;
- Code[1] = OPCODE_NOP;
- Code[2] = OPCODE_BR_COND_SPTK_FEW;
- Code[2] |= LShiftU64 (Br, 13);
- WriteBundle ((VOID *) Ptr, 0x1d, Code[0], Code[1], Code[2]);
-
- //
- // Add the thunk to our list of allocated thunks so we can do some cleanup
- // when the image is unloaded. Do this last since the Add function flushes
- // the instruction cache for us.
- //
- EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
-
- //
- // Done
- //
- return EFI_SUCCESS;
-}
-
-
-/**
- Given raw bytes of Itanium based code, format them into a bundle and
- write them out.
-
- @param MemPtr pointer to memory location to write the bundles
- to.
- @param Template 5-bit template.
- @param Slot0 Instruction slot 0 data for the bundle.
- @param Slot1 Instruction slot 1 data for the bundle.
- @param Slot2 Instruction slot 2 data for the bundle.
-
- @retval EFI_INVALID_PARAMETER Pointer is not aligned
- @retval EFI_INVALID_PARAMETER No more than 5 bits in template
- @retval EFI_INVALID_PARAMETER More than 41 bits used in code
- @retval EFI_SUCCESS All data is written.
-
-**/
-EFI_STATUS
-WriteBundle (
- IN VOID *MemPtr,
- IN UINT8 Template,
- IN UINT64 Slot0,
- IN UINT64 Slot1,
- IN UINT64 Slot2
- )
-{
- UINT8 *BPtr;
- UINT32 Index;
- UINT64 Low64;
- UINT64 High64;
-
- //
- // Verify pointer is aligned
- //
- if ((UINT64) MemPtr & 0xF) {
- return EFI_INVALID_PARAMETER;
- }
- //
- // Verify no more than 5 bits in template
- //
- if ((Template &~0x1F) != 0) {
- return EFI_INVALID_PARAMETER;
- }
- //
- // Verify max of 41 bits used in code
- //
- if (((Slot0 | Slot1 | Slot2) &~0x1ffffffffff) != 0) {
- return EFI_INVALID_PARAMETER;
- }
-
- Low64 = LShiftU64 (Slot1, 46);
- Low64 = Low64 | LShiftU64 (Slot0, 5) | Template;
-
- High64 = RShiftU64 (Slot1, 18);
- High64 = High64 | LShiftU64 (Slot2, 23);
-
- //
- // Now write it all out
- //
- BPtr = (UINT8 *) MemPtr;
- for (Index = 0; Index < 8; Index++) {
- *BPtr = (UINT8) Low64;
- Low64 = RShiftU64 (Low64, 8);
- BPtr++;
- }
-
- for (Index = 0; Index < 8; Index++) {
- *BPtr = (UINT8) High64;
- High64 = RShiftU64 (High64, 8);
- BPtr++;
- }
-
- return EFI_SUCCESS;
-}
-
-
-/**
- This function is called to execute an EBC CALLEX instruction.
- The function check the callee's content to see whether it is common native
- code or a thunk to another piece of EBC code.
- If the callee is common native code, use EbcLLCAllEXASM to manipulate,
- otherwise, set the VM->IP to target EBC code directly to avoid another VM
- be startup which cost time and stack space.
-
- @param VmPtr Pointer to a VM context.
- @param FuncAddr Callee's address
- @param NewStackPointer New stack pointer after the call
- @param FramePtr New frame pointer after the call
- @param Size The size of call instruction
-
-**/
-VOID
-EbcLLCALLEX (
- IN VM_CONTEXT *VmPtr,
- IN UINTN FuncAddr,
- IN UINTN NewStackPointer,
- IN VOID *FramePtr,
- IN UINT8 Size
- )
-{
- UINTN IsThunk;
- UINTN TargetEbcAddr;
- UINTN CodeOne18;
- UINTN CodeOne23;
- UINTN CodeTwoI;
- UINTN CodeTwoIc;
- UINTN CodeTwo7b;
- UINTN CodeTwo5c;
- UINTN CodeTwo9d;
- UINTN CalleeAddr;
-
- IsThunk = 1;
- TargetEbcAddr = 0;
-
- //
- // FuncAddr points to the descriptor of the target instructions.
- //
- CalleeAddr = *((UINT64 *)FuncAddr);
-
- //
- // Processor specific code to check whether the callee is a thunk to EBC.
- //
- if (*((UINT64 *)CalleeAddr) != 0xBCCA000100000005) {
- IsThunk = 0;
- goto Action;
- }
- if (*((UINT64 *)CalleeAddr + 1) != 0x697623C1004A112E) {
- IsThunk = 0;
- goto Action;
- }
-
- CodeOne18 = RShiftU64 (*((UINT64 *)CalleeAddr + 2), 46) & 0x3FFFF;
- CodeOne23 = (*((UINT64 *)CalleeAddr + 3)) & 0x7FFFFF;
- CodeTwoI = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 59) & 0x1;
- CodeTwoIc = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 44) & 0x1;
- CodeTwo7b = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 36) & 0x7F;
- CodeTwo5c = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 45) & 0x1F;
- CodeTwo9d = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 50) & 0x1FF;
-
- TargetEbcAddr = CodeTwo7b;
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo9d, 7);
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo5c, 16);
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoIc, 21);
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne18, 22);
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne23, 40);
- TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoI, 63);
-
-Action:
- if (IsThunk == 1){
- //
- // The callee is a thunk to EBC, adjust the stack pointer down 16 bytes and
- // put our return address and frame pointer on the VM stack.
- // Then set the VM's IP to new EBC code.
- //
- VmPtr->Gpr[0] -= 8;
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
- VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
- VmPtr->Gpr[0] -= 8;
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (VmPtr->Ip + Size));
-
- VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
- } else {
- //
- // The callee is not a thunk to EBC, call native code,
- // and get return value.
- //
- VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
-
- //
- // Advance the IP.
- //
- VmPtr->Ip += Size;
- }
-}
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h deleted file mode 100644 index d90ea82ad0..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h +++ /dev/null @@ -1,41 +0,0 @@ -/** @file
- Definition of EBC Support function.
-
-Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#ifndef _IPF_EBC_SUPPORT_H_
-#define _IPF_EBC_SUPPORT_H_
-
-#define VM_STACK_SIZE (1024 * 32)
-
-#define EBC_THUNK_SIZE 128
-#define STACK_REMAIN_SIZE (1024 * 4)
-
-//
-// For code execution, thunks must be aligned on 16-byte boundary
-//
-#define EBC_THUNK_ALIGNMENT 16
-
-//
-// Opcodes for IPF instructions. We'll need to hand-create thunk code (stuffing
-// bits) to insert a jump to the interpreter.
-//
-#define OPCODE_NOP (UINT64) 0x00008000000
-#define OPCODE_BR_COND_SPTK_FEW (UINT64) 0x00100000000
-#define OPCODE_MOV_BX_RX (UINT64) 0x00E00100000
-
-//
-// Opcode for MOVL instruction
-//
-#define MOVL_OPCODE 0x06
-
-#endif
diff --git a/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S b/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S deleted file mode 100644 index b01486a871..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S +++ /dev/null @@ -1,147 +0,0 @@ -#/** @file
-#
-# This code provides low level routines that support the Virtual Machine
-# for option ROMs.
-#
-# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
-# 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.
-#
-#**/
-
-#---------------------------------------------------------------------------
-# Equate files needed.
-#---------------------------------------------------------------------------
-
-ASM_GLOBAL ASM_PFX(CopyMem);
-ASM_GLOBAL ASM_PFX(EbcInterpret);
-ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint);
-
-#****************************************************************************
-# EbcLLCALLEX
-#
-# This function is called to execute an EBC CALLEX instruction.
-# This instruction requires that we thunk out to external native
-# code. For x64, we switch stacks, copy the arguments to the stack
-# and jump to the specified function.
-# On return, we restore the stack pointer to its original location.
-#
-# Destroys no working registers.
-#****************************************************************************
-# VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
-ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
-ASM_PFX(EbcLLCALLEXNative):
- push %rbp
- push %rbx
- mov %rsp, %rbp
- # Function prolog
-
- # Copy FuncAddr to a preserved register.
- mov %rcx, %rbx
-
- # Set stack pointer to new value
- sub %rdx, %r8
-
- #
- # Fix X64 native function call prolog. Prepare space for at least 4 arguments,
- # even if the native function's arguments are less than 4.
- #
- # From MSDN x64 Software Conventions, Overview of x64 Calling Conventions:
- # "The caller is responsible for allocating space for parameters to the
- # callee, and must always allocate sufficient space for the 4 register
- # parameters, even if the callee doesn't have that many parameters.
- # This aids in the simplicity of supporting C unprototyped functions,
- # and vararg C/C++ functions."
- #
- cmp $0x20, %r8
- jae skip_expansion
- mov $0x20, %r8
-skip_expansion:
-
- sub %r8, %rsp
-
- #
- # Fix X64 native function call 16-byte alignment.
- #
- # From MSDN x64 Software Conventions, Stack Usage:
- # "The stack will always be maintained 16-byte aligned, except within
- # the prolog (for example, after the return address is pushed)."
- #
- and $0xFFFFFFFFFFFFFFF0, %rsp
-
- mov %rsp, %rcx
- sub $0x20, %rsp
- call ASM_PFX(CopyMem)
- add $0x20, %rsp
-
- # Considering the worst case, load 4 potiential arguments
- # into registers.
- mov (%rsp), %rcx
- mov 0x8(%rsp), %rdx
- mov 0x10(%rsp), %r8
- mov 0x18(%rsp), %r9
-
- # Now call the external routine
- call *%rbx
-
- # Function epilog
- mov %rbp, %rsp
- pop %rbx
- pop %rbp
- ret
-
-ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);
-ASM_PFX(EbcLLEbcInterpret):
- # save old parameter to stack
- mov %rcx, 0x8(%rsp)
- mov %rdx, 0x10(%rsp)
- mov %r8, 0x18(%rsp)
- mov %r9, 0x20(%rsp)
-
- # Construct new stack
- push %rbp
- mov %rsp, %rbp
- push %rsi
- push %rdi
- push %rbx
- sub $0x80, %rsp
- push %r10
- mov %rbp, %rsi
- add $0x10, %rsi
- mov %rsp, %rdi
- add $0x8, %rdi
- mov $0x10, %rcx
- rep movsq
-
- # build new paramater calling convention
- mov 0x18(%rsp), %r9
- mov 0x10(%rsp), %r8
- mov 0x8(%rsp), %rdx
- mov %r10, %rcx
-
- # call C-code
- call ASM_PFX(EbcInterpret)
- add $0x88, %esp
- pop %rbx
- pop %rdi
- pop %rsi
- pop %rbp
- ret
-
-ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);
-ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
- # build new paramater calling convention
- mov %rdx, %r8
- mov %rcx, %rdx
- mov %r10, %rcx
-
- # call C-code
- sub $0x28, %rsp
- call ASM_PFX(ExecuteEbcImageEntryPoint)
- add $0x28, %rsp
- ret
diff --git a/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.asm b/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.asm deleted file mode 100644 index 1fbd165be7..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.asm +++ /dev/null @@ -1,246 +0,0 @@ -;/** @file
-;
-; This code provides low level routines that support the Virtual Machine.
-; for option ROMs.
-;
-; Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-; Copyright (c) 2014 Hewlett-Packard Development Company, L.P.<BR>
-; 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.
-;
-;**/
-
- page ,132
- title VM ASSEMBLY LANGUAGE ROUTINES
-
-;---------------------------------------------------------------------------
-; Equate files needed.
-;---------------------------------------------------------------------------
-
-.CODE
-
-CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD
-EbcInterpret PROTO
-ExecuteEbcImageEntryPoint PROTO
-
-;****************************************************************************
-; EbcLLCALLEX
-;
-; This function is called to execute an EBC CALLEX instruction.
-; This instruction requires that we thunk out to external native
-; code. For x64, we switch stacks, copy the arguments to the stack
-; and jump to the specified function.
-; On return, we restore the stack pointer to its original location.
-;
-; Destroys no working registers.
-;****************************************************************************
-; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
-EbcLLCALLEXNative PROC PUBLIC
- push rbp
- push rbx
- mov rbp, rsp
- ; Function prolog
-
- ; Copy FuncAddr to a preserved register.
- mov rbx, rcx
-
- ; Set stack pointer to new value
- sub r8, rdx
-
- ;
- ; Fix X64 native function call prolog. Prepare space for at least 4 arguments,
- ; even if the native function's arguments are less than 4.
- ;
- ; From MSDN x64 Software Conventions, Overview of x64 Calling Conventions:
- ; "The caller is responsible for allocating space for parameters to the
- ; callee, and must always allocate sufficient space for the 4 register
- ; parameters, even if the callee doesn't have that many parameters.
- ; This aids in the simplicity of supporting C unprototyped functions,
- ; and vararg C/C++ functions."
- ;
- cmp r8, 20h
- jae skip_expansion
- mov r8, 20h
-skip_expansion:
-
- sub rsp, r8
-
- ;
- ; Fix X64 native function call 16-byte alignment.
- ;
- ; From MSDN x64 Software Conventions, Stack Usage:
- ; "The stack will always be maintained 16-byte aligned, except within
- ; the prolog (for example, after the return address is pushed)."
- ;
- and rsp, NOT 0fh
-
- mov rcx, rsp
- sub rsp, 20h
- call CopyMem
- add rsp, 20h
-
- ; Considering the worst case, load 4 potiential arguments
- ; into registers.
- mov rcx, qword ptr [rsp]
- mov rdx, qword ptr [rsp+8h]
- mov r8, qword ptr [rsp+10h]
- mov r9, qword ptr [rsp+18h]
-
- ; Now call the external routine
- call rbx
-
- ; Function epilog
- mov rsp, rbp
- pop rbx
- pop rbp
- ret
-EbcLLCALLEXNative ENDP
-
-;****************************************************************************
-; EbcLLEbcInterpret
-;
-; Begin executing an EBC image.
-;****************************************************************************
-; UINT64 EbcLLEbcInterpret(VOID)
-EbcLLEbcInterpret PROC PUBLIC
- ;
- ;; mov rax, ca112ebccall2ebch
- ;; mov r10, EbcEntryPoint
- ;; mov r11, EbcLLEbcInterpret
- ;; jmp r11
- ;
- ; Caller uses above instruction to jump here
- ; The stack is below:
- ; +-----------+
- ; | RetAddr |
- ; +-----------+
- ; |EntryPoint | (R10)
- ; +-----------+
- ; | Arg1 | <- RDI
- ; +-----------+
- ; | Arg2 |
- ; +-----------+
- ; | ... |
- ; +-----------+
- ; | Arg16 |
- ; +-----------+
- ; | Dummy |
- ; +-----------+
- ; | RDI |
- ; +-----------+
- ; | RSI |
- ; +-----------+
- ; | RBP | <- RBP
- ; +-----------+
- ; | RetAddr | <- RSP is here
- ; +-----------+
- ; | Scratch1 | (RCX) <- RSI
- ; +-----------+
- ; | Scratch2 | (RDX)
- ; +-----------+
- ; | Scratch3 | (R8)
- ; +-----------+
- ; | Scratch4 | (R9)
- ; +-----------+
- ; | Arg5 |
- ; +-----------+
- ; | Arg6 |
- ; +-----------+
- ; | ... |
- ; +-----------+
- ; | Arg16 |
- ; +-----------+
- ;
-
- ; save old parameter to stack
- mov [rsp + 08h], rcx
- mov [rsp + 10h], rdx
- mov [rsp + 18h], r8
- mov [rsp + 20h], r9
-
- ; Construct new stack
- push rbp
- mov rbp, rsp
- push rsi
- push rdi
- push rbx
- sub rsp, 80h
- push r10
- mov rsi, rbp
- add rsi, 10h
- mov rdi, rsp
- add rdi, 8
- mov rcx, 16
- rep movsq
-
- ; build new paramater calling convention
- mov r9, [rsp + 18h]
- mov r8, [rsp + 10h]
- mov rdx, [rsp + 08h]
- mov rcx, r10
-
- ; call C-code
- call EbcInterpret
- add rsp, 88h
- pop rbx
- pop rdi
- pop rsi
- pop rbp
- ret
-EbcLLEbcInterpret ENDP
-
-;****************************************************************************
-; EbcLLExecuteEbcImageEntryPoint
-;
-; Begin executing an EBC image.
-;****************************************************************************
-; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)
-EbcLLExecuteEbcImageEntryPoint PROC PUBLIC
- ;
- ;; mov rax, ca112ebccall2ebch
- ;; mov r10, EbcEntryPoint
- ;; mov r11, EbcLLExecuteEbcImageEntryPoint
- ;; jmp r11
- ;
- ; Caller uses above instruction to jump here
- ; The stack is below:
- ; +-----------+
- ; | RetAddr |
- ; +-----------+
- ; |EntryPoint | (R10)
- ; +-----------+
- ; |ImageHandle|
- ; +-----------+
- ; |SystemTable|
- ; +-----------+
- ; | Dummy |
- ; +-----------+
- ; | Dummy |
- ; +-----------+
- ; | RetAddr | <- RSP is here
- ; +-----------+
- ; |ImageHandle| (RCX)
- ; +-----------+
- ; |SystemTable| (RDX)
- ; +-----------+
- ;
-
- ; build new paramater calling convention
- mov r8, rdx
- mov rdx, rcx
- mov rcx, r10
-
- ; call C-code
- sub rsp, 28h
- call ExecuteEbcImageEntryPoint
- add rsp, 28h
- ret
-EbcLLExecuteEbcImageEntryPoint ENDP
-
-END
-
diff --git a/MdeModulePkg/Universal/EbcDxe/X64/EbcSupport.c b/MdeModulePkg/Universal/EbcDxe/X64/EbcSupport.c deleted file mode 100644 index bdde5e41fa..0000000000 --- a/MdeModulePkg/Universal/EbcDxe/X64/EbcSupport.c +++ /dev/null @@ -1,573 +0,0 @@ -/** @file
- This module contains EBC support routines that are customized based on
- the target x64 processor.
-
-Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
-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.
-
-**/
-
-#include "EbcInt.h"
-#include "EbcExecute.h"
-
-//
-// NOTE: This is the stack size allocated for the interpreter
-// when it executes an EBC image. The requirements can change
-// based on whether or not a debugger is present, and other
-// platform-specific configurations.
-//
-#define VM_STACK_SIZE (1024 * 8)
-
-#define STACK_REMAIN_SIZE (1024 * 4)
-
-//
-// This is instruction buffer used to create EBC thunk
-//
-#define EBC_ENTRYPOINT_SIGNATURE 0xAFAFAFAFAFAFAFAFull
-#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE 0xFAFAFAFAFAFAFAFAull
-UINT8 mInstructionBufferTemplate[] = {
- //
- // Add a magic code here to help the VM recognize the thunk..
- // mov rax, 0xca112ebcca112ebc => 48 B8 BC 2E 11 CA BC 2E 11 CA
- //
- 0x48, 0xB8, 0xBC, 0x2E, 0x11, 0xCA, 0xBC, 0x2E, 0x11, 0xCA,
- //
- // Add code bytes to load up a processor register with the EBC entry point.
- // mov r10, EbcEntryPoint => 49 BA XX XX XX XX XX XX XX XX (To be fixed at runtime)
- // These 8 bytes of the thunk entry is the address of the EBC
- // entry point.
- //
- 0x49, 0xBA,
- (UINT8)(EBC_ENTRYPOINT_SIGNATURE & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
- (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
- //
- // Stick in a load of r11 with the address of appropriate VM function.
- // mov r11, EbcLLEbcInterpret => 49 BB XX XX XX XX XX XX XX XX (To be fixed at runtime)
- //
- 0x49, 0xBB,
- (UINT8)(EBC_LL_EBC_ENTRYPOINT_SIGNATURE & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
- (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
- //
- // Stick in jump opcode bytes
- // jmp r11 => 41 FF E3
- //
- 0x41, 0xFF, 0xE3,
-};
-
-/**
- Begin executing an EBC image.
- This is used for Ebc Thunk call.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcLLEbcInterpret (
- VOID
- );
-
-/**
- Begin executing an EBC image.
- This is used for Ebc image entrypoint.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcLLExecuteEbcImageEntryPoint (
- VOID
- );
-
-/**
- Pushes a 64 bit unsigned value to the VM stack.
-
- @param VmPtr The pointer to current VM context.
- @param Arg The value to be pushed.
-
-**/
-VOID
-PushU64 (
- IN VM_CONTEXT *VmPtr,
- IN UINT64 Arg
- )
-{
- //
- // Advance the VM stack down, and then copy the argument to the stack.
- // Hope it's aligned.
- //
- VmPtr->Gpr[0] -= sizeof (UINT64);
- *(UINT64 *) VmPtr->Gpr[0] = Arg;
- return;
-}
-
-
-/**
- Begin executing an EBC image.
-
- This is a thunk function. Microsoft x64 compiler only provide fast_call
- calling convention, so the first four arguments are passed by rcx, rdx,
- r8, and r9, while other arguments are passed in stack.
-
- @param EntryPoint The entrypoint of EBC code.
- @param Arg1 The 1st argument.
- @param Arg2 The 2nd argument.
- @param Arg3 The 3rd argument.
- @param Arg4 The 4th argument.
- @param Arg5 The 5th argument.
- @param Arg6 The 6th argument.
- @param Arg7 The 7th argument.
- @param Arg8 The 8th argument.
- @param Arg9 The 9th argument.
- @param Arg10 The 10th argument.
- @param Arg11 The 11th argument.
- @param Arg12 The 12th argument.
- @param Arg13 The 13th argument.
- @param Arg14 The 14th argument.
- @param Arg15 The 15th argument.
- @param Arg16 The 16th argument.
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-EbcInterpret (
- IN UINTN EntryPoint,
- IN UINTN Arg1,
- IN UINTN Arg2,
- IN UINTN Arg3,
- IN UINTN Arg4,
- IN UINTN Arg5,
- IN UINTN Arg6,
- IN UINTN Arg7,
- IN UINTN Arg8,
- IN UINTN Arg9,
- IN UINTN Arg10,
- IN UINTN Arg11,
- IN UINTN Arg12,
- IN UINTN Arg13,
- IN UINTN Arg14,
- IN UINTN Arg15,
- IN UINTN Arg16
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
-
- //
- // Get the EBC entry point
- //
- Addr = EntryPoint;
-
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
-
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
-
- //
- // Initialize the stack pointer for the EBC. Get the current system stack
- // pointer and adjust it down by the max needed for the interpreter.
- //
-
- //
- // Adjust the VM's stack pointer down.
- //
-
- Status = GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
-
- //
- // Align the stack on a natural boundary.
- //
- VmContext.Gpr[0] &= ~(VM_REGISTER)(sizeof (UINTN) - 1);
-
- //
- // Put a magic value in the stack gap, then adjust down again.
- //
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
- VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
-
- //
- // The stack upper to LowStackTop is belong to the VM.
- //
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
-
- //
- // For the worst case, assume there are 4 arguments passed in registers, store
- // them to VM's stack.
- //
- PushU64 (&VmContext, (UINT64) Arg16);
- PushU64 (&VmContext, (UINT64) Arg15);
- PushU64 (&VmContext, (UINT64) Arg14);
- PushU64 (&VmContext, (UINT64) Arg13);
- PushU64 (&VmContext, (UINT64) Arg12);
- PushU64 (&VmContext, (UINT64) Arg11);
- PushU64 (&VmContext, (UINT64) Arg10);
- PushU64 (&VmContext, (UINT64) Arg9);
- PushU64 (&VmContext, (UINT64) Arg8);
- PushU64 (&VmContext, (UINT64) Arg7);
- PushU64 (&VmContext, (UINT64) Arg6);
- PushU64 (&VmContext, (UINT64) Arg5);
- PushU64 (&VmContext, (UINT64) Arg4);
- PushU64 (&VmContext, (UINT64) Arg3);
- PushU64 (&VmContext, (UINT64) Arg2);
- PushU64 (&VmContext, (UINT64) Arg1);
-
- //
- // Interpreter assumes 64-bit return address is pushed on the stack.
- // The x64 does not do this so pad the stack accordingly.
- //
- PushU64 (&VmContext, (UINT64) 0);
- PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
-
- //
- // For x64, this is where we say our return address is
- //
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
-
- //
- // We need to keep track of where the EBC stack starts. This way, if the EBC
- // accesses any stack variables above its initial stack setting, then we know
- // it's accessing variables passed into it, which means the data is on the
- // VM's stack.
- // When we're called, on the stack (high to low) we have the parameters, the
- // return address, then the saved ebp. Save the pointer to the return address.
- // EBC code knows that's there, so should look above it for function parameters.
- // The offset is the size of locals (VMContext + Addr + saved ebp).
- // Note that the interpreter assumes there is a 16 bytes of return address on
- // the stack too, so adjust accordingly.
- // VmContext.HighStackBottom = (UINTN)(Addr + sizeof (VmContext) + sizeof (Addr));
- //
-
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
-
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Begin executing an EBC image.
-
- @param EntryPoint The entrypoint of EBC code.
- @param ImageHandle image handle for the EBC application we're executing
- @param SystemTable standard system table passed into an driver's entry
- point
-
- @return The value returned by the EBC application we're going to run.
-
-**/
-UINT64
-EFIAPI
-ExecuteEbcImageEntryPoint (
- IN UINTN EntryPoint,
- IN EFI_HANDLE ImageHandle,
- IN EFI_SYSTEM_TABLE *SystemTable
- )
-{
- //
- // Create a new VM context on the stack
- //
- VM_CONTEXT VmContext;
- UINTN Addr;
- EFI_STATUS Status;
- UINTN StackIndex;
-
- //
- // Get the EBC entry point
- //
- Addr = EntryPoint;
-
- //
- // Now clear out our context
- //
- ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
-
- //
- // Save the image handle so we can track the thunks created for this image
- //
- VmContext.ImageHandle = ImageHandle;
- VmContext.SystemTable = SystemTable;
-
- //
- // Set the VM instruction pointer to the correct location in memory.
- //
- VmContext.Ip = (VMIP) Addr;
-
- //
- // Initialize the stack pointer for the EBC. Get the current system stack
- // pointer and adjust it down by the max needed for the interpreter.
- //
-
- Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
- if (EFI_ERROR(Status)) {
- return Status;
- }
- VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
- VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
- VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
- VmContext.Gpr[0] -= sizeof (UINTN);
-
-
- //
- // Put a magic value in the stack gap, then adjust down again
- //
- *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
- VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
-
- //
- // Align the stack on a natural boundary
- VmContext.Gpr[0] &= ~(VM_REGISTER)(sizeof(UINTN) - 1);
- //
- VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
-
- //
- // Simply copy the image handle and system table onto the EBC stack.
- // Greatly simplifies things by not having to spill the args.
- //
- PushU64 (&VmContext, (UINT64) SystemTable);
- PushU64 (&VmContext, (UINT64) ImageHandle);
-
- //
- // VM pushes 16-bytes for return address. Simulate that here.
- //
- PushU64 (&VmContext, (UINT64) 0);
- PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
-
- //
- // For x64, this is where we say our return address is
- //
- VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
-
- //
- // Entry function needn't access high stack context, simply
- // put the stack pointer here.
- //
-
- //
- // Begin executing the EBC code
- //
- EbcExecute (&VmContext);
-
- //
- // Return the value in R[7] unless there was an error
- //
- ReturnEBCStack(StackIndex);
- return (UINT64) VmContext.Gpr[7];
-}
-
-
-/**
- Create thunks for an EBC image entry point, or an EBC protocol service.
-
- @param ImageHandle Image handle for the EBC image. If not null, then
- we're creating a thunk for an image entry point.
- @param EbcEntryPoint Address of the EBC code that the thunk is to call
- @param Thunk Returned thunk we create here
- @param Flags Flags indicating options for creating the thunk
-
- @retval EFI_SUCCESS The thunk was created successfully.
- @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not 16-bit
- aligned.
- @retval EFI_OUT_OF_RESOURCES There is not enough memory to created the EBC
- Thunk.
- @retval EFI_BUFFER_TOO_SMALL EBC_THUNK_SIZE is not larger enough.
-
-**/
-EFI_STATUS
-EbcCreateThunks (
- IN EFI_HANDLE ImageHandle,
- IN VOID *EbcEntryPoint,
- OUT VOID **Thunk,
- IN UINT32 Flags
- )
-{
- UINT8 *Ptr;
- UINT8 *ThunkBase;
- UINT32 Index;
- INT32 ThunkSize;
-
- //
- // Check alignment of pointer to EBC code
- //
- if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
- return EFI_INVALID_PARAMETER;
- }
-
- ThunkSize = sizeof(mInstructionBufferTemplate);
-
- Ptr = AllocatePool (sizeof(mInstructionBufferTemplate));
-
- if (Ptr == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
- //
- // Print(L"Allocate TH: 0x%X\n", (UINT32)Ptr);
- //
- // Save the start address so we can add a pointer to it to a list later.
- //
- ThunkBase = Ptr;
-
- //
- // Give them the address of our buffer we're going to fix up
- //
- *Thunk = (VOID *) Ptr;
-
- //
- // Copy whole thunk instruction buffer template
- //
- CopyMem (Ptr, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate));
-
- //
- // Patch EbcEntryPoint and EbcLLEbcInterpret
- //
- for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
- if (*(UINTN *)&Ptr[Index] == EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcEntryPoint;
- }
- if (*(UINTN *)&Ptr[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
- if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcLLExecuteEbcImageEntryPoint;
- } else {
- *(UINTN *)&Ptr[Index] = (UINTN)EbcLLEbcInterpret;
- }
- }
- }
-
- //
- // Add the thunk to the list for this image. Do this last since the add
- // function flushes the cache for us.
- //
- EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
-
- return EFI_SUCCESS;
-}
-
-
-/**
- This function is called to execute an EBC CALLEX instruction.
- The function check the callee's content to see whether it is common native
- code or a thunk to another piece of EBC code.
- If the callee is common native code, use EbcLLCAllEXASM to manipulate,
- otherwise, set the VM->IP to target EBC code directly to avoid another VM
- be startup which cost time and stack space.
-
- @param VmPtr Pointer to a VM context.
- @param FuncAddr Callee's address
- @param NewStackPointer New stack pointer after the call
- @param FramePtr New frame pointer after the call
- @param Size The size of call instruction
-
-**/
-VOID
-EbcLLCALLEX (
- IN VM_CONTEXT *VmPtr,
- IN UINTN FuncAddr,
- IN UINTN NewStackPointer,
- IN VOID *FramePtr,
- IN UINT8 Size
- )
-{
- UINTN IsThunk;
- UINTN TargetEbcAddr;
- UINT8 InstructionBuffer[sizeof(mInstructionBufferTemplate)];
- UINTN Index;
- UINTN IndexOfEbcEntrypoint;
-
- IsThunk = 1;
- TargetEbcAddr = 0;
- IndexOfEbcEntrypoint = 0;
-
- //
- // Processor specific code to check whether the callee is a thunk to EBC.
- //
- CopyMem (InstructionBuffer, (VOID *)FuncAddr, sizeof(InstructionBuffer));
- //
- // Fill the signature according to mInstructionBufferTemplate
- //
- for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
- if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&InstructionBuffer[Index] = EBC_ENTRYPOINT_SIGNATURE;
- IndexOfEbcEntrypoint = Index;
- }
- if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
- *(UINTN *)&InstructionBuffer[Index] = EBC_LL_EBC_ENTRYPOINT_SIGNATURE;
- }
- }
- //
- // Check if we need thunk to native
- //
- if (CompareMem (InstructionBuffer, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate)) != 0) {
- IsThunk = 0;
- }
-
- if (IsThunk == 1){
- //
- // The callee is a thunk to EBC, adjust the stack pointer down 16 bytes and
- // put our return address and frame pointer on the VM stack.
- // Then set the VM's IP to new EBC code.
- //
- VmPtr->Gpr[0] -= 8;
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
- VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
- VmPtr->Gpr[0] -= 8;
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));
-
- CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + IndexOfEbcEntrypoint, sizeof(UINTN));
- VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
- } else {
- //
- // The callee is not a thunk to EBC, call native code,
- // and get return value.
- //
- VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
-
- //
- // Advance the IP.
- //
- VmPtr->Ip += Size;
- }
-}
-
|