1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
///** @file
//
// This code provides low level routines that support the Virtual Machine
// for option ROMs.
//
// Copyright (c) 2015, The Linux Foundation. All rights reserved.
// 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.
//
//**/
ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative)
ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret)
ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint)
//****************************************************************************
// 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):
stp x19, x20, [sp, #-16]!
stp x29, x30, [sp, #-16]!
mov x19, x0
mov x20, sp
sub x2, x2, x1 // Length = NewStackPointer-FramePtr
sub sp, sp, x2
sub sp, sp, #64 // Make sure there is room for at least 8 args in the new stack
mov x0, sp
bl CopyMem // Sp, NewStackPointer, Length
ldp x0, x1, [sp], #16
ldp x2, x3, [sp], #16
ldp x4, x5, [sp], #16
ldp x6, x7, [sp], #16
blr x19
mov sp, x20
ldp x29, x30, [sp], #16
ldp x19, x20, [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)
// x9 contains the Entry point that will be the first argument when
// EBCInterpret is called.
//
//****************************************************************************
ASM_PFX(EbcLLEbcInterpret):
stp x29, x30, [sp, #-16]!
// copy the current arguments 9-16 from old location and add arg 7 to stack
// keeping 16 byte stack alignment
sub sp, sp, #80
str x7, [sp]
ldr x11, [sp, #96]
str x11, [sp, #8]
ldr x11, [sp, #104]
str x11, [sp, #16]
ldr x11, [sp, #112]
str x11, [sp, #24]
ldr x11, [sp, #120]
str x11, [sp, #32]
ldr x11, [sp, #128]
str x11, [sp, #40]
ldr x11, [sp, #136]
str x11, [sp, #48]
ldr x11, [sp, #144]
str x11, [sp, #56]
ldr x11, [sp, #152]
str x11, [sp, #64]
// Shift arguments and add entry point and as argument 1
mov x7, x6
mov x6, x5
mov x5, x4
mov x4, x3
mov x3, x2
mov x2, x1
mov x1, x0
mov x0, x9
// call C-code
bl ASM_PFX(EbcInterpret)
add sp, sp, #80
ldp x29, x30, [sp], #16
ret
//****************************************************************************
// EbcLLExecuteEbcImageEntryPoint
//
// This function is called by the thunk code to handle the image entry point
// x9 contains the Entry point that will be the first argument when
// ExecuteEbcImageEntryPoint is called.
//
//****************************************************************************
ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
stp x29, x30, [sp, #-16]!
// build new parameter calling convention
mov x2, x1
mov x1, x0
mov x0, x9
// call C-code
bl ASM_PFX(ExecuteEbcImageEntryPoint)
ldp x29, x30, [sp], #16
ret
|
