// Copyright (c) 2015, The Linux Foundation. All rights reserved.<BR>\r
// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
//\r
-// This program and the accompanying materials\r
-// are licensed and made available under the terms and conditions of the BSD License\r
-// which accompanies this distribution. The full text of the license may be found at\r
-// http://opensource.org/licenses/bsd-license.php\r
-//\r
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+// SPDX-License-Identifier: BSD-2-Clause-Patent\r
//\r
//**/\r
\r
//****************************************************************************\r
// UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)\r
ASM_PFX(EbcLLCALLEXNative):\r
- stp x19, x20, [sp, #-16]!\r
- stp x29, x30, [sp, #-16]!\r
-\r
- mov x19, x0\r
- mov x20, sp\r
- sub x2, x2, x1 // Length = NewStackPointer-FramePtr\r
- sub sp, sp, x2\r
- sub sp, sp, #64 // Make sure there is room for at least 8 args in the new stack\r
- mov x0, sp\r
+ mov x8, x0 // Preserve x0\r
+ mov x9, x1 // Preserve x1\r
\r
- bl CopyMem // Sp, NewStackPointer, Length\r
-\r
- ldp x0, x1, [sp], #16\r
- ldp x2, x3, [sp], #16\r
- ldp x4, x5, [sp], #16\r
- ldp x6, x7, [sp], #16\r
+ //\r
+ // If the EBC stack frame is smaller than or equal to 64 bytes, we know there\r
+ // are no stacked arguments #9 and beyond that we need to copy to the native\r
+ // stack. In this case, we can perform a tail call which is much more\r
+ // efficient, since there is no need to touch the native stack at all.\r
+ //\r
+ sub x3, x2, x1 // Length = NewStackPointer - FramePtr\r
+ cmp x3, #64\r
+ b.gt 1f\r
\r
- blr x19\r
+ //\r
+ // While probably harmless in practice, we should not access the VM stack\r
+ // outside of the interval [NewStackPointer, FramePtr), which means we\r
+ // should not blindly fill all 8 argument registers with VM stack data.\r
+ // So instead, calculate how many argument registers we can fill based on\r
+ // the size of the VM stack frame, and skip the remaining ones.\r
+ //\r
+ adr x0, 0f // Take address of 'br' instruction below\r
+ bic x3, x3, #7 // Ensure correct alignment\r
+ sub x0, x0, x3, lsr #1 // Subtract 4 bytes for each arg to unstack\r
+ br x0 // Skip remaining argument registers\r
+\r
+ ldr x7, [x9, #56] // Call with 8 arguments\r
+ ldr x6, [x9, #48] // |\r
+ ldr x5, [x9, #40] // |\r
+ ldr x4, [x9, #32] // |\r
+ ldr x3, [x9, #24] // |\r
+ ldr x2, [x9, #16] // |\r
+ ldr x1, [x9, #8] // V\r
+ ldr x0, [x9] // Call with 1 argument\r
+\r
+0: br x8 // Call with no arguments\r
\r
- mov sp, x20\r
- ldp x29, x30, [sp], #16\r
- ldp x19, x20, [sp], #16\r
+ //\r
+ // More than 64 bytes: we need to build the full native stack frame and copy\r
+ // the part of the VM stack exceeding 64 bytes (which may contain stacked\r
+ // arguments) to the native stack\r
+ //\r
+1: stp x29, x30, [sp, #-16]!\r
+ mov x29, sp\r
\r
- ret\r
+ //\r
+ // Ensure that the stack pointer remains 16 byte aligned,\r
+ // even if the size of the VM stack frame is not a multiple of 16\r
+ //\r
+ add x1, x1, #64 // Skip over [potential] reg params\r
+ tbz x3, #3, 2f // Multiple of 16?\r
+ ldr x4, [x2, #-8]! // No? Then push one word\r
+ str x4, [sp, #-16]! // ... but use two slots\r
+ b 3f\r
+\r
+2: ldp x4, x5, [x2, #-16]!\r
+ stp x4, x5, [sp, #-16]!\r
+3: cmp x2, x1\r
+ b.gt 2b\r
+\r
+ ldp x0, x1, [x9]\r
+ ldp x2, x3, [x9, #16]\r
+ ldp x4, x5, [x9, #32]\r
+ ldp x6, x7, [x9, #48]\r
+\r
+ blr x8\r
+\r
+ mov sp, x29\r
+ ldp x29, x30, [sp], #16\r
+ ret\r
\r
//****************************************************************************\r
// EbcLLEbcInterpret\r
//\r
// This function is called by the thunk code to handle an Native to EBC call\r
// This can handle up to 16 arguments (1-8 on in x0-x7, 9-16 are on the stack)\r
-// x16 contains the Entry point that will be the first argument when\r
+// x16 contains the Entry point that will be the first stacked argument when\r
// EBCInterpret is called.\r
//\r
//****************************************************************************\r
ASM_PFX(EbcLLEbcInterpret):\r
- stp x29, x30, [sp, #-16]!\r
-\r
- // copy the current arguments 9-16 from old location and add arg 7 to stack\r
- // keeping 16 byte stack alignment\r
- sub sp, sp, #80\r
- str x7, [sp]\r
- ldr x11, [sp, #96]\r
- str x11, [sp, #8]\r
- ldr x11, [sp, #104]\r
- str x11, [sp, #16]\r
- ldr x11, [sp, #112]\r
- str x11, [sp, #24]\r
- ldr x11, [sp, #120]\r
- str x11, [sp, #32]\r
- ldr x11, [sp, #128]\r
- str x11, [sp, #40]\r
- ldr x11, [sp, #136]\r
- str x11, [sp, #48]\r
- ldr x11, [sp, #144]\r
- str x11, [sp, #56]\r
- ldr x11, [sp, #152]\r
- str x11, [sp, #64]\r
-\r
- // Shift arguments and add entry point and as argument 1\r
- mov x7, x6\r
- mov x6, x5\r
- mov x5, x4\r
- mov x4, x3\r
- mov x3, x2\r
- mov x2, x1\r
- mov x1, x0\r
- mov x0, x16\r
+ stp x29, x30, [sp, #-16]!\r
+ mov x29, sp\r
\r
- // call C-code\r
- bl ASM_PFX(EbcInterpret)\r
- add sp, sp, #80\r
+ // push the entry point and the address of args #9 - #16 onto the stack\r
+ add x17, sp, #16\r
+ stp x16, x17, [sp, #-16]!\r
\r
- ldp x29, x30, [sp], #16\r
+ // call C-code\r
+ bl ASM_PFX(EbcInterpret)\r
\r
+ add sp, sp, #16\r
+ ldp x29, x30, [sp], #16\r
ret\r
\r
//****************************************************************************\r
//\r
//****************************************************************************\r
ASM_PFX(EbcLLExecuteEbcImageEntryPoint):\r
- stp x29, x30, [sp, #-16]!\r
- // build new parameter calling convention\r
- mov x2, x1\r
- mov x1, x0\r
- mov x0, x16\r
+ mov x2, x16\r
\r
- // call C-code\r
- bl ASM_PFX(ExecuteEbcImageEntryPoint)\r
- ldp x29, x30, [sp], #16\r
- ret\r
+ // tail call to C code\r
+ b ASM_PFX(ExecuteEbcImageEntryPoint)\r
\r
//****************************************************************************\r
// mEbcInstructionBufferTemplate\r
projects / mirror_edk2.git / blobdiff