toolchain/gcc/libffi/src/x86/ffi.c

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