Mercurial > hg > CbC > CbC_gcc
comparison libffi/src/vax/ffi.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
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 } |