src/sh/ffi.c

   1 /* -----------------------------------------------------------------------
   2    ffi.c - Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Kaz Kojima
   3            Copyright (c) 2008 Red Hat, Inc.
   4
   5    SuperH Foreign Function Interface
   6
   7    Permission is hereby granted, free of charge, to any person obtaining
   8    a copy of this software and associated documentation files (the
   9    ``Software''), to deal in the Software without restriction, including
  10    without limitation the rights to use, copy, modify, merge, publish,
  11    distribute, sublicense, and/or sell copies of the Software, and to
  12    permit persons to whom the Software is furnished to do so, subject to
  13    the following conditions:
  14
  15    The above copyright notice and this permission notice shall be included
  16    in all copies or substantial portions of the Software.
  17
  18    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  19    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25    DEALINGS IN THE SOFTWARE.
  26    ----------------------------------------------------------------------- */
  27
  28 #include <ffi.h>
  29 #include <ffi_common.h>
  30
  31 #include <stdlib.h>
  32
  33 #define NGREGARG 4
  34 #if defined(__SH4__)
  35 #define NFREGARG 8
  36 #endif
  37
  38 #if defined(__HITACHI__)
  39 #define STRUCT_VALUE_ADDRESS_WITH_ARG 1
  40 #else
  41 #define STRUCT_VALUE_ADDRESS_WITH_ARG 0
  42 #endif
  43
  44 /* If the structure has essentialy an unique element, return its type.  */
  45 static int
  46 simple_type (ffi_type *arg)
  47 {
  48   if (arg->type != FFI_TYPE_STRUCT)
  49     return arg->type;
  50   else if (arg->elements[1])
  51     return FFI_TYPE_STRUCT;
  52
  53   return simple_type (arg->elements[0]);
  54 }
  55
  56 static int
  57 return_type (ffi_type *arg)
  58 {
  59   unsigned short type;
  60
  61   if (arg->type != FFI_TYPE_STRUCT)
  62     return arg->type;
  63
  64   type = simple_type (arg->elements[0]);
  65   if (! arg->elements[1])
  66     {
  67       switch (type)
  68         {
  69         case FFI_TYPE_SINT8:
  70         case FFI_TYPE_UINT8:
  71         case FFI_TYPE_SINT16:
  72         case FFI_TYPE_UINT16:
  73         case FFI_TYPE_SINT32:
  74         case FFI_TYPE_UINT32:
  75           return FFI_TYPE_INT;
  76
  77         default:
  78           return type;
  79         }
  80     }
  81
  82   /* gcc uses r0/r1 pair for some kind of structures.  */
  83   if (arg->size <= 2 * sizeof (int))
  84     {
  85       int i = 0;
  86       ffi_type *e;
  87
  88       while ((e = arg->elements[i++]))
  89         {
  90           type = simple_type (e);
  91           switch (type)
  92             {
  93             case FFI_TYPE_SINT32:
  94             case FFI_TYPE_UINT32:
  95             case FFI_TYPE_INT:
  96             case FFI_TYPE_FLOAT:
  97               return FFI_TYPE_UINT64;
  98
  99             default:
 100               break;
 101             }
 102         }
 103     }
 104
 105   return FFI_TYPE_STRUCT;
 106 }
 107
 108 /* ffi_prep_args is called by the assembly routine once stack space
 109    has been allocated for the function's arguments */
 110
 111 void ffi_prep_args(char *stack, extended_cif *ecif)
 112 {
 113   register unsigned int i;
 114   register int tmp;
 115   register unsigned int avn;
 116   register void **p_argv;
 117   register char *argp;
 118   register ffi_type **p_arg;
 119   int greg, ireg;
 120 #if defined(__SH4__)
 121   int freg = 0;
 122 #endif
 123
 124   tmp = 0;
 125   argp = stack;
 126
 127   if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT)
 128     {
 129       *(void **) argp = ecif->rvalue;
 130       argp += 4;
 131       ireg = STRUCT_VALUE_ADDRESS_WITH_ARG ? 1 : 0;
 132     }
 133   else
 134     ireg = 0;
 135
 136   /* Set arguments for registers.  */
 137   greg = ireg;
 138   avn = ecif->cif->nargs;
 139   p_argv = ecif->avalue;
 140
 141   for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)
 142     {
 143       size_t z;
 144
 145       z = (*p_arg)->size;
 146       if (z < sizeof(int))
 147         {
 148           if (greg++ >= NGREGARG)
 149             continue;
 150
 151           z = sizeof(int);
 152           switch ((*p_arg)->type)
 153             {
 154             case FFI_TYPE_SINT8:
 155               *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
 156               break;
 157
 158             case FFI_TYPE_UINT8:
 159               *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
 160               break;
 161
 162             case FFI_TYPE_SINT16:
 163               *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
 164               break;
 165
 166             case FFI_TYPE_UINT16:
 167               *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
 168               break;
 169
 170             case FFI_TYPE_STRUCT:
 171               *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
 172               break;
 173
 174             default:
 175               FFI_ASSERT(0);
 176             }
 177           argp += z;
 178         }
 179       else if (z == sizeof(int))
 180         {
 181 #if defined(__SH4__)
 182           if ((*p_arg)->type == FFI_TYPE_FLOAT)
 183             {
 184               if (freg++ >= NFREGARG)
 185                 continue;
 186             }
 187           else
 188 #endif
 189             {
 190               if (greg++ >= NGREGARG)
 191                 continue;
 192             }
 193           *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
 194           argp += z;
 195         }
 196 #if defined(__SH4__)
 197       else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
 198         {
 199           if (freg + 1 >= NFREGARG)
 200             continue;
 201           freg = (freg + 1) & ~1;
 202           freg += 2;
 203           memcpy (argp, *p_argv, z);
 204           argp += z;
 205         }
 206 #endif
 207       else
 208         {
 209           int n = (z + sizeof (int) - 1) / sizeof (int);
 210 #if defined(__SH4__)
 211           if (greg + n - 1 >= NGREGARG)
 212             continue;
 213 #else
 214           if (greg >= NGREGARG)
 215             continue;
 216 #endif
 217           greg += n;
 218           memcpy (argp, *p_argv, z);
 219           argp += n * sizeof (int);
 220         }
 221     }
 222
 223   /* Set arguments on stack.  */
 224   greg = ireg;
 225 #if defined(__SH4__)
 226   freg = 0;
 227 #endif
 228   p_argv = ecif->avalue;
 229
 230   for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)
 231     {
 232       size_t z;
 233
 234       z = (*p_arg)->size;
 235       if (z < sizeof(int))
 236         {
 237           if (greg++ < NGREGARG)
 238             continue;
 239
 240           z = sizeof(int);
 241           switch ((*p_arg)->type)
 242             {
 243             case FFI_TYPE_SINT8:
 244               *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
 245               break;
 246
 247             case FFI_TYPE_UINT8:
 248               *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
 249               break;
 250
 251             case FFI_TYPE_SINT16:
 252               *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
 253               break;
 254
 255             case FFI_TYPE_UINT16:
 256               *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
 257               break;
 258
 259             case FFI_TYPE_STRUCT:
 260               *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
 261               break;
 262
 263             default:
 264               FFI_ASSERT(0);
 265             }
 266           argp += z;
 267         }
 268       else if (z == sizeof(int))
 269         {
 270 #if defined(__SH4__)
 271           if ((*p_arg)->type == FFI_TYPE_FLOAT)
 272             {
 273               if (freg++ < NFREGARG)
 274                 continue;
 275             }
 276           else
 277 #endif
 278             {
 279               if (greg++ < NGREGARG)
 280                 continue;
 281             }
 282           *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
 283           argp += z;
 284         }
 285 #if defined(__SH4__)
 286       else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
 287         {
 288           if (freg + 1 < NFREGARG)
 289             {
 290               freg = (freg + 1) & ~1;
 291               freg += 2;
 292               continue;
 293             }
 294           memcpy (argp, *p_argv, z);
 295           argp += z;
 296         }
 297 #endif
 298       else
 299         {
 300           int n = (z + sizeof (int) - 1) / sizeof (int);
 301           if (greg + n - 1 < NGREGARG)
 302             {
 303               greg += n;
 304               continue;
 305             }
 306 #if (! defined(__SH4__))
 307           else if (greg < NGREGARG)
 308             {
 309               greg = NGREGARG;
 310               continue;
 311             }
 312 #endif
 313           memcpy (argp, *p_argv, z);
 314           argp += n * sizeof (int);
 315         }
 316     }
 317
 318   return;
 319 }
 320
 321 /* Perform machine dependent cif processing */
 322 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
 323 {
 324   int i, j;
 325   int size, type;
 326   int n, m;
 327   int greg;
 328 #if defined(__SH4__)
 329   int freg = 0;
 330 #endif
 331
 332   cif->flags = 0;
 333
 334   greg = ((return_type (cif->rtype) == FFI_TYPE_STRUCT) &&
 335           STRUCT_VALUE_ADDRESS_WITH_ARG) ? 1 : 0;
 336
 337 #if defined(__SH4__)
 338   for (i = j = 0; i < cif->nargs && j < 12; i++)
 339     {
 340       type = (cif->arg_types)[i]->type;
 341       switch (type)
 342         {
 343         case FFI_TYPE_FLOAT:
 344           if (freg >= NFREGARG)
 345             continue;
 346           freg++;
 347           cif->flags += ((cif->arg_types)[i]->type) << (2 * j);
 348           j++;
 349           break;
 350
 351         case FFI_TYPE_DOUBLE:
 352           if ((freg + 1) >= NFREGARG)
 353             continue;
 354           freg = (freg + 1) & ~1;
 355           freg += 2;
 356           cif->flags += ((cif->arg_types)[i]->type) << (2 * j);
 357           j++;
 358           break;
 359
 360         default:
 361           size = (cif->arg_types)[i]->size;
 362           n = (size + sizeof (int) - 1) / sizeof (int);
 363           if (greg + n - 1 >= NGREGARG)
 364                 continue;
 365           greg += n;
 366           for (m = 0; m < n; m++)
 367             cif->flags += FFI_TYPE_INT << (2 * j++);
 368           break;
 369         }
 370     }
 371 #else
 372   for (i = j = 0; i < cif->nargs && j < 4; i++)
 373     {
 374       size = (cif->arg_types)[i]->size;
 375       n = (size + sizeof (int) - 1) / sizeof (int);
 376       if (greg >= NGREGARG)
 377         continue;
 378       else if (greg + n - 1 >= NGREGARG)
 379         n = NGREGARG - greg;
 380       greg += n;
 381       for (m = 0; m < n; m++)
 382         cif->flags += FFI_TYPE_INT << (2 * j++);
 383     }
 384 #endif
 385
 386   /* Set the return type flag */
 387   switch (cif->rtype->type)
 388     {
 389     case FFI_TYPE_STRUCT:
 390       cif->flags += (unsigned) (return_type (cif->rtype)) << 24;
 391       break;
 392
 393     case FFI_TYPE_VOID:
 394     case FFI_TYPE_FLOAT:
 395     case FFI_TYPE_DOUBLE:
 396     case FFI_TYPE_SINT64:
 397     case FFI_TYPE_UINT64:
 398       cif->flags += (unsigned) cif->rtype->type << 24;
 399       break;
 400
 401     default:
 402       cif->flags += FFI_TYPE_INT << 24;
 403       break;
 404     }
 405
 406   return FFI_OK;
 407 }
 408
 409 extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *,
 410                           unsigned, unsigned, unsigned *, void (*fn)(void));
 411
 412 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 413 {
 414   extended_cif ecif;
 415   UINT64 trvalue;
 416
 417   ecif.cif = cif;
 418   ecif.avalue = avalue;
 419
 420   /* If the return value is a struct and we don't have a return */
 421   /* value address then we need to make one                     */
 422
 423   if (cif->rtype->type == FFI_TYPE_STRUCT
 424       && return_type (cif->rtype) != FFI_TYPE_STRUCT)
 425     ecif.rvalue = &trvalue;
 426   else if ((rvalue == NULL) &&
 427       (cif->rtype->type == FFI_TYPE_STRUCT))
 428     {
 429       ecif.rvalue = alloca(cif->rtype->size);
 430     }
 431   else
 432     ecif.rvalue = rvalue;
 433
 434   switch (cif->abi)
 435     {
 436     case FFI_SYSV:
 437       ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
 438                     fn);
 439       break;
 440     default:
 441       FFI_ASSERT(0);
 442       break;
 443     }
 444
 445   if (rvalue
 446       && cif->rtype->type == FFI_TYPE_STRUCT
 447       && return_type (cif->rtype) != FFI_TYPE_STRUCT)
 448     memcpy (rvalue, &trvalue, cif->rtype->size);
 449 }
 450
 451 extern void ffi_closure_SYSV (void);
 452 #if defined(__SH4__)
 453 extern void __ic_invalidate (void *line);
 454 #endif
 455
 456 ffi_status
 457 ffi_prep_closure_loc (ffi_closure* closure,
 458                       ffi_cif* cif,
 459                       void (*fun)(ffi_cif*, void*, void**, void*),
 460                       void *user_data,
 461                       void *codeloc)
 462 {
 463   unsigned int *tramp;
 464   unsigned int insn;
 465
 466   FFI_ASSERT (cif->abi == FFI_GCC_SYSV);
 467
 468   tramp = (unsigned int *) &closure->tramp[0];
 469   /* Set T bit if the function returns a struct pointed with R2.  */
 470   insn = (return_type (cif->rtype) == FFI_TYPE_STRUCT
 471           ? 0x0018 /* sett */
 472           : 0x0008 /* clrt */);
 473
 474 #ifdef __LITTLE_ENDIAN__
 475   tramp[0] = 0xd301d102;
 476   tramp[1] = 0x0000412b | (insn << 16);
 477 #else
 478   tramp[0] = 0xd102d301;
 479   tramp[1] = 0x412b0000 | insn;
 480 #endif
 481   *(void **) &tramp[2] = (void *)codeloc;          /* ctx */
 482   *(void **) &tramp[3] = (void *)ffi_closure_SYSV; /* funaddr */
 483
 484   closure->cif = cif;
 485   closure->fun = fun;
 486   closure->user_data = user_data;
 487
 488 #if defined(__SH4__)
 489   /* Flush the icache.  */
 490   __ic_invalidate(codeloc);
 491 #endif
 492
 493   return FFI_OK;
 494 }
 495
 496 /* Basically the trampoline invokes ffi_closure_SYSV, and on
 497  * entry, r3 holds the address of the closure.
 498  * After storing the registers that could possibly contain
 499  * parameters to be passed into the stack frame and setting
 500  * up space for a return value, ffi_closure_SYSV invokes the
 501  * following helper function to do most of the work.
 502  */
 503
 504 #ifdef __LITTLE_ENDIAN__
 505 #define OFS_INT8        0
 506 #define OFS_INT16       0
 507 #else
 508 #define OFS_INT8        3
 509 #define OFS_INT16       2
 510 #endif
 511
 512 int
 513 ffi_closure_helper_SYSV (ffi_closure *closure, void *rvalue,
 514                          unsigned long *pgr, unsigned long *pfr,
 515                          unsigned long *pst)
 516 {
 517   void **avalue;
 518   ffi_type **p_arg;
 519   int i, avn;
 520   int ireg, greg = 0;
 521 #if defined(__SH4__)
 522   int freg = 0;
 523 #endif
 524   ffi_cif *cif;
 525
 526   cif = closure->cif;
 527   avalue = alloca(cif->nargs * sizeof(void *));
 528
 529   /* Copy the caller's structure return value address so that the closure
 530      returns the data directly to the caller.  */
 531   if (cif->rtype->type == FFI_TYPE_STRUCT && STRUCT_VALUE_ADDRESS_WITH_ARG)
 532     {
 533       rvalue = (void *) *pgr++;
 534       ireg = 1;
 535     }
 536   else
 537     ireg = 0;
 538
 539   cif = closure->cif;
 540   greg = ireg;
 541   avn = cif->nargs;
 542
 543   /* Grab the addresses of the arguments from the stack frame.  */
 544   for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
 545     {
 546       size_t z;
 547
 548       z = (*p_arg)->size;
 549       if (z < sizeof(int))
 550         {
 551           if (greg++ >= NGREGARG)
 552             continue;
 553
 554           z = sizeof(int);
 555           switch ((*p_arg)->type)
 556             {
 557             case FFI_TYPE_SINT8:
 558             case FFI_TYPE_UINT8:
 559               avalue[i] = (((char *)pgr) + OFS_INT8);
 560               break;
 561
 562             case FFI_TYPE_SINT16:
 563             case FFI_TYPE_UINT16:
 564               avalue[i] = (((char *)pgr) + OFS_INT16);
 565               break;
 566
 567             case FFI_TYPE_STRUCT:
 568               avalue[i] = pgr;
 569               break;
 570
 571             default:
 572               FFI_ASSERT(0);
 573             }
 574           pgr++;
 575         }
 576       else if (z == sizeof(int))
 577         {
 578 #if defined(__SH4__)
 579           if ((*p_arg)->type == FFI_TYPE_FLOAT)
 580             {
 581               if (freg++ >= NFREGARG)
 582                 continue;
 583               avalue[i] = pfr;
 584               pfr++;
 585             }
 586           else
 587 #endif
 588             {
 589               if (greg++ >= NGREGARG)
 590                 continue;
 591               avalue[i] = pgr;
 592               pgr++;
 593             }
 594         }
 595 #if defined(__SH4__)
 596       else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
 597         {
 598           if (freg + 1 >= NFREGARG)
 599             continue;
 600           if (freg & 1)
 601             pfr++;
 602           freg = (freg + 1) & ~1;
 603           freg += 2;
 604           avalue[i] = pfr;
 605           pfr += 2;
 606         }
 607 #endif
 608       else
 609         {
 610           int n = (z + sizeof (int) - 1) / sizeof (int);
 611 #if defined(__SH4__)
 612           if (greg + n - 1 >= NGREGARG)
 613             continue;
 614 #else
 615           if (greg >= NGREGARG)
 616             continue;
 617 #endif
 618           greg += n;
 619           avalue[i] = pgr;
 620           pgr += n;
 621         }
 622     }
 623
 624   greg = ireg;
 625 #if defined(__SH4__)
 626   freg = 0;
 627 #endif
 628
 629   for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
 630     {
 631       size_t z;
 632
 633       z = (*p_arg)->size;
 634       if (z < sizeof(int))
 635         {
 636           if (greg++ < NGREGARG)
 637             continue;
 638
 639           z = sizeof(int);
 640           switch ((*p_arg)->type)
 641             {
 642             case FFI_TYPE_SINT8:
 643             case FFI_TYPE_UINT8:
 644               avalue[i] = (((char *)pst) + OFS_INT8);
 645               break;
 646
 647             case FFI_TYPE_SINT16:
 648             case FFI_TYPE_UINT16:
 649               avalue[i] = (((char *)pst) + OFS_INT16);
 650               break;
 651
 652             case FFI_TYPE_STRUCT:
 653               avalue[i] = pst;
 654               break;
 655
 656             default:
 657               FFI_ASSERT(0);
 658             }
 659           pst++;
 660         }
 661       else if (z == sizeof(int))
 662         {
 663 #if defined(__SH4__)
 664           if ((*p_arg)->type == FFI_TYPE_FLOAT)
 665             {
 666               if (freg++ < NFREGARG)
 667                 continue;
 668             }
 669           else
 670 #endif
 671             {
 672               if (greg++ < NGREGARG)
 673                 continue;
 674             }
 675           avalue[i] = pst;
 676           pst++;
 677         }
 678 #if defined(__SH4__)
 679       else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
 680         {
 681           if (freg + 1 < NFREGARG)
 682             {
 683               freg = (freg + 1) & ~1;
 684               freg += 2;
 685               continue;
 686             }
 687           avalue[i] = pst;
 688           pst += 2;
 689         }
 690 #endif
 691       else
 692         {
 693           int n = (z + sizeof (int) - 1) / sizeof (int);
 694           if (greg + n - 1 < NGREGARG)
 695             {
 696               greg += n;
 697               continue;
 698             }
 699 #if (! defined(__SH4__))
 700           else if (greg < NGREGARG)
 701             {
 702               greg += n;
 703               pst += greg - NGREGARG;
 704               continue;
 705             }
 706 #endif
 707           avalue[i] = pst;
 708           pst += n;
 709         }
 710     }
 711
 712   (closure->fun) (cif, rvalue, avalue, closure->user_data);
 713
 714   /* Tell ffi_closure_SYSV how to perform return type promotions.  */
 715   return return_type (cif->rtype);
 716 }