libffi/src/x86/ffi.c

   1 /* -----------------------------------------------------------------------
   2    ffi.c - Copyright (c) 1996, 1998, 1999, 2001, 2007  Red Hat, Inc.
   3            Copyright (c) 2002  Ranjit Mathew
   4            Copyright (c) 2002  Bo Thorsen
   5            Copyright (c) 2002  Roger Sayle
   6
   7    x86 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 CYGNUS SOLUTIONS 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 #ifndef __x86_64__
  30
  31 #include <ffi.h>
  32 #include <ffi_common.h>
  33
  34 #include <stdlib.h>
  35
  36 /* ffi_prep_args is called by the assembly routine once stack space
  37    has been allocated for the function's arguments */
  38
  39 void ffi_prep_args(char *stack, extended_cif *ecif)
  40 {
  41   register unsigned int i;
  42   register void **p_argv;
  43   register char *argp;
  44   register ffi_type **p_arg;
  45
  46   argp = stack;
  47
  48   if (ecif->cif->flags == FFI_TYPE_STRUCT)
  49     {
  50       *(void **) argp = ecif->rvalue;
  51       argp += 4;
  52     }
  53
  54   p_argv = ecif->avalue;
  55
  56   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
  57        i != 0;
  58        i--, p_arg++)
  59     {
  60       size_t z;
  61
  62       /* Align if necessary */
  63       if ((sizeof(int) - 1) & (unsigned) argp)
  64         argp = (char *) ALIGN(argp, sizeof(int));
  65
  66       z = (*p_arg)->size;
  67       if (z < sizeof(int))
  68         {
  69           z = sizeof(int);
  70           switch ((*p_arg)->type)
  71             {
  72             case FFI_TYPE_SINT8:
  73               *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
  74               break;
  75
  76             case FFI_TYPE_UINT8:
  77               *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
  78               break;
  79
  80             case FFI_TYPE_SINT16:
  81               *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
  82               break;
  83
  84             case FFI_TYPE_UINT16:
  85               *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
  86               break;
  87
  88             case FFI_TYPE_SINT32:
  89               *(signed int *) argp = (signed int)*(SINT32 *)(* p_argv);
  90               break;
  91
  92             case FFI_TYPE_UINT32:
  93               *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
  94               break;
  95
  96             case FFI_TYPE_STRUCT:
  97               *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
  98               break;
  99
 100             default:
 101               FFI_ASSERT(0);
 102             }
 103         }
 104       else
 105         {
 106           memcpy(argp, *p_argv, z);
 107         }
 108       p_argv++;
 109       argp += z;
 110     }
 111
 112   return;
 113 }
 114
 115 /* Perform machine dependent cif processing */
 116 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
 117 {
 118   /* Set the return type flag */
 119   switch (cif->rtype->type)
 120     {
 121     case FFI_TYPE_VOID:
 122 #ifdef X86
 123     case FFI_TYPE_STRUCT:
 124     case FFI_TYPE_UINT8:
 125     case FFI_TYPE_UINT16:
 126     case FFI_TYPE_SINT8:
 127     case FFI_TYPE_SINT16:
 128 #endif
 129
 130     case FFI_TYPE_SINT64:
 131     case FFI_TYPE_FLOAT:
 132     case FFI_TYPE_DOUBLE:
 133     case FFI_TYPE_LONGDOUBLE:
 134       cif->flags = (unsigned) cif->rtype->type;
 135       break;
 136
 137     case FFI_TYPE_UINT64:
 138       cif->flags = FFI_TYPE_SINT64;
 139       break;
 140
 141 #ifndef X86
 142     case FFI_TYPE_STRUCT:
 143       if (cif->rtype->size == 1)
 144         {
 145           cif->flags = FFI_TYPE_SINT8; /* same as char size */
 146         }
 147       else if (cif->rtype->size == 2)
 148         {
 149           cif->flags = FFI_TYPE_SINT16; /* same as short size */
 150         }
 151       else if (cif->rtype->size == 4)
 152         {
 153           cif->flags = FFI_TYPE_INT; /* same as int type */
 154         }
 155       else if (cif->rtype->size == 8)
 156         {
 157           cif->flags = FFI_TYPE_SINT64; /* same as int64 type */
 158         }
 159       else
 160         {
 161           cif->flags = FFI_TYPE_STRUCT;
 162         }
 163       break;
 164 #endif
 165
 166     default:
 167       cif->flags = FFI_TYPE_INT;
 168       break;
 169     }
 170
 171 #ifdef X86_DARWIN
 172   cif->bytes = (cif->bytes + 15) & ~0xF;
 173 #endif
 174
 175   return FFI_OK;
 176 }
 177
 178 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *,
 179                           unsigned, unsigned, unsigned *, void (*fn)());
 180
 181 #ifdef X86_WIN32
 182 extern void ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *,
 183                           unsigned, unsigned, unsigned *, void (*fn)());
 184
 185 #endif /* X86_WIN32 */
 186
 187 void ffi_call(ffi_cif *cif, void (*fn)(), void *rvalue, void **avalue)
 188 {
 189   extended_cif ecif;
 190
 191   ecif.cif = cif;
 192   ecif.avalue = avalue;
 193
 194   /* If the return value is a struct and we don't have a return */
 195   /* value address then we need to make one                     */
 196
 197   if ((rvalue == NULL) &&
 198       (cif->flags == FFI_TYPE_STRUCT))
 199     {
 200       ecif.rvalue = alloca(cif->rtype->size);
 201     }
 202   else
 203     ecif.rvalue = rvalue;
 204
 205
 206   switch (cif->abi)
 207     {
 208     case FFI_SYSV:
 209       ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
 210                     fn);
 211       break;
 212 #ifdef X86_WIN32
 213     case FFI_STDCALL:
 214       ffi_call_STDCALL(ffi_prep_args, &ecif, cif->bytes, cif->flags,
 215                        ecif.rvalue, fn);
 216       break;
 217 #endif /* X86_WIN32 */
 218     default:
 219       FFI_ASSERT(0);
 220       break;
 221     }
 222 }
 223
 224
 225 /** private members **/
 226
 227 static void ffi_prep_incoming_args_SYSV (char *stack, void **ret,
 228                                          void** args, ffi_cif* cif);
 229 void FFI_HIDDEN ffi_closure_SYSV (ffi_closure *)
 230      __attribute__ ((regparm(1)));
 231 unsigned int FFI_HIDDEN ffi_closure_SYSV_inner (ffi_closure *, void **, void *)
 232      __attribute__ ((regparm(1)));
 233 void FFI_HIDDEN ffi_closure_raw_SYSV (ffi_raw_closure *)
 234      __attribute__ ((regparm(1)));
 235
 236 /* This function is jumped to by the trampoline */
 237
 238 unsigned int FFI_HIDDEN
 239 ffi_closure_SYSV_inner (closure, respp, args)
 240      ffi_closure *closure;
 241      void **respp;
 242      void *args;
 243 {
 244   // our various things...
 245   ffi_cif       *cif;
 246   void         **arg_area;
 247
 248   cif         = closure->cif;
 249   arg_area    = (void**) alloca (cif->nargs * sizeof (void*));
 250
 251   /* this call will initialize ARG_AREA, such that each
 252    * element in that array points to the corresponding
 253    * value on the stack; and if the function returns
 254    * a structure, it will re-set RESP to point to the
 255    * structure return address.  */
 256
 257   ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif);
 258
 259   (closure->fun) (cif, *respp, arg_area, closure->user_data);
 260
 261   return cif->flags;
 262 }
 263
 264 static void
 265 ffi_prep_incoming_args_SYSV(char *stack, void **rvalue, void **avalue,
 266                             ffi_cif *cif)
 267 {
 268   register unsigned int i;
 269   register void **p_argv;
 270   register char *argp;
 271   register ffi_type **p_arg;
 272
 273   argp = stack;
 274
 275   if ( cif->flags == FFI_TYPE_STRUCT ) {
 276     *rvalue = *(void **) argp;
 277     argp += 4;
 278   }
 279
 280   p_argv = avalue;
 281
 282   for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
 283     {
 284       size_t z;
 285
 286       /* Align if necessary */
 287       if ((sizeof(int) - 1) & (unsigned) argp) {
 288         argp = (char *) ALIGN(argp, sizeof(int));
 289       }
 290
 291       z = (*p_arg)->size;
 292
 293       /* because we're little endian, this is what it turns into.   */
 294
 295       *p_argv = (void*) argp;
 296
 297       p_argv++;
 298       argp += z;
 299     }
 300
 301   return;
 302 }
 303
 304 /* How to make a trampoline.  Derived from gcc/config/i386/i386.c. */
 305
 306 #define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \
 307 ({ unsigned char *__tramp = (unsigned char*)(TRAMP); \
 308    unsigned int  __fun = (unsigned int)(FUN); \
 309    unsigned int  __ctx = (unsigned int)(CTX); \
 310    unsigned int  __dis = __fun - (__ctx + FFI_TRAMPOLINE_SIZE); \
 311    *(unsigned char*) &__tramp[0] = 0xb8; \
 312    *(unsigned int*)  &__tramp[1] = __ctx; /* movl __ctx, %eax */ \
 313    *(unsigned char *)  &__tramp[5] = 0xe9; \
 314    *(unsigned int*)  &__tramp[6] = __dis; /* jmp __fun  */ \
 315  })
 316
 317
 318 /* the cif must already be prep'ed */
 319
 320 ffi_status
 321 ffi_prep_closure_loc (ffi_closure* closure,
 322                       ffi_cif* cif,
 323                       void (*fun)(ffi_cif*,void*,void**,void*),
 324                       void *user_data,
 325                       void *codeloc)
 326 {
 327   FFI_ASSERT (cif->abi == FFI_SYSV);
 328
 329   FFI_INIT_TRAMPOLINE (&closure->tramp[0], \
 330                        &ffi_closure_SYSV,  \
 331                        codeloc);
 332
 333   closure->cif  = cif;
 334   closure->user_data = user_data;
 335   closure->fun  = fun;
 336
 337   return FFI_OK;
 338 }
 339
 340 /* ------- Native raw API support -------------------------------- */
 341
 342 #if !FFI_NO_RAW_API
 343
 344 ffi_status
 345 ffi_prep_raw_closure_loc (ffi_raw_closure* closure,
 346                           ffi_cif* cif,
 347                           void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 348                           void *user_data,
 349                           void *codeloc)
 350 {
 351   int i;
 352
 353   FFI_ASSERT (cif->abi == FFI_SYSV);
 354
 355   // we currently don't support certain kinds of arguments for raw
 356   // closures.  This should be implemented by a separate assembly language
 357   // routine, since it would require argument processing, something we
 358   // don't do now for performance.
 359
 360   for (i = cif->nargs-1; i >= 0; i--)
 361     {
 362       FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_STRUCT);
 363       FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_LONGDOUBLE);
 364     }
 365
 366
 367   FFI_INIT_TRAMPOLINE (&closure->tramp[0], &ffi_closure_raw_SYSV,
 368                        codeloc);
 369
 370   closure->cif  = cif;
 371   closure->user_data = user_data;
 372   closure->fun  = fun;
 373
 374   return FFI_OK;
 375 }
 376
 377 static void
 378 ffi_prep_args_raw(char *stack, extended_cif *ecif)
 379 {
 380   memcpy (stack, ecif->avalue, ecif->cif->bytes);
 381 }
 382
 383 /* we borrow this routine from libffi (it must be changed, though, to
 384  * actually call the function passed in the first argument.  as of
 385  * libffi-1.20, this is not the case.)
 386  */
 387
 388 extern void
 389 ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, unsigned,
 390               unsigned, unsigned *, void (*fn)());
 391
 392 #ifdef X86_WIN32
 393 extern void
 394 ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *, unsigned,
 395                  unsigned, unsigned *, void (*fn)());
 396 #endif /* X86_WIN32 */
 397
 398 void
 399 ffi_raw_call(ffi_cif *cif, void (*fn)(), void *rvalue, ffi_raw *fake_avalue)
 400 {
 401   extended_cif ecif;
 402   void **avalue = (void **)fake_avalue;
 403
 404   ecif.cif = cif;
 405   ecif.avalue = avalue;
 406
 407   /* If the return value is a struct and we don't have a return */
 408   /* value address then we need to make one                     */
 409
 410   if ((rvalue == NULL) &&
 411       (cif->rtype->type == FFI_TYPE_STRUCT))
 412     {
 413       ecif.rvalue = alloca(cif->rtype->size);
 414     }
 415   else
 416     ecif.rvalue = rvalue;
 417
 418
 419   switch (cif->abi)
 420     {
 421     case FFI_SYSV:
 422       ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,
 423                     ecif.rvalue, fn);
 424       break;
 425 #ifdef X86_WIN32
 426     case FFI_STDCALL:
 427       ffi_call_STDCALL(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,
 428                        ecif.rvalue, fn);
 429       break;
 430 #endif /* X86_WIN32 */
 431     default:
 432       FFI_ASSERT(0);
 433       break;
 434     }
 435 }
 436
 437 #endif
 438
 439 #endif /* __x86_64__  */