| ///** @file | |
| // | |
| // This code provides low level routines that support the Virtual Machine | |
| // for option ROMs. | |
| // | |
| // Copyright (c) 2016, Linaro, Ltd. All rights reserved.<BR> | |
| // Copyright (c) 2015, The Linux Foundation. All rights reserved.<BR> | |
| // Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR> | |
| // | |
| // SPDX-License-Identifier: BSD-2-Clause-Patent | |
| // | |
| //**/ | |
| ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative) | |
| ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret) | |
| ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint) | |
| ASM_GLOBAL ASM_PFX(mEbcInstructionBufferTemplate) | |
| //**************************************************************************** | |
| // EbcLLCALLEX | |
| // | |
| // This function is called to execute an EBC CALLEX instruction. | |
| // This instruction requires that we thunk out to external native | |
| // code. For AArch64, we copy the VM stack into the main stack and then pop | |
| // the first 8 arguments off according to the AArch64 Procedure Call Standard | |
| // On return, we restore the stack pointer to its original location. | |
| // | |
| //**************************************************************************** | |
| // UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) | |
| ASM_PFX(EbcLLCALLEXNative): | |
| mov x8, x0 // Preserve x0 | |
| mov x9, x1 // Preserve x1 | |
| // | |
| // If the EBC stack frame is smaller than or equal to 64 bytes, we know there | |
| // are no stacked arguments #9 and beyond that we need to copy to the native | |
| // stack. In this case, we can perform a tail call which is much more | |
| // efficient, since there is no need to touch the native stack at all. | |
| // | |
| sub x3, x2, x1 // Length = NewStackPointer - FramePtr | |
| cmp x3, #64 | |
| b.gt 1f | |
| // | |
| // While probably harmless in practice, we should not access the VM stack | |
| // outside of the interval [NewStackPointer, FramePtr), which means we | |
| // should not blindly fill all 8 argument registers with VM stack data. | |
| // So instead, calculate how many argument registers we can fill based on | |
| // the size of the VM stack frame, and skip the remaining ones. | |
| // | |
| adr x0, 0f // Take address of 'br' instruction below | |
| bic x3, x3, #7 // Ensure correct alignment | |
| sub x0, x0, x3, lsr #1 // Subtract 4 bytes for each arg to unstack | |
| br x0 // Skip remaining argument registers | |
| ldr x7, [x9, #56] // Call with 8 arguments | |
| ldr x6, [x9, #48] // | | |
| ldr x5, [x9, #40] // | | |
| ldr x4, [x9, #32] // | | |
| ldr x3, [x9, #24] // | | |
| ldr x2, [x9, #16] // | | |
| ldr x1, [x9, #8] // V | |
| ldr x0, [x9] // Call with 1 argument | |
| 0: br x8 // Call with no arguments | |
| // | |
| // More than 64 bytes: we need to build the full native stack frame and copy | |
| // the part of the VM stack exceeding 64 bytes (which may contain stacked | |
| // arguments) to the native stack | |
| // | |
| 1: stp x29, x30, [sp, #-16]! | |
| mov x29, sp | |
| // | |
| // Ensure that the stack pointer remains 16 byte aligned, | |
| // even if the size of the VM stack frame is not a multiple of 16 | |
| // | |
| add x1, x1, #64 // Skip over [potential] reg params | |
| tbz x3, #3, 2f // Multiple of 16? | |
| ldr x4, [x2, #-8]! // No? Then push one word | |
| str x4, [sp, #-16]! // ... but use two slots | |
| b 3f | |
| 2: ldp x4, x5, [x2, #-16]! | |
| stp x4, x5, [sp, #-16]! | |
| 3: cmp x2, x1 | |
| b.gt 2b | |
| ldp x0, x1, [x9] | |
| ldp x2, x3, [x9, #16] | |
| ldp x4, x5, [x9, #32] | |
| ldp x6, x7, [x9, #48] | |
| blr x8 | |
| mov sp, x29 | |
| ldp x29, x30, [sp], #16 | |
| ret | |
| //**************************************************************************** | |
| // EbcLLEbcInterpret | |
| // | |
| // This function is called by the thunk code to handle an Native to EBC call | |
| // This can handle up to 16 arguments (1-8 on in x0-x7, 9-16 are on the stack) | |
| // x16 contains the Entry point that will be the first stacked argument when | |
| // EBCInterpret is called. | |
| // | |
| //**************************************************************************** | |
| ASM_PFX(EbcLLEbcInterpret): | |
| stp x29, x30, [sp, #-16]! | |
| mov x29, sp | |
| // push the entry point and the address of args #9 - #16 onto the stack | |
| add x17, sp, #16 | |
| stp x16, x17, [sp, #-16]! | |
| // call C-code | |
| bl ASM_PFX(EbcInterpret) | |
| add sp, sp, #16 | |
| ldp x29, x30, [sp], #16 | |
| ret | |
| //**************************************************************************** | |
| // EbcLLExecuteEbcImageEntryPoint | |
| // | |
| // This function is called by the thunk code to handle the image entry point | |
| // x16 contains the Entry point that will be the third argument when | |
| // ExecuteEbcImageEntryPoint is called. | |
| // | |
| //**************************************************************************** | |
| ASM_PFX(EbcLLExecuteEbcImageEntryPoint): | |
| mov x2, x16 | |
| // tail call to C code | |
| b ASM_PFX(ExecuteEbcImageEntryPoint) | |
| //**************************************************************************** | |
| // mEbcInstructionBufferTemplate | |
| //**************************************************************************** | |
| .section ".rodata", "a" | |
| .align 3 | |
| ASM_PFX(mEbcInstructionBufferTemplate): | |
| adr x17, 0f | |
| ldp x16, x17, [x17] | |
| br x17 | |
| // | |
| // Add a magic code here to help the VM recognize the thunk. | |
| // | |
| hlt #0xEBC | |
| 0: .quad 0 // EBC_ENTRYPOINT_SIGNATURE | |
| .quad 0 // EBC_LL_EBC_ENTRYPOINT_SIGNATURE |