|
111
|
1 /*
|
|
|
2 * Copyright (c) 2013 Miodrag Vallat. <miod@openbsd.org>
|
|
|
3 *
|
|
|
4 * Permission is hereby granted, free of charge, to any person obtaining
|
|
|
5 * a copy of this software and associated documentation files (the
|
|
|
6 * ``Software''), to deal in the Software without restriction, including
|
|
|
7 * without limitation the rights to use, copy, modify, merge, publish,
|
|
|
8 * distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
9 * permit persons to whom the Software is furnished to do so, subject to
|
|
|
10 * the following conditions:
|
|
|
11 *
|
|
|
12 * The above copyright notice and this permission notice shall be included
|
|
|
13 * in all copies or substantial portions of the Software.
|
|
|
14 *
|
|
|
15 * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
|
|
|
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
20 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
21 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
22 */
|
|
|
23
|
|
|
24 /*
|
|
|
25 * vax Foreign Function Interface
|
|
|
26 *
|
|
|
27 * This file attempts to provide all the FFI entry points which can reliably
|
|
|
28 * be implemented in C.
|
|
|
29 */
|
|
|
30
|
|
|
31 #include <ffi.h>
|
|
|
32 #include <ffi_common.h>
|
|
|
33
|
|
|
34 #include <stdlib.h>
|
|
|
35 #include <unistd.h>
|
|
|
36
|
|
|
37 #define CIF_FLAGS_CHAR 1 /* for struct only */
|
|
|
38 #define CIF_FLAGS_SHORT 2 /* for struct only */
|
|
|
39 #define CIF_FLAGS_INT 4
|
|
|
40 #define CIF_FLAGS_DINT 8
|
|
|
41
|
|
|
42 /*
|
|
|
43 * Foreign Function Interface API
|
|
|
44 */
|
|
|
45
|
|
|
46 void ffi_call_elfbsd (extended_cif *, unsigned, unsigned, void *,
|
|
|
47 void (*) ());
|
|
|
48 void *ffi_prep_args (extended_cif *ecif, void *stack);
|
|
|
49
|
|
|
50 void *
|
|
|
51 ffi_prep_args (extended_cif *ecif, void *stack)
|
|
|
52 {
|
|
|
53 unsigned int i;
|
|
|
54 void **p_argv;
|
|
|
55 char *argp;
|
|
|
56 ffi_type **p_arg;
|
|
|
57 void *struct_value_ptr;
|
|
|
58
|
|
|
59 argp = stack;
|
|
|
60
|
|
|
61 if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
|
|
|
62 && !ecif->cif->flags)
|
|
|
63 struct_value_ptr = ecif->rvalue;
|
|
|
64 else
|
|
|
65 struct_value_ptr = NULL;
|
|
|
66
|
|
|
67 p_argv = ecif->avalue;
|
|
|
68
|
|
|
69 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
|
|
|
70 i != 0;
|
|
|
71 i--, p_arg++)
|
|
|
72 {
|
|
|
73 size_t z;
|
|
|
74
|
|
|
75 z = (*p_arg)->size;
|
|
|
76 if (z < sizeof (int))
|
|
|
77 {
|
|
|
78 switch ((*p_arg)->type)
|
|
|
79 {
|
|
|
80 case FFI_TYPE_SINT8:
|
|
|
81 *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
|
|
|
82 break;
|
|
|
83
|
|
|
84 case FFI_TYPE_UINT8:
|
|
|
85 *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
|
|
|
86 break;
|
|
|
87
|
|
|
88 case FFI_TYPE_SINT16:
|
|
|
89 *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
|
|
|
90 break;
|
|
|
91
|
|
|
92 case FFI_TYPE_UINT16:
|
|
|
93 *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
|
|
|
94 break;
|
|
|
95
|
|
|
96 case FFI_TYPE_STRUCT:
|
|
|
97 memcpy (argp, *p_argv, z);
|
|
|
98 break;
|
|
|
99
|
|
|
100 default:
|
|
|
101 FFI_ASSERT (0);
|
|
|
102 }
|
|
|
103 z = sizeof (int);
|
|
|
104 }
|
|
|
105 else
|
|
|
106 {
|
|
|
107 memcpy (argp, *p_argv, z);
|
|
|
108
|
|
|
109 /* Align if necessary. */
|
|
|
110 if ((sizeof(int) - 1) & z)
|
|
|
111 z = ALIGN(z, sizeof(int));
|
|
|
112 }
|
|
|
113
|
|
|
114 p_argv++;
|
|
|
115 argp += z;
|
|
|
116 }
|
|
|
117
|
|
|
118 return struct_value_ptr;
|
|
|
119 }
|
|
|
120
|
|
|
121 ffi_status
|
|
|
122 ffi_prep_cif_machdep (ffi_cif *cif)
|
|
|
123 {
|
|
|
124 /* Set the return type flag */
|
|
|
125 switch (cif->rtype->type)
|
|
|
126 {
|
|
|
127 case FFI_TYPE_VOID:
|
|
|
128 cif->flags = 0;
|
|
|
129 break;
|
|
|
130
|
|
|
131 case FFI_TYPE_STRUCT:
|
|
|
132 if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT &&
|
|
|
133 cif->rtype->elements[1])
|
|
|
134 {
|
|
|
135 cif->flags = 0;
|
|
|
136 break;
|
|
|
137 }
|
|
|
138
|
|
|
139 if (cif->rtype->size == sizeof (char))
|
|
|
140 cif->flags = CIF_FLAGS_CHAR;
|
|
|
141 else if (cif->rtype->size == sizeof (short))
|
|
|
142 cif->flags = CIF_FLAGS_SHORT;
|
|
|
143 else if (cif->rtype->size == sizeof (int))
|
|
|
144 cif->flags = CIF_FLAGS_INT;
|
|
|
145 else if (cif->rtype->size == 2 * sizeof (int))
|
|
|
146 cif->flags = CIF_FLAGS_DINT;
|
|
|
147 else
|
|
|
148 cif->flags = 0;
|
|
|
149 break;
|
|
|
150
|
|
|
151 default:
|
|
|
152 if (cif->rtype->size <= sizeof (int))
|
|
|
153 cif->flags = CIF_FLAGS_INT;
|
|
|
154 else
|
|
|
155 cif->flags = CIF_FLAGS_DINT;
|
|
|
156 break;
|
|
|
157 }
|
|
|
158
|
|
|
159 return FFI_OK;
|
|
|
160 }
|
|
|
161
|
|
|
162 void
|
|
|
163 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
|
|
|
164 {
|
|
|
165 extended_cif ecif;
|
|
|
166
|
|
|
167 ecif.cif = cif;
|
|
|
168 ecif.avalue = avalue;
|
|
|
169
|
|
|
170 /* If the return value is a struct and we don't have a return value
|
|
|
171 address then we need to make one. */
|
|
|
172
|
|
|
173 if (rvalue == NULL
|
|
|
174 && cif->rtype->type == FFI_TYPE_STRUCT
|
|
|
175 && cif->flags == 0)
|
|
|
176 ecif.rvalue = alloca (cif->rtype->size);
|
|
|
177 else
|
|
|
178 ecif.rvalue = rvalue;
|
|
|
179
|
|
|
180 switch (cif->abi)
|
|
|
181 {
|
|
|
182 case FFI_ELFBSD:
|
|
|
183 ffi_call_elfbsd (&ecif, cif->bytes, cif->flags, ecif.rvalue, fn);
|
|
|
184 break;
|
|
|
185
|
|
|
186 default:
|
|
|
187 FFI_ASSERT (0);
|
|
|
188 break;
|
|
|
189 }
|
|
|
190 }
|
|
|
191
|
|
|
192 /*
|
|
|
193 * Closure API
|
|
|
194 */
|
|
|
195
|
|
|
196 void ffi_closure_elfbsd (void);
|
|
|
197 void ffi_closure_struct_elfbsd (void);
|
|
|
198 unsigned int ffi_closure_elfbsd_inner (ffi_closure *, void *, char *);
|
|
|
199
|
|
|
200 static void
|
|
|
201 ffi_prep_closure_elfbsd (ffi_cif *cif, void **avalue, char *stackp)
|
|
|
202 {
|
|
|
203 unsigned int i;
|
|
|
204 void **p_argv;
|
|
|
205 ffi_type **p_arg;
|
|
|
206
|
|
|
207 p_argv = avalue;
|
|
|
208
|
|
|
209 for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
|
|
|
210 {
|
|
|
211 size_t z;
|
|
|
212
|
|
|
213 z = (*p_arg)->size;
|
|
|
214 *p_argv = stackp;
|
|
|
215
|
|
|
216 /* Align if necessary */
|
|
|
217 if ((sizeof (int) - 1) & z)
|
|
|
218 z = ALIGN(z, sizeof (int));
|
|
|
219
|
|
|
220 p_argv++;
|
|
|
221 stackp += z;
|
|
|
222 }
|
|
|
223 }
|
|
|
224
|
|
|
225 unsigned int
|
|
|
226 ffi_closure_elfbsd_inner (ffi_closure *closure, void *resp, char *stack)
|
|
|
227 {
|
|
|
228 ffi_cif *cif;
|
|
|
229 void **arg_area;
|
|
|
230
|
|
|
231 cif = closure->cif;
|
|
|
232 arg_area = (void **) alloca (cif->nargs * sizeof (void *));
|
|
|
233
|
|
|
234 ffi_prep_closure_elfbsd (cif, arg_area, stack);
|
|
|
235
|
|
|
236 (closure->fun) (cif, resp, arg_area, closure->user_data);
|
|
|
237
|
|
|
238 return cif->flags;
|
|
|
239 }
|
|
|
240
|
|
|
241 ffi_status
|
|
|
242 ffi_prep_closure_loc (ffi_closure *closure, ffi_cif *cif,
|
|
|
243 void (*fun)(ffi_cif *, void *, void **, void *),
|
|
|
244 void *user_data, void *codeloc)
|
|
|
245 {
|
|
|
246 char *tramp = (char *) codeloc;
|
|
|
247 void *fn;
|
|
|
248
|
|
|
249 FFI_ASSERT (cif->abi == FFI_ELFBSD);
|
|
|
250
|
|
|
251 /* entry mask */
|
|
|
252 *(unsigned short *)(tramp + 0) = 0x0000;
|
|
|
253 /* movl #closure, r0 */
|
|
|
254 tramp[2] = 0xd0;
|
|
|
255 tramp[3] = 0x8f;
|
|
|
256 *(unsigned int *)(tramp + 4) = (unsigned int) closure;
|
|
|
257 tramp[8] = 0x50;
|
|
|
258
|
|
|
259 if (cif->rtype->type == FFI_TYPE_STRUCT
|
|
|
260 && !cif->flags)
|
|
|
261 fn = &ffi_closure_struct_elfbsd;
|
|
|
262 else
|
|
|
263 fn = &ffi_closure_elfbsd;
|
|
|
264
|
|
|
265 /* jmpl #fn */
|
|
|
266 tramp[9] = 0x17;
|
|
|
267 tramp[10] = 0xef;
|
|
|
268 *(unsigned int *)(tramp + 11) = (unsigned int)fn + 2 -
|
|
|
269 (unsigned int)tramp - 9 - 6;
|
|
|
270
|
|
|
271 closure->cif = cif;
|
|
|
272 closure->user_data = user_data;
|
|
|
273 closure->fun = fun;
|
|
|
274
|
|
|
275 return FFI_OK;
|
|
|
276 }
|
