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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
; -----------------------------------------------------------------------
; sysv.S - Copyright (c) 1998 Red Hat, Inc.
;
; ARM Foreign Function Interface
;
; Permission is hereby granted, free of charge, to any person obtaining
; a copy of this software and associated documentation files (the
; ``Software''), to deal in the Software without restriction, including
; without limitation the rights to use, copy, modify, merge, publish,
; distribute, sublicense, and/or sell copies of the Software, and to
; permit persons to whom the Software is furnished to do so, subject to
; the following conditions:
;
; The above copyright notice and this permission notice shall be included
; in all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
; OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
; IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
; OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
; OTHER DEALINGS IN THE SOFTWARE.
; ----------------------------------------------------------------------- */
;#define LIBFFI_ASM
;#include <fficonfig.h>
;#include <ffi.h>
;#ifdef HAVE_MACHINE_ASM_H
;#include <machine/asm.h>
;#else
;#ifdef __USER_LABEL_PREFIX__
;#define CONCAT1(a, b) CONCAT2(a, b)
;#define CONCAT2(a, b) a ## b
;/* Use the right prefix for global labels. */
;#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
;#else
;#define CNAME(x) x
;#endif
;#define ENTRY(x) .globl CNAME(x); .type CNAME(x),%function; CNAME(x):
;#endif
FFI_TYPE_VOID EQU 0
FFI_TYPE_INT EQU 1
FFI_TYPE_FLOAT EQU 2
FFI_TYPE_DOUBLE EQU 3
;FFI_TYPE_LONGDOUBLE EQU 4
FFI_TYPE_UINT8 EQU 5
FFI_TYPE_SINT8 EQU 6
FFI_TYPE_UINT16 EQU 7
FFI_TYPE_SINT16 EQU 8
FFI_TYPE_UINT32 EQU 9
FFI_TYPE_SINT32 EQU 10
FFI_TYPE_UINT64 EQU 11
FFI_TYPE_SINT64 EQU 12
FFI_TYPE_STRUCT EQU 13
FFI_TYPE_POINTER EQU 14
; WinCE always uses software floating point (I think)
__SOFTFP__ EQU {TRUE}
AREA |.text|, CODE, ARM ; .text
; a1: ffi_prep_args
; a2: &ecif
; a3: cif->bytes
; a4: fig->flags
; sp+0: ecif.rvalue
; sp+4: fn
; This assumes we are using gas.
;ENTRY(ffi_call_SYSV)
EXPORT |ffi_call_SYSV|
|ffi_call_SYSV| PROC
; Save registers
stmfd sp!, {a1-a4, fp, lr}
mov fp, sp
; Make room for all of the new args.
sub sp, fp, a3
; Place all of the ffi_prep_args in position
mov ip, a1
mov a1, sp
; a2 already set
; And call
mov lr, pc
mov pc, ip
; move first 4 parameters in registers
ldr a1, [sp, #0]
ldr a2, [sp, #4]
ldr a3, [sp, #8]
ldr a4, [sp, #12]
; and adjust stack
ldr ip, [fp, #8]
cmp ip, #16
movge ip, #16
add sp, sp, ip
; call function
mov lr, pc
ldr pc, [fp, #28]
; Remove the space we pushed for the args
mov sp, fp
; Load a3 with the pointer to storage for the return value
ldr a3, [sp, #24]
; Load a4 with the return type code
ldr a4, [sp, #12]
; If the return value pointer is NULL, assume no return value.
cmp a3, #0
beq call_epilogue
; return INT
cmp a4, #FFI_TYPE_INT
streq a1, [a3]
beq call_epilogue
; return FLOAT
cmp a4, #FFI_TYPE_FLOAT
[ __SOFTFP__ ;ifdef __SOFTFP__
streq a1, [a3]
| ;else
stfeqs f0, [a3]
] ;endif
beq call_epilogue
; return DOUBLE or LONGDOUBLE
cmp a4, #FFI_TYPE_DOUBLE
[ __SOFTFP__ ;ifdef __SOFTFP__
stmeqia a3, {a1, a2}
| ;else
stfeqd f0, [a3]
] ;endif
beq call_epilogue
; return SINT64 or UINT64
cmp a4, #FFI_TYPE_SINT64
stmeqia a3, {a1, a2}
call_epilogue
ldmfd sp!, {a1-a4, fp, pc}
;.ffi_call_SYSV_end:
;.size CNAME(ffi_call_SYSV),.ffi_call_SYSV_end-CNAME(ffi_call_SYSV)
ENDP
RESERVE_RETURN EQU 16
; This function is called by the trampoline
; It is NOT callable from C
; ip = pointer to struct ffi_closure
IMPORT |ffi_closure_SYSV_inner|
EXPORT |ffi_closure_SYSV|
|ffi_closure_SYSV| PROC
; Store the argument registers on the stack
stmfd sp!, {a1-a4}
; Push the return address onto the stack
stmfd sp!, {lr}
mov a1, ip ; first arg = address of ffi_closure
add a2, sp, #4 ; second arg = sp+4 (points to saved a1)
; Allocate space for a non-struct return value
sub sp, sp, #RESERVE_RETURN
mov a3, sp ; third arg = return value address
; static unsigned int
; ffi_closure_SYSV_inner (ffi_closure *closure, char *in_args, void *rvalue)
bl ffi_closure_SYSV_inner
; a1 now contains the return type code
; At this point the return value is on the stack
; Transfer it to the correct registers if necessary
; return INT
cmp a1, #FFI_TYPE_INT
ldreq a1, [sp]
beq closure_epilogue
; return FLOAT
cmp a1, #FFI_TYPE_FLOAT
[ __SOFTFP__ ;ifdef __SOFTFP__
ldreq a1, [sp]
| ;else
stfeqs f0, [sp]
] ;endif
beq closure_epilogue
; return DOUBLE or LONGDOUBLE
cmp a1, #FFI_TYPE_DOUBLE
[ __SOFTFP__ ;ifdef __SOFTFP__
ldmeqia sp, {a1, a2}
| ;else
stfeqd f0, [sp]
] ;endif
beq closure_epilogue
; return SINT64 or UINT64
cmp a1, #FFI_TYPE_SINT64
ldmeqia sp, {a1, a2}
closure_epilogue
add sp, sp, #RESERVE_RETURN ; remove return value buffer
ldmfd sp!, {ip} ; ip = pop return address
add sp, sp, #16 ; remove saved argument registers {a1-a4} from the stack
mov pc, ip ; return
ENDP ; ffi_closure_SYSV
END
|
