1 /* ----------------------------------------------------------------------- 2 ffi.c - Copyright (c) 1998 Cygnus Solutions 3 Copyright (c) 2004 Simon Posnjak 4 Copyright (c) 2005 Axis Communications AB 5 Copyright (C) 2007 Free Software Foundation, Inc. 6 7 CRIS Foreign Function Interface 8 9 Permission is hereby granted, free of charge, to any person obtaining 10 a copy of this software and associated documentation files (the 11 ``Software''), to deal in the Software without restriction, including 12 without limitation the rights to use, copy, modify, merge, publish, 13 distribute, sublicense, and/or sell copies of the Software, and to 14 permit persons to whom the Software is furnished to do so, subject to 15 the following conditions: 16 17 The above copyright notice and this permission notice shall be included 18 in all copies or substantial portions of the Software. 19 20 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS 21 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 23 IN NO EVENT SHALL SIMON POSNJAK BE LIABLE FOR ANY CLAIM, DAMAGES OR 24 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 25 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 26 OTHER DEALINGS IN THE SOFTWARE. 27 ----------------------------------------------------------------------- */ 28 29 #include <ffi.h> 30 #include <ffi_common.h> 31 32 #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG) 33 34 static ffi_status 35 initialize_aggregate_packed_struct (ffi_type * arg) 36 { 37 ffi_type **ptr; 38 39 FFI_ASSERT (arg != NULL); 40 41 FFI_ASSERT (arg->elements != NULL); 42 FFI_ASSERT (arg->size == 0); 43 FFI_ASSERT (arg->alignment == 0); 44 45 ptr = &(arg->elements[0]); 46 47 while ((*ptr) != NULL) 48 { 49 if (((*ptr)->size == 0) 50 && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK)) 51 return FFI_BAD_TYPEDEF; 52 53 FFI_ASSERT (ffi_type_test ((*ptr))); 54 55 arg->size += (*ptr)->size; 56 57 arg->alignment = (arg->alignment > (*ptr)->alignment) ? 58 arg->alignment : (*ptr)->alignment; 59 60 ptr++; 61 } 62 63 if (arg->size == 0) 64 return FFI_BAD_TYPEDEF; 65 else 66 return FFI_OK; 67 } 68 69 int 70 ffi_prep_args (char *stack, extended_cif * ecif) 71 { 72 unsigned int i; 73 unsigned int struct_count = 0; 74 void **p_argv; 75 char *argp; 76 ffi_type **p_arg; 77 78 argp = stack; 79 80 p_argv = ecif->avalue; 81 82 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; 83 (i != 0); i--, p_arg++) 84 { 85 size_t z; 86 87 switch ((*p_arg)->type) 88 { 89 case FFI_TYPE_STRUCT: 90 { 91 z = (*p_arg)->size; 92 if (z <= 4) 93 { 94 memcpy (argp, *p_argv, z); 95 z = 4; 96 } 97 else if (z <= 8) 98 { 99 memcpy (argp, *p_argv, z); 100 z = 8; 101 } 102 else 103 { 104 unsigned int uiLocOnStack; 105 z = sizeof (void *); 106 uiLocOnStack = 4 * ecif->cif->nargs + struct_count; 107 struct_count = struct_count + (*p_arg)->size; 108 *(unsigned int *) argp = 109 (unsigned int) (UINT32 *) (stack + uiLocOnStack); 110 memcpy ((stack + uiLocOnStack), *p_argv, (*p_arg)->size); 111 } 112 break; 113 } 114 default: 115 z = (*p_arg)->size; 116 if (z < sizeof (int)) 117 { 118 switch ((*p_arg)->type) 119 { 120 case FFI_TYPE_SINT8: 121 *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv); 122 break; 123 124 case FFI_TYPE_UINT8: 125 *(unsigned int *) argp = 126 (unsigned int) *(UINT8 *) (*p_argv); 127 break; 128 129 case FFI_TYPE_SINT16: 130 *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv); 131 break; 132 133 case FFI_TYPE_UINT16: 134 *(unsigned int *) argp = 135 (unsigned int) *(UINT16 *) (*p_argv); 136 break; 137 138 default: 139 FFI_ASSERT (0); 140 } 141 z = sizeof (int); 142 } 143 else if (z == sizeof (int)) 144 *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv); 145 else 146 memcpy (argp, *p_argv, z); 147 break; 148 } 149 p_argv++; 150 argp += z; 151 } 152 153 return (struct_count); 154 } 155 156 ffi_status FFI_HIDDEN 157 ffi_prep_cif_core (ffi_cif * cif, 158 ffi_abi abi, unsigned int isvariadic, 159 unsigned int nfixedargs, unsigned int ntotalargs, 160 ffi_type * rtype, ffi_type ** atypes) 161 { 162 unsigned bytes = 0; 163 unsigned int i; 164 ffi_type **ptr; 165 166 FFI_ASSERT (cif != NULL); 167 FFI_ASSERT((!isvariadic) || (nfixedargs >= 1)); 168 FFI_ASSERT(nfixedargs <= ntotalargs); 169 FFI_ASSERT (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI); 170 171 cif->abi = abi; 172 cif->arg_types = atypes; 173 cif->nargs = ntotalargs; 174 cif->rtype = rtype; 175 176 cif->flags = 0; 177 178 if ((cif->rtype->size == 0) 179 && (initialize_aggregate_packed_struct (cif->rtype) != FFI_OK)) 180 return FFI_BAD_TYPEDEF; 181 182 FFI_ASSERT_VALID_TYPE (cif->rtype); 183 184 for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++) 185 { 186 if (((*ptr)->size == 0) 187 && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK)) 188 return FFI_BAD_TYPEDEF; 189 190 FFI_ASSERT_VALID_TYPE (*ptr); 191 192 if (((*ptr)->alignment - 1) & bytes) 193 bytes = ALIGN (bytes, (*ptr)->alignment); 194 if ((*ptr)->type == FFI_TYPE_STRUCT) 195 { 196 if ((*ptr)->size > 8) 197 { 198 bytes += (*ptr)->size; 199 bytes += sizeof (void *); 200 } 201 else 202 { 203 if ((*ptr)->size > 4) 204 bytes += 8; 205 else 206 bytes += 4; 207 } 208 } 209 else 210 bytes += STACK_ARG_SIZE ((*ptr)->size); 211 } 212 213 cif->bytes = bytes; 214 215 return ffi_prep_cif_machdep (cif); 216 } 217 218 ffi_status 219 ffi_prep_cif_machdep (ffi_cif * cif) 220 { 221 switch (cif->rtype->type) 222 { 223 case FFI_TYPE_VOID: 224 case FFI_TYPE_STRUCT: 225 case FFI_TYPE_FLOAT: 226 case FFI_TYPE_DOUBLE: 227 case FFI_TYPE_SINT64: 228 case FFI_TYPE_UINT64: 229 cif->flags = (unsigned) cif->rtype->type; 230 break; 231 232 default: 233 cif->flags = FFI_TYPE_INT; 234 break; 235 } 236 237 return FFI_OK; 238 } 239 240 extern void ffi_call_SYSV (int (*)(char *, extended_cif *), 241 extended_cif *, 242 unsigned, unsigned, unsigned *, void (*fn) ()) 243 __attribute__ ((__visibility__ ("hidden"))); 244 245 void 246 ffi_call (ffi_cif * cif, void (*fn) (), void *rvalue, void **avalue) 247 { 248 extended_cif ecif; 249 250 ecif.cif = cif; 251 ecif.avalue = avalue; 252 253 if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) 254 { 255 ecif.rvalue = alloca (cif->rtype->size); 256 } 257 else 258 ecif.rvalue = rvalue; 259 260 switch (cif->abi) 261 { 262 case FFI_SYSV: 263 ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes, 264 cif->flags, ecif.rvalue, fn); 265 break; 266 default: 267 FFI_ASSERT (0); 268 break; 269 } 270 } 271 272 /* Because the following variables are not exported outside libffi, we 273 mark them hidden. */ 274 275 /* Assembly code for the jump stub. */ 276 extern const char ffi_cris_trampoline_template[] 277 __attribute__ ((__visibility__ ("hidden"))); 278 279 /* Offset into ffi_cris_trampoline_template of where to put the 280 ffi_prep_closure_inner function. */ 281 extern const int ffi_cris_trampoline_fn_offset 282 __attribute__ ((__visibility__ ("hidden"))); 283 284 /* Offset into ffi_cris_trampoline_template of where to put the 285 closure data. */ 286 extern const int ffi_cris_trampoline_closure_offset 287 __attribute__ ((__visibility__ ("hidden"))); 288 289 /* This function is sibling-called (jumped to) by the closure 290 trampoline. We get R10..R13 at PARAMS[0..3] and a copy of [SP] at 291 PARAMS[4] to simplify handling of a straddling parameter. A copy 292 of R9 is at PARAMS[5] and SP at PARAMS[6]. These parameters are 293 put at the appropriate place in CLOSURE which is then executed and 294 the return value is passed back to the caller. */ 295 296 static unsigned long long 297 ffi_prep_closure_inner (void **params, ffi_closure* closure) 298 { 299 char *register_args = (char *) params; 300 void *struct_ret = params[5]; 301 char *stack_args = params[6]; 302 char *ptr = register_args; 303 ffi_cif *cif = closure->cif; 304 ffi_type **arg_types = cif->arg_types; 305 306 /* Max room needed is number of arguments as 64-bit values. */ 307 void **avalue = alloca (closure->cif->nargs * sizeof(void *)); 308 int i; 309 int doing_regs; 310 long long llret = 0; 311 312 /* Find the address of each argument. */ 313 for (i = 0, doing_regs = 1; i < cif->nargs; i++) 314 { 315 /* Types up to and including 8 bytes go by-value. */ 316 if (arg_types[i]->size <= 4) 317 { 318 avalue[i] = ptr; 319 ptr += 4; 320 } 321 else if (arg_types[i]->size <= 8) 322 { 323 avalue[i] = ptr; 324 ptr += 8; 325 } 326 else 327 { 328 FFI_ASSERT (arg_types[i]->type == FFI_TYPE_STRUCT); 329 330 /* Passed by-reference, so copy the pointer. */ 331 avalue[i] = *(void **) ptr; 332 ptr += 4; 333 } 334 335 /* If we've handled more arguments than fit in registers, start 336 looking at the those passed on the stack. Step over the 337 first one if we had a straddling parameter. */ 338 if (doing_regs && ptr >= register_args + 4*4) 339 { 340 ptr = stack_args + ((ptr > register_args + 4*4) ? 4 : 0); 341 doing_regs = 0; 342 } 343 } 344 345 /* Invoke the closure. */ 346 (closure->fun) (cif, 347 348 cif->rtype->type == FFI_TYPE_STRUCT 349 /* The caller allocated space for the return 350 structure, and passed a pointer to this space in 351 R9. */ 352 ? struct_ret 353 354 /* We take advantage of being able to ignore that 355 the high part isn't set if the return value is 356 not in R10:R11, but in R10 only. */ 357 : (void *) &llret, 358 359 avalue, closure->user_data); 360 361 return llret; 362 } 363 364 /* API function: Prepare the trampoline. */ 365 366 ffi_status 367 ffi_prep_closure_loc (ffi_closure* closure, 368 ffi_cif* cif, 369 void (*fun)(ffi_cif *, void *, void **, void*), 370 void *user_data, 371 void *codeloc) 372 { 373 void *innerfn = ffi_prep_closure_inner; 374 FFI_ASSERT (cif->abi == FFI_SYSV); 375 closure->cif = cif; 376 closure->user_data = user_data; 377 closure->fun = fun; 378 memcpy (closure->tramp, ffi_cris_trampoline_template, 379 FFI_CRIS_TRAMPOLINE_CODE_PART_SIZE); 380 memcpy (closure->tramp + ffi_cris_trampoline_fn_offset, 381 &innerfn, sizeof (void *)); 382 memcpy (closure->tramp + ffi_cris_trampoline_closure_offset, 383 &codeloc, sizeof (void *)); 384 385 return FFI_OK; 386 } 387
