libffi/src/mips/ffi.c

   1 /* -----------------------------------------------------------------------
   2    ffi.c - Copyright (c) 2011  Anthony Green
   3            Copyright (c) 2008  David Daney
   4            Copyright (c) 1996, 2007, 2008, 2011  Red Hat, Inc.
   5
   6    MIPS Foreign Function Interface
   7
   8    Permission is hereby granted, free of charge, to any person obtaining
   9    a copy of this software and associated documentation files (the
  10    ``Software''), to deal in the Software without restriction, including
  11    without limitation the rights to use, copy, modify, merge, publish,
  12    distribute, sublicense, and/or sell copies of the Software, and to
  13    permit persons to whom the Software is furnished to do so, subject to
  14    the following conditions:
  15
  16    The above copyright notice and this permission notice shall be included
  17    in all copies or substantial portions of the Software.
  18
  19    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  20    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26    DEALINGS IN THE SOFTWARE.
  27    ----------------------------------------------------------------------- */
  28
  29 #include <ffi.h>
  30 #include <ffi_common.h>
  31
  32 #include <stdlib.h>
  33
  34 #ifdef __GNUC__
  35 #  if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
  36 #    define USE__BUILTIN___CLEAR_CACHE 1
  37 #  endif
  38 #endif
  39
  40 #ifndef USE__BUILTIN___CLEAR_CACHE
  41 #  if defined(__OpenBSD__)
  42 #    include <mips64/sysarch.h>
  43 #  else
  44 #    include <sys/cachectl.h>
  45 #  endif
  46 #endif
  47
  48 #ifdef FFI_DEBUG
  49 # define FFI_MIPS_STOP_HERE() ffi_stop_here()
  50 #else
  51 # define FFI_MIPS_STOP_HERE() do {} while(0)
  52 #endif
  53
  54 #ifdef FFI_MIPS_N32
  55 #define FIX_ARGP \
  56 FFI_ASSERT(argp <= &stack[bytes]); \
  57 if (argp == &stack[bytes]) \
  58 { \
  59   argp = stack; \
  60   FFI_MIPS_STOP_HERE(); \
  61 }
  62 #else
  63 #define FIX_ARGP
  64 #endif
  65
  66
  67 /* ffi_prep_args is called by the assembly routine once stack space
  68    has been allocated for the function's arguments */
  69
  70 static void ffi_prep_args(char *stack,
  71                           extended_cif *ecif,
  72                           int bytes,
  73                           int flags)
  74 {
  75   int i;
  76   void **p_argv;
  77   char *argp;
  78   ffi_type **p_arg;
  79
  80 #ifdef FFI_MIPS_N32
  81   /* If more than 8 double words are used, the remainder go
  82      on the stack. We reorder stuff on the stack here to
  83      support this easily. */
  84   if (bytes > 8 * sizeof(ffi_arg))
  85     argp = &stack[bytes - (8 * sizeof(ffi_arg))];
  86   else
  87     argp = stack;
  88 #else
  89   argp = stack;
  90 #endif
  91
  92   memset(stack, 0, bytes);
  93
  94 #ifdef FFI_MIPS_N32
  95   if ( ecif->cif->rstruct_flag != 0 )
  96 #else
  97   if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT )
  98 #endif
  99     {
 100       *(ffi_arg *) argp = (ffi_arg) ecif->rvalue;
 101       argp += sizeof(ffi_arg);
 102       FIX_ARGP;
 103     }
 104
 105   p_argv = ecif->avalue;
 106
 107   for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs; i++, p_arg++)
 108     {
 109       size_t z;
 110       unsigned int a;
 111
 112       /* Align if necessary.  */
 113       a = (*p_arg)->alignment;
 114       if (a < sizeof(ffi_arg))
 115         a = sizeof(ffi_arg);
 116
 117       if ((a - 1) & (unsigned long) argp)
 118         {
 119           argp = (char *) ALIGN(argp, a);
 120           FIX_ARGP;
 121         }
 122
 123       z = (*p_arg)->size;
 124       if (z <= sizeof(ffi_arg))
 125         {
 126           int type = (*p_arg)->type;
 127           z = sizeof(ffi_arg);
 128
 129           /* The size of a pointer depends on the ABI */
 130           if (type == FFI_TYPE_POINTER)
 131             type = (ecif->cif->abi == FFI_N64
 132                     || ecif->cif->abi == FFI_N64_SOFT_FLOAT)
 133               ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
 134
 135         if (i < 8 && (ecif->cif->abi == FFI_N32_SOFT_FLOAT
 136                       || ecif->cif->abi == FFI_N64_SOFT_FLOAT))
 137           {
 138             switch (type)
 139               {
 140               case FFI_TYPE_FLOAT:
 141                 type = FFI_TYPE_UINT32;
 142                 break;
 143               case FFI_TYPE_DOUBLE:
 144                 type = FFI_TYPE_UINT64;
 145                 break;
 146               default:
 147                 break;
 148               }
 149           }
 150           switch (type)
 151             {
 152               case FFI_TYPE_SINT8:
 153                 *(ffi_arg *)argp = *(SINT8 *)(* p_argv);
 154                 break;
 155
 156               case FFI_TYPE_UINT8:
 157                 *(ffi_arg *)argp = *(UINT8 *)(* p_argv);
 158                 break;
 159
 160               case FFI_TYPE_SINT16:
 161                 *(ffi_arg *)argp = *(SINT16 *)(* p_argv);
 162                 break;
 163
 164               case FFI_TYPE_UINT16:
 165                 *(ffi_arg *)argp = *(UINT16 *)(* p_argv);
 166                 break;
 167
 168               case FFI_TYPE_SINT32:
 169                 *(ffi_arg *)argp = *(SINT32 *)(* p_argv);
 170                 break;
 171
 172               case FFI_TYPE_UINT32:
 173 #ifdef FFI_MIPS_N32
 174                 /* The N32 ABI requires that 32-bit integers
 175                    be sign-extended to 64-bits, regardless of
 176                    whether they are signed or unsigned. */
 177                 *(ffi_arg *)argp = *(SINT32 *)(* p_argv);
 178 #else
 179                 *(ffi_arg *)argp = *(UINT32 *)(* p_argv);
 180 #endif
 181                 break;
 182
 183               /* This can only happen with 64bit slots.  */
 184               case FFI_TYPE_FLOAT:
 185                 *(float *) argp = *(float *)(* p_argv);
 186                 break;
 187
 188               /* Handle structures.  */
 189               default:
 190                 memcpy(argp, *p_argv, (*p_arg)->size);
 191                 break;
 192             }
 193         }
 194       else
 195         {
 196 #ifdef FFI_MIPS_O32
 197           memcpy(argp, *p_argv, z);
 198 #else
 199           {
 200             unsigned long end = (unsigned long) argp + z;
 201             unsigned long cap = (unsigned long) stack + bytes;
 202
 203             /* Check if the data will fit within the register space.
 204                Handle it if it doesn't.  */
 205
 206             if (end <= cap)
 207               memcpy(argp, *p_argv, z);
 208             else
 209               {
 210                 unsigned long portion = cap - (unsigned long)argp;
 211
 212                 memcpy(argp, *p_argv, portion);
 213                 argp = stack;
 214                 z -= portion;
 215                 memcpy(argp, (void*)((unsigned long)(*p_argv) + portion),
 216                        z);
 217               }
 218           }
 219 #endif
 220       }
 221       p_argv++;
 222       argp += z;
 223       FIX_ARGP;
 224     }
 225 }
 226
 227 #ifdef FFI_MIPS_N32
 228
 229 /* The n32 spec says that if "a chunk consists solely of a double
 230    float field (but not a double, which is part of a union), it
 231    is passed in a floating point register. Any other chunk is
 232    passed in an integer register". This code traverses structure
 233    definitions and generates the appropriate flags. */
 234
 235 static unsigned
 236 calc_n32_struct_flags(int soft_float, ffi_type *arg,
 237                       unsigned *loc, unsigned *arg_reg)
 238 {
 239   unsigned flags = 0;
 240   unsigned index = 0;
 241
 242   ffi_type *e;
 243
 244   if (soft_float)
 245     return 0;
 246
 247   while ((e = arg->elements[index]))
 248     {
 249       /* Align this object.  */
 250       *loc = ALIGN(*loc, e->alignment);
 251       if (e->type == FFI_TYPE_DOUBLE)
 252         {
 253           /* Already aligned to FFI_SIZEOF_ARG.  */
 254           *arg_reg = *loc / FFI_SIZEOF_ARG;
 255           if (*arg_reg > 7)
 256             break;
 257           flags += (FFI_TYPE_DOUBLE << (*arg_reg * FFI_FLAG_BITS));
 258           *loc += e->size;
 259         }
 260       else
 261         *loc += e->size;
 262       index++;
 263     }
 264   /* Next Argument register at alignment of FFI_SIZEOF_ARG.  */
 265   *arg_reg = ALIGN(*loc, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
 266
 267   return flags;
 268 }
 269
 270 static unsigned
 271 calc_n32_return_struct_flags(int soft_float, ffi_type *arg)
 272 {
 273   unsigned flags = 0;
 274   unsigned small = FFI_TYPE_SMALLSTRUCT;
 275   ffi_type *e;
 276
 277   /* Returning structures under n32 is a tricky thing.
 278      A struct with only one or two floating point fields
 279      is returned in $f0 (and $f2 if necessary). Any other
 280      struct results at most 128 bits are returned in $2
 281      (the first 64 bits) and $3 (remainder, if necessary).
 282      Larger structs are handled normally. */
 283
 284   if (arg->size > 16)
 285     return 0;
 286
 287   if (arg->size > 8)
 288     small = FFI_TYPE_SMALLSTRUCT2;
 289
 290   e = arg->elements[0];
 291
 292   if (e->type == FFI_TYPE_DOUBLE)
 293     flags = FFI_TYPE_DOUBLE;
 294   else if (e->type == FFI_TYPE_FLOAT)
 295     flags = FFI_TYPE_FLOAT;
 296
 297   if (flags && (e = arg->elements[1]))
 298     {
 299       if (e->type == FFI_TYPE_DOUBLE)
 300         flags += FFI_TYPE_DOUBLE << FFI_FLAG_BITS;
 301       else if (e->type == FFI_TYPE_FLOAT)
 302         flags += FFI_TYPE_FLOAT << FFI_FLAG_BITS;
 303       else
 304         return small;
 305
 306       if (flags && (arg->elements[2]))
 307         {
 308           /* There are three arguments and the first two are
 309              floats! This must be passed the old way. */
 310           return small;
 311         }
 312       if (soft_float)
 313         flags += FFI_TYPE_STRUCT_SOFT;
 314     }
 315   else
 316     if (!flags)
 317       return small;
 318
 319   return flags;
 320 }
 321
 322 #endif
 323
 324 /* Perform machine dependent cif processing */
 325 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
 326 {
 327   cif->flags = 0;
 328
 329 #ifdef FFI_MIPS_O32
 330   /* Set the flags necessary for O32 processing.  FFI_O32_SOFT_FLOAT
 331    * does not have special handling for floating point args.
 332    */
 333
 334   if (cif->rtype->type != FFI_TYPE_STRUCT && cif->abi == FFI_O32)
 335     {
 336       if (cif->nargs > 0)
 337         {
 338           switch ((cif->arg_types)[0]->type)
 339             {
 340             case FFI_TYPE_FLOAT:
 341             case FFI_TYPE_DOUBLE:
 342               cif->flags += (cif->arg_types)[0]->type;
 343               break;
 344
 345             default:
 346               break;
 347             }
 348
 349           if (cif->nargs > 1)
 350             {
 351               /* Only handle the second argument if the first
 352                  is a float or double. */
 353               if (cif->flags)
 354                 {
 355                   switch ((cif->arg_types)[1]->type)
 356                     {
 357                     case FFI_TYPE_FLOAT:
 358                     case FFI_TYPE_DOUBLE:
 359                       cif->flags += (cif->arg_types)[1]->type << FFI_FLAG_BITS;
 360                       break;
 361
 362                     default:
 363                       break;
 364                     }
 365                 }
 366             }
 367         }
 368     }
 369
 370   /* Set the return type flag */
 371
 372   if (cif->abi == FFI_O32_SOFT_FLOAT)
 373     {
 374       switch (cif->rtype->type)
 375         {
 376         case FFI_TYPE_VOID:
 377         case FFI_TYPE_STRUCT:
 378           cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
 379           break;
 380
 381         case FFI_TYPE_SINT64:
 382         case FFI_TYPE_UINT64:
 383         case FFI_TYPE_DOUBLE:
 384           cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
 385           break;
 386
 387         case FFI_TYPE_FLOAT:
 388         default:
 389           cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
 390           break;
 391         }
 392     }
 393   else
 394     {
 395       /* FFI_O32 */
 396       switch (cif->rtype->type)
 397         {
 398         case FFI_TYPE_VOID:
 399         case FFI_TYPE_STRUCT:
 400         case FFI_TYPE_FLOAT:
 401         case FFI_TYPE_DOUBLE:
 402           cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
 403           break;
 404
 405         case FFI_TYPE_SINT64:
 406         case FFI_TYPE_UINT64:
 407           cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
 408           break;
 409
 410         default:
 411           cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
 412           break;
 413         }
 414     }
 415 #endif
 416
 417 #ifdef FFI_MIPS_N32
 418   /* Set the flags necessary for N32 processing */
 419   {
 420     int type;
 421     unsigned arg_reg = 0;
 422     unsigned loc = 0;
 423     unsigned count = (cif->nargs < 8) ? cif->nargs : 8;
 424     unsigned index = 0;
 425
 426     unsigned struct_flags = 0;
 427     int soft_float = (cif->abi == FFI_N32_SOFT_FLOAT
 428                       || cif->abi == FFI_N64_SOFT_FLOAT);
 429
 430     if (cif->rtype->type == FFI_TYPE_STRUCT)
 431       {
 432         struct_flags = calc_n32_return_struct_flags(soft_float, cif->rtype);
 433
 434         if (struct_flags == 0)
 435           {
 436             /* This means that the structure is being passed as
 437                a hidden argument */
 438
 439             arg_reg = 1;
 440             count = (cif->nargs < 7) ? cif->nargs : 7;
 441
 442             cif->rstruct_flag = !0;
 443           }
 444         else
 445             cif->rstruct_flag = 0;
 446       }
 447     else
 448       cif->rstruct_flag = 0;
 449
 450     while (count-- > 0 && arg_reg < 8)
 451       {
 452         type = (cif->arg_types)[index]->type;
 453         if (soft_float)
 454           {
 455             switch (type)
 456               {
 457               case FFI_TYPE_FLOAT:
 458                 type = FFI_TYPE_UINT32;
 459                 break;
 460               case FFI_TYPE_DOUBLE:
 461                 type = FFI_TYPE_UINT64;
 462                 break;
 463               default:
 464                 break;
 465               }
 466           }
 467         switch (type)
 468           {
 469           case FFI_TYPE_FLOAT:
 470           case FFI_TYPE_DOUBLE:
 471             cif->flags +=
 472               ((cif->arg_types)[index]->type << (arg_reg * FFI_FLAG_BITS));
 473             arg_reg++;
 474             break;
 475           case FFI_TYPE_LONGDOUBLE:
 476             /* Align it.  */
 477             arg_reg = ALIGN(arg_reg, 2);
 478             /* Treat it as two adjacent doubles.  */
 479             if (soft_float)
 480               {
 481                 arg_reg += 2;
 482               }
 483             else
 484               {
 485                 cif->flags +=
 486                   (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
 487                 arg_reg++;
 488                 cif->flags +=
 489                   (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
 490                 arg_reg++;
 491               }
 492             break;
 493
 494           case FFI_TYPE_STRUCT:
 495             loc = arg_reg * FFI_SIZEOF_ARG;
 496             cif->flags += calc_n32_struct_flags(soft_float,
 497                                                 (cif->arg_types)[index],
 498                                                 &loc, &arg_reg);
 499             break;
 500
 501           default:
 502             arg_reg++;
 503             break;
 504           }
 505
 506         index++;
 507       }
 508
 509   /* Set the return type flag */
 510     switch (cif->rtype->type)
 511       {
 512       case FFI_TYPE_STRUCT:
 513         {
 514           if (struct_flags == 0)
 515             {
 516               /* The structure is returned through a hidden
 517                  first argument. Do nothing, 'cause FFI_TYPE_VOID
 518                  is 0 */
 519             }
 520           else
 521             {
 522               /* The structure is returned via some tricky
 523                  mechanism */
 524               cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
 525               cif->flags += struct_flags << (4 + (FFI_FLAG_BITS * 8));
 526             }
 527           break;
 528         }
 529
 530       case FFI_TYPE_VOID:
 531         /* Do nothing, 'cause FFI_TYPE_VOID is 0 */
 532         break;
 533
 534       case FFI_TYPE_POINTER:
 535         if (cif->abi == FFI_N32_SOFT_FLOAT || cif->abi == FFI_N32)
 536           cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
 537         else
 538           cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
 539         break;
 540
 541       case FFI_TYPE_FLOAT:
 542         if (soft_float)
 543           {
 544             cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
 545             break;
 546           }
 547         /* else fall through */
 548       case FFI_TYPE_DOUBLE:
 549         if (soft_float)
 550           cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
 551         else
 552           cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 8);
 553         break;
 554
 555       case FFI_TYPE_LONGDOUBLE:
 556         /* Long double is returned as if it were a struct containing
 557            two doubles.  */
 558         if (soft_float)
 559           {
 560             cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
 561             cif->flags += FFI_TYPE_SMALLSTRUCT2 << (4 + (FFI_FLAG_BITS * 8));
 562           }
 563         else
 564           {
 565             cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
 566             cif->flags += (FFI_TYPE_DOUBLE
 567                            + (FFI_TYPE_DOUBLE << FFI_FLAG_BITS))
 568                                               << (4 + (FFI_FLAG_BITS * 8));
 569           }
 570         break;
 571       default:
 572         cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
 573         break;
 574       }
 575   }
 576 #endif
 577
 578   return FFI_OK;
 579 }
 580
 581 /* Low level routine for calling O32 functions */
 582 extern int ffi_call_O32(void (*)(char *, extended_cif *, int, int),
 583                         extended_cif *, unsigned,
 584                         unsigned, unsigned *, void (*)(void));
 585
 586 /* Low level routine for calling N32 functions */
 587 extern int ffi_call_N32(void (*)(char *, extended_cif *, int, int),
 588                         extended_cif *, unsigned,
 589                         unsigned, void *, void (*)(void));
 590
 591 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 592 {
 593   extended_cif ecif;
 594
 595   ecif.cif = cif;
 596   ecif.avalue = avalue;
 597
 598   /* If the return value is a struct and we don't have a return */
 599   /* value address then we need to make one                     */
 600
 601   if ((rvalue == NULL) &&
 602       (cif->rtype->type == FFI_TYPE_STRUCT))
 603     ecif.rvalue = alloca(cif->rtype->size);
 604   else
 605     ecif.rvalue = rvalue;
 606
 607   switch (cif->abi)
 608     {
 609 #ifdef FFI_MIPS_O32
 610     case FFI_O32:
 611     case FFI_O32_SOFT_FLOAT:
 612       ffi_call_O32(ffi_prep_args, &ecif, cif->bytes,
 613                    cif->flags, ecif.rvalue, fn);
 614       break;
 615 #endif
 616
 617 #ifdef FFI_MIPS_N32
 618     case FFI_N32:
 619     case FFI_N32_SOFT_FLOAT:
 620     case FFI_N64:
 621     case FFI_N64_SOFT_FLOAT:
 622       {
 623         int copy_rvalue = 0;
 624         int copy_offset = 0;
 625         char *rvalue_copy = ecif.rvalue;
 626         if (cif->rtype->type == FFI_TYPE_STRUCT && cif->rtype->size < 16)
 627           {
 628             /* For structures smaller than 16 bytes we clobber memory
 629                in 8 byte increments.  Make a copy so we don't clobber
 630                the callers memory outside of the struct bounds.  */
 631             rvalue_copy = alloca(16);
 632             copy_rvalue = 1;
 633           }
 634         else if (cif->rtype->type == FFI_TYPE_FLOAT
 635                  && (cif->abi == FFI_N64_SOFT_FLOAT
 636                      || cif->abi == FFI_N32_SOFT_FLOAT))
 637           {
 638             rvalue_copy = alloca (8);
 639             copy_rvalue = 1;
 640 #if defined(__MIPSEB__) || defined(_MIPSEB)
 641             copy_offset = 4;
 642 #endif
 643           }
 644         ffi_call_N32(ffi_prep_args, &ecif, cif->bytes,
 645                      cif->flags, rvalue_copy, fn);
 646         if (copy_rvalue)
 647           memcpy(ecif.rvalue, rvalue_copy + copy_offset, cif->rtype->size);
 648       }
 649       break;
 650 #endif
 651
 652     default:
 653       FFI_ASSERT(0);
 654       break;
 655     }
 656 }
 657
 658 #if FFI_CLOSURES
 659 #if defined(FFI_MIPS_O32)
 660 extern void ffi_closure_O32(void);
 661 #else
 662 extern void ffi_closure_N32(void);
 663 #endif /* FFI_MIPS_O32 */
 664
 665 ffi_status
 666 ffi_prep_closure_loc (ffi_closure *closure,
 667                       ffi_cif *cif,
 668                       void (*fun)(ffi_cif*,void*,void**,void*),
 669                       void *user_data,
 670                       void *codeloc)
 671 {
 672   unsigned int *tramp = (unsigned int *) &closure->tramp[0];
 673   void * fn;
 674   char *clear_location = (char *) codeloc;
 675
 676 #if defined(FFI_MIPS_O32)
 677   if (cif->abi != FFI_O32 && cif->abi != FFI_O32_SOFT_FLOAT)
 678     return FFI_BAD_ABI;
 679   fn = ffi_closure_O32;
 680 #else
 681 #if _MIPS_SIM ==_ABIN32
 682   if (cif->abi != FFI_N32
 683       && cif->abi != FFI_N32_SOFT_FLOAT)
 684     return FFI_BAD_ABI;
 685 #else
 686   if (cif->abi != FFI_N64
 687       && cif->abi != FFI_N64_SOFT_FLOAT)
 688     return FFI_BAD_ABI;
 689 #endif
 690   fn = ffi_closure_N32;
 691 #endif /* FFI_MIPS_O32 */
 692
 693 #if defined(FFI_MIPS_O32) || (_MIPS_SIM ==_ABIN32)
 694   /* lui  $25,high(fn) */
 695   tramp[0] = 0x3c190000 | ((unsigned)fn >> 16);
 696   /* ori  $25,low(fn)  */
 697   tramp[1] = 0x37390000 | ((unsigned)fn & 0xffff);
 698   /* lui  $12,high(codeloc) */
 699   tramp[2] = 0x3c0c0000 | ((unsigned)codeloc >> 16);
 700   /* jr   $25          */
 701   tramp[3] = 0x03200008;
 702   /* ori  $12,low(codeloc)  */
 703   tramp[4] = 0x358c0000 | ((unsigned)codeloc & 0xffff);
 704 #else
 705   /* N64 has a somewhat larger trampoline.  */
 706   /* lui  $25,high(fn) */
 707   tramp[0] = 0x3c190000 | ((unsigned long)fn >> 48);
 708   /* lui  $12,high(codeloc) */
 709   tramp[1] = 0x3c0c0000 | ((unsigned long)codeloc >> 48);
 710   /* ori  $25,mid-high(fn)  */
 711   tramp[2] = 0x37390000 | (((unsigned long)fn >> 32 ) & 0xffff);
 712   /* ori  $12,mid-high(codeloc)  */
 713   tramp[3] = 0x358c0000 | (((unsigned long)codeloc >> 32) & 0xffff);
 714   /* dsll $25,$25,16 */
 715   tramp[4] = 0x0019cc38;
 716   /* dsll $12,$12,16 */
 717   tramp[5] = 0x000c6438;
 718   /* ori  $25,mid-low(fn)  */
 719   tramp[6] = 0x37390000 | (((unsigned long)fn >> 16 ) & 0xffff);
 720   /* ori  $12,mid-low(codeloc)  */
 721   tramp[7] = 0x358c0000 | (((unsigned long)codeloc >> 16) & 0xffff);
 722   /* dsll $25,$25,16 */
 723   tramp[8] = 0x0019cc38;
 724   /* dsll $12,$12,16 */
 725   tramp[9] = 0x000c6438;
 726   /* ori  $25,low(fn)  */
 727   tramp[10] = 0x37390000 | ((unsigned long)fn  & 0xffff);
 728   /* jr   $25          */
 729   tramp[11] = 0x03200008;
 730   /* ori  $12,low(codeloc)  */
 731   tramp[12] = 0x358c0000 | ((unsigned long)codeloc & 0xffff);
 732
 733 #endif
 734
 735   closure->cif = cif;
 736   closure->fun = fun;
 737   closure->user_data = user_data;
 738
 739 #ifdef USE__BUILTIN___CLEAR_CACHE
 740   __builtin___clear_cache(clear_location, clear_location + FFI_TRAMPOLINE_SIZE);
 741 #else
 742   cacheflush (clear_location, FFI_TRAMPOLINE_SIZE, ICACHE);
 743 #endif
 744   return FFI_OK;
 745 }
 746
 747 /*
 748  * Decodes the arguments to a function, which will be stored on the
 749  * stack. AR is the pointer to the beginning of the integer arguments
 750  * (and, depending upon the arguments, some floating-point arguments
 751  * as well). FPR is a pointer to the area where floating point
 752  * registers have been saved, if any.
 753  *
 754  * RVALUE is the location where the function return value will be
 755  * stored. CLOSURE is the prepared closure to invoke.
 756  *
 757  * This function should only be called from assembly, which is in
 758  * turn called from a trampoline.
 759  *
 760  * Returns the function return type.
 761  *
 762  * Based on the similar routine for sparc.
 763  */
 764 int
 765 ffi_closure_mips_inner_O32 (ffi_closure *closure,
 766                             void *rvalue, ffi_arg *ar,
 767                             double *fpr)
 768 {
 769   ffi_cif *cif;
 770   void **avaluep;
 771   ffi_arg *avalue;
 772   ffi_type **arg_types;
 773   int i, avn, argn, seen_int;
 774
 775   cif = closure->cif;
 776   avalue = alloca (cif->nargs * sizeof (ffi_arg));
 777   avaluep = alloca (cif->nargs * sizeof (ffi_arg));
 778
 779   seen_int = (cif->abi == FFI_O32_SOFT_FLOAT);
 780   argn = 0;
 781
 782   if ((cif->flags >> (FFI_FLAG_BITS * 2)) == FFI_TYPE_STRUCT)
 783     {
 784       rvalue = (void *)(UINT32)ar[0];
 785       argn = 1;
 786     }
 787
 788   i = 0;
 789   avn = cif->nargs;
 790   arg_types = cif->arg_types;
 791
 792   while (i < avn)
 793     {
 794       if (i < 2 && !seen_int &&
 795           (arg_types[i]->type == FFI_TYPE_FLOAT ||
 796            arg_types[i]->type == FFI_TYPE_DOUBLE ||
 797            arg_types[i]->type == FFI_TYPE_LONGDOUBLE))
 798         {
 799 #if defined(__MIPSEB__) || defined(_MIPSEB)
 800           if (arg_types[i]->type == FFI_TYPE_FLOAT)
 801             avaluep[i] = ((char *) &fpr[i]) + sizeof (float);
 802           else
 803 #endif
 804             avaluep[i] = (char *) &fpr[i];
 805         }
 806       else
 807         {
 808           if (arg_types[i]->alignment == 8 && (argn & 0x1))
 809             argn++;
 810           switch (arg_types[i]->type)
 811             {
 812               case FFI_TYPE_SINT8:
 813                 avaluep[i] = &avalue[i];
 814                 *(SINT8 *) &avalue[i] = (SINT8) ar[argn];
 815                 break;
 816
 817               case FFI_TYPE_UINT8:
 818                 avaluep[i] = &avalue[i];
 819                 *(UINT8 *) &avalue[i] = (UINT8) ar[argn];
 820                 break;
 821
 822               case FFI_TYPE_SINT16:
 823                 avaluep[i] = &avalue[i];
 824                 *(SINT16 *) &avalue[i] = (SINT16) ar[argn];
 825                 break;
 826
 827               case FFI_TYPE_UINT16:
 828                 avaluep[i] = &avalue[i];
 829                 *(UINT16 *) &avalue[i] = (UINT16) ar[argn];
 830                 break;
 831
 832               default:
 833                 avaluep[i] = (char *) &ar[argn];
 834                 break;
 835             }
 836           seen_int = 1;
 837         }
 838       argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
 839       i++;
 840     }
 841
 842   /* Invoke the closure. */
 843   (closure->fun) (cif, rvalue, avaluep, closure->user_data);
 844
 845   if (cif->abi == FFI_O32_SOFT_FLOAT)
 846     {
 847       switch (cif->rtype->type)
 848         {
 849         case FFI_TYPE_FLOAT:
 850           return FFI_TYPE_INT;
 851         case FFI_TYPE_DOUBLE:
 852           return FFI_TYPE_UINT64;
 853         default:
 854           return cif->rtype->type;
 855         }
 856     }
 857   else
 858     {
 859       return cif->rtype->type;
 860     }
 861 }
 862
 863 #if defined(FFI_MIPS_N32)
 864
 865 static void
 866 copy_struct_N32(char *target, unsigned offset, ffi_abi abi, ffi_type *type,
 867                 int argn, unsigned arg_offset, ffi_arg *ar,
 868                 ffi_arg *fpr, int soft_float)
 869 {
 870   ffi_type **elt_typep = type->elements;
 871   while(*elt_typep)
 872     {
 873       ffi_type *elt_type = *elt_typep;
 874       unsigned o;
 875       char *tp;
 876       char *argp;
 877       char *fpp;
 878
 879       o = ALIGN(offset, elt_type->alignment);
 880       arg_offset += o - offset;
 881       offset = o;
 882       argn += arg_offset / sizeof(ffi_arg);
 883       arg_offset = arg_offset % sizeof(ffi_arg);
 884
 885       argp = (char *)(ar + argn);
 886       fpp = (char *)(argn >= 8 ? ar + argn : fpr + argn);
 887
 888       tp = target + offset;
 889
 890       if (elt_type->type == FFI_TYPE_DOUBLE && !soft_float)
 891         *(double *)tp = *(double *)fpp;
 892       else
 893         memcpy(tp, argp + arg_offset, elt_type->size);
 894
 895       offset += elt_type->size;
 896       arg_offset += elt_type->size;
 897       elt_typep++;
 898       argn += arg_offset / sizeof(ffi_arg);
 899       arg_offset = arg_offset % sizeof(ffi_arg);
 900     }
 901 }
 902
 903 /*
 904  * Decodes the arguments to a function, which will be stored on the
 905  * stack. AR is the pointer to the beginning of the integer
 906  * arguments. FPR is a pointer to the area where floating point
 907  * registers have been saved.
 908  *
 909  * RVALUE is the location where the function return value will be
 910  * stored. CLOSURE is the prepared closure to invoke.
 911  *
 912  * This function should only be called from assembly, which is in
 913  * turn called from a trampoline.
 914  *
 915  * Returns the function return flags.
 916  *
 917  */
 918 int
 919 ffi_closure_mips_inner_N32 (ffi_closure *closure,
 920                             void *rvalue, ffi_arg *ar,
 921                             ffi_arg *fpr)
 922 {
 923   ffi_cif *cif;
 924   void **avaluep;
 925   ffi_arg *avalue;
 926   ffi_type **arg_types;
 927   int i, avn, argn;
 928   int soft_float;
 929   ffi_arg *argp;
 930
 931   cif = closure->cif;
 932   soft_float = cif->abi == FFI_N64_SOFT_FLOAT
 933     || cif->abi == FFI_N32_SOFT_FLOAT;
 934   avalue = alloca (cif->nargs * sizeof (ffi_arg));
 935   avaluep = alloca (cif->nargs * sizeof (ffi_arg));
 936
 937   argn = 0;
 938
 939   if (cif->rstruct_flag)
 940     {
 941 #if _MIPS_SIM==_ABIN32
 942       rvalue = (void *)(UINT32)ar[0];
 943 #else /* N64 */
 944       rvalue = (void *)ar[0];
 945 #endif
 946       argn = 1;
 947     }
 948
 949   i = 0;
 950   avn = cif->nargs;
 951   arg_types = cif->arg_types;
 952
 953   while (i < avn)
 954     {
 955       if (arg_types[i]->type == FFI_TYPE_FLOAT
 956           || arg_types[i]->type == FFI_TYPE_DOUBLE
 957           || arg_types[i]->type == FFI_TYPE_LONGDOUBLE)
 958         {
 959           argp = (argn >= 8 || soft_float) ? ar + argn : fpr + argn;
 960           if ((arg_types[i]->type == FFI_TYPE_LONGDOUBLE) && ((unsigned)argp & (arg_types[i]->alignment-1)))
 961             {
 962               argp=(ffi_arg*)ALIGN(argp,arg_types[i]->alignment);
 963               argn++;
 964             }
 965 #if defined(__MIPSEB__) || defined(_MIPSEB)
 966           if (arg_types[i]->type == FFI_TYPE_FLOAT && argn < 8)
 967             avaluep[i] = ((char *) argp) + sizeof (float);
 968           else
 969 #endif
 970             avaluep[i] = (char *) argp;
 971         }
 972       else
 973         {
 974           unsigned type = arg_types[i]->type;
 975
 976           if (arg_types[i]->alignment > sizeof(ffi_arg))
 977             argn = ALIGN(argn, arg_types[i]->alignment / sizeof(ffi_arg));
 978
 979           argp = ar + argn;
 980
 981           /* The size of a pointer depends on the ABI */
 982           if (type == FFI_TYPE_POINTER)
 983             type = (cif->abi == FFI_N64 || cif->abi == FFI_N64_SOFT_FLOAT)
 984               ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
 985
 986           if (soft_float && type ==  FFI_TYPE_FLOAT)
 987             type = FFI_TYPE_UINT32;
 988
 989           switch (type)
 990             {
 991             case FFI_TYPE_SINT8:
 992               avaluep[i] = &avalue[i];
 993               *(SINT8 *) &avalue[i] = (SINT8) *argp;
 994               break;
 995
 996             case FFI_TYPE_UINT8:
 997               avaluep[i] = &avalue[i];
 998               *(UINT8 *) &avalue[i] = (UINT8) *argp;
 999               break;
1000
1001             case FFI_TYPE_SINT16:
1002               avaluep[i] = &avalue[i];
1003               *(SINT16 *) &avalue[i] = (SINT16) *argp;
1004               break;
1005
1006             case FFI_TYPE_UINT16:
1007               avaluep[i] = &avalue[i];
1008               *(UINT16 *) &avalue[i] = (UINT16) *argp;
1009               break;
1010
1011             case FFI_TYPE_SINT32:
1012               avaluep[i] = &avalue[i];
1013               *(SINT32 *) &avalue[i] = (SINT32) *argp;
1014               break;
1015
1016             case FFI_TYPE_UINT32:
1017               avaluep[i] = &avalue[i];
1018               *(UINT32 *) &avalue[i] = (UINT32) *argp;
1019               break;
1020
1021             case FFI_TYPE_STRUCT:
1022               if (argn < 8)
1023                 {
1024                   /* Allocate space for the struct as at least part of
1025                      it was passed in registers.  */
1026                   avaluep[i] = alloca(arg_types[i]->size);
1027                   copy_struct_N32(avaluep[i], 0, cif->abi, arg_types[i],
1028                                   argn, 0, ar, fpr, soft_float);
1029
1030                   break;
1031                 }
1032               /* Else fall through.  */
1033             default:
1034               avaluep[i] = (char *) argp;
1035               break;
1036             }
1037         }
1038       argn += ALIGN(arg_types[i]->size, sizeof(ffi_arg)) / sizeof(ffi_arg);
1039       i++;
1040     }
1041
1042   /* Invoke the closure. */
1043   (closure->fun) (cif, rvalue, avaluep, closure->user_data);
1044
1045   return cif->flags >> (FFI_FLAG_BITS * 8);
1046 }
1047
1048 #endif /* FFI_MIPS_N32 */
1049
1050 #endif /* FFI_CLOSURES */