libffi/src/powerpc/ffi_linux64.c

   1 /* -----------------------------------------------------------------------
   2    ffi_linux64.c - Copyright (C) 2013 IBM
   3                    Copyright (C) 2011 Anthony Green
   4                    Copyright (C) 2011 Kyle Moffett
   5                    Copyright (C) 2008 Red Hat, Inc
   6                    Copyright (C) 2007, 2008 Free Software Foundation, Inc
   7                    Copyright (c) 1998 Geoffrey Keating
   8
   9    PowerPC Foreign Function Interface
  10
  11    Permission is hereby granted, free of charge, to any person obtaining
  12    a copy of this software and associated documentation files (the
  13    ``Software''), to deal in the Software without restriction, including
  14    without limitation the rights to use, copy, modify, merge, publish,
  15    distribute, sublicense, and/or sell copies of the Software, and to
  16    permit persons to whom the Software is furnished to do so, subject to
  17    the following conditions:
  18
  19    The above copyright notice and this permission notice shall be included
  20    in all copies or substantial portions of the Software.
  21
  22    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
  26    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  27    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  28    OTHER DEALINGS IN THE SOFTWARE.
  29    ----------------------------------------------------------------------- */
  30
  31 #include "ffi.h"
  32
  33 #ifdef POWERPC64
  34 #include "ffi_common.h"
  35 #include "ffi_powerpc.h"
  36
  37
  38 /* About the LINUX64 ABI.  */
  39 enum {
  40   NUM_GPR_ARG_REGISTERS64 = 8,
  41   NUM_FPR_ARG_REGISTERS64 = 13
  42 };
  43 enum { ASM_NEEDS_REGISTERS64 = 4 };
  44
  45
  46 #if HAVE_LONG_DOUBLE_VARIANT && FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
  47 /* Adjust size of ffi_type_longdouble.  */
  48 void FFI_HIDDEN
  49 ffi_prep_types_linux64 (ffi_abi abi)
  50 {
  51   if ((abi & (FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128)) == FFI_LINUX)
  52     {
  53       ffi_type_longdouble.size = 8;
  54       ffi_type_longdouble.alignment = 8;
  55     }
  56   else
  57     {
  58       ffi_type_longdouble.size = 16;
  59       ffi_type_longdouble.alignment = 16;
  60     }
  61 }
  62 #endif
  63
  64
  65 #if _CALL_ELF == 2
  66 static unsigned int
  67 discover_homogeneous_aggregate (const ffi_type *t, unsigned int *elnum)
  68 {
  69   switch (t->type)
  70     {
  71     case FFI_TYPE_FLOAT:
  72     case FFI_TYPE_DOUBLE:
  73       *elnum = 1;
  74       return (int) t->type;
  75
  76     case FFI_TYPE_STRUCT:;
  77       {
  78         unsigned int base_elt = 0, total_elnum = 0;
  79         ffi_type **el = t->elements;
  80         while (*el)
  81           {
  82             unsigned int el_elt, el_elnum = 0;
  83             el_elt = discover_homogeneous_aggregate (*el, &el_elnum);
  84             if (el_elt == 0
  85                 || (base_elt && base_elt != el_elt))
  86               return 0;
  87             base_elt = el_elt;
  88             total_elnum += el_elnum;
  89             if (total_elnum > 8)
  90               return 0;
  91             el++;
  92           }
  93         *elnum = total_elnum;
  94         return base_elt;
  95       }
  96
  97     default:
  98       return 0;
  99     }
 100 }
 101 #endif
 102
 103
 104 /* Perform machine dependent cif processing */
 105 static ffi_status
 106 ffi_prep_cif_linux64_core (ffi_cif *cif)
 107 {
 108   ffi_type **ptr;
 109   unsigned bytes;
 110   unsigned i, fparg_count = 0, intarg_count = 0;
 111   unsigned flags = cif->flags;
 112 #if _CALL_ELF == 2
 113   unsigned int elt, elnum;
 114 #endif
 115
 116 #if FFI_TYPE_LONGDOUBLE == FFI_TYPE_DOUBLE
 117   /* If compiled without long double support..  */
 118   if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
 119     return FFI_BAD_ABI;
 120 #endif
 121
 122   /* The machine-independent calculation of cif->bytes doesn't work
 123      for us.  Redo the calculation.  */
 124 #if _CALL_ELF == 2
 125   /* Space for backchain, CR, LR, TOC and the asm's temp regs.  */
 126   bytes = (4 + ASM_NEEDS_REGISTERS64) * sizeof (long);
 127
 128   /* Space for the general registers.  */
 129   bytes += NUM_GPR_ARG_REGISTERS64 * sizeof (long);
 130 #else
 131   /* Space for backchain, CR, LR, cc/ld doubleword, TOC and the asm's temp
 132      regs.  */
 133   bytes = (6 + ASM_NEEDS_REGISTERS64) * sizeof (long);
 134
 135   /* Space for the mandatory parm save area and general registers.  */
 136   bytes += 2 * NUM_GPR_ARG_REGISTERS64 * sizeof (long);
 137 #endif
 138
 139   /* Return value handling.  */
 140   switch (cif->rtype->type)
 141     {
 142 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 143     case FFI_TYPE_LONGDOUBLE:
 144       if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
 145         flags |= FLAG_RETURNS_128BITS;
 146       /* Fall through.  */
 147 #endif
 148     case FFI_TYPE_DOUBLE:
 149       flags |= FLAG_RETURNS_64BITS;
 150       /* Fall through.  */
 151     case FFI_TYPE_FLOAT:
 152       flags |= FLAG_RETURNS_FP;
 153       break;
 154
 155     case FFI_TYPE_UINT128:
 156       flags |= FLAG_RETURNS_128BITS;
 157       /* Fall through.  */
 158     case FFI_TYPE_UINT64:
 159     case FFI_TYPE_SINT64:
 160       flags |= FLAG_RETURNS_64BITS;
 161       break;
 162
 163     case FFI_TYPE_STRUCT:
 164 #if _CALL_ELF == 2
 165       elt = discover_homogeneous_aggregate (cif->rtype, &elnum);
 166       if (elt)
 167         {
 168           if (elt == FFI_TYPE_DOUBLE)
 169             flags |= FLAG_RETURNS_64BITS;
 170           flags |= FLAG_RETURNS_FP | FLAG_RETURNS_SMST;
 171           break;
 172         }
 173       if (cif->rtype->size <= 16)
 174         {
 175           flags |= FLAG_RETURNS_SMST;
 176           break;
 177         }
 178 #endif
 179       intarg_count++;
 180       flags |= FLAG_RETVAL_REFERENCE;
 181       /* Fall through.  */
 182     case FFI_TYPE_VOID:
 183       flags |= FLAG_RETURNS_NOTHING;
 184       break;
 185
 186     default:
 187       /* Returns 32-bit integer, or similar.  Nothing to do here.  */
 188       break;
 189     }
 190
 191   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
 192     {
 193       unsigned int align;
 194
 195       switch ((*ptr)->type)
 196         {
 197 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 198         case FFI_TYPE_LONGDOUBLE:
 199           if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
 200             {
 201               fparg_count++;
 202               intarg_count++;
 203             }
 204           /* Fall through.  */
 205 #endif
 206         case FFI_TYPE_DOUBLE:
 207         case FFI_TYPE_FLOAT:
 208           fparg_count++;
 209           intarg_count++;
 210           if (fparg_count > NUM_FPR_ARG_REGISTERS64)
 211             flags |= FLAG_ARG_NEEDS_PSAVE;
 212           break;
 213
 214         case FFI_TYPE_STRUCT:
 215           if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
 216             {
 217               align = (*ptr)->alignment;
 218               if (align > 16)
 219                 align = 16;
 220               align = align / 8;
 221               if (align > 1)
 222                 intarg_count = ALIGN (intarg_count, align);
 223             }
 224           intarg_count += ((*ptr)->size + 7) / 8;
 225 #if _CALL_ELF == 2
 226           elt = discover_homogeneous_aggregate (*ptr, &elnum);
 227           if (elt)
 228             {
 229               fparg_count += elnum;
 230               if (fparg_count > NUM_FPR_ARG_REGISTERS64)
 231                 flags |= FLAG_ARG_NEEDS_PSAVE;
 232             }
 233           else
 234 #endif
 235             {
 236               if (intarg_count > NUM_GPR_ARG_REGISTERS64)
 237                 flags |= FLAG_ARG_NEEDS_PSAVE;
 238             }
 239           break;
 240
 241         case FFI_TYPE_POINTER:
 242         case FFI_TYPE_UINT64:
 243         case FFI_TYPE_SINT64:
 244         case FFI_TYPE_INT:
 245         case FFI_TYPE_UINT32:
 246         case FFI_TYPE_SINT32:
 247         case FFI_TYPE_UINT16:
 248         case FFI_TYPE_SINT16:
 249         case FFI_TYPE_UINT8:
 250         case FFI_TYPE_SINT8:
 251           /* Everything else is passed as a 8-byte word in a GPR, either
 252              the object itself or a pointer to it.  */
 253           intarg_count++;
 254           if (intarg_count > NUM_GPR_ARG_REGISTERS64)
 255             flags |= FLAG_ARG_NEEDS_PSAVE;
 256           break;
 257         default:
 258           FFI_ASSERT (0);
 259         }
 260     }
 261
 262   if (fparg_count != 0)
 263     flags |= FLAG_FP_ARGUMENTS;
 264   if (intarg_count > 4)
 265     flags |= FLAG_4_GPR_ARGUMENTS;
 266
 267   /* Space for the FPR registers, if needed.  */
 268   if (fparg_count != 0)
 269     bytes += NUM_FPR_ARG_REGISTERS64 * sizeof (double);
 270
 271   /* Stack space.  */
 272 #if _CALL_ELF == 2
 273   if ((flags & FLAG_ARG_NEEDS_PSAVE) != 0)
 274     bytes += intarg_count * sizeof (long);
 275 #else
 276   if (intarg_count > NUM_GPR_ARG_REGISTERS64)
 277     bytes += (intarg_count - NUM_GPR_ARG_REGISTERS64) * sizeof (long);
 278 #endif
 279
 280   /* The stack space allocated needs to be a multiple of 16 bytes.  */
 281   bytes = (bytes + 15) & ~0xF;
 282
 283   cif->flags = flags;
 284   cif->bytes = bytes;
 285
 286   return FFI_OK;
 287 }
 288
 289 ffi_status FFI_HIDDEN
 290 ffi_prep_cif_linux64 (ffi_cif *cif)
 291 {
 292   if ((cif->abi & FFI_LINUX) != 0)
 293     cif->nfixedargs = cif->nargs;
 294 #if _CALL_ELF != 2
 295   else if (cif->abi == FFI_COMPAT_LINUX64)
 296     {
 297       /* This call is from old code.  Don't touch cif->nfixedargs
 298          since old code will be using a smaller cif.  */
 299       cif->flags |= FLAG_COMPAT;
 300       /* Translate to new abi value.  */
 301       cif->abi = FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128;
 302     }
 303 #endif
 304   else
 305     return FFI_BAD_ABI;
 306   return ffi_prep_cif_linux64_core (cif);
 307 }
 308
 309 ffi_status FFI_HIDDEN
 310 ffi_prep_cif_linux64_var (ffi_cif *cif,
 311                           unsigned int nfixedargs,
 312                           unsigned int ntotalargs MAYBE_UNUSED)
 313 {
 314   if ((cif->abi & FFI_LINUX) != 0)
 315     cif->nfixedargs = nfixedargs;
 316 #if _CALL_ELF != 2
 317   else if (cif->abi == FFI_COMPAT_LINUX64)
 318     {
 319       /* This call is from old code.  Don't touch cif->nfixedargs
 320          since old code will be using a smaller cif.  */
 321       cif->flags |= FLAG_COMPAT;
 322       /* Translate to new abi value.  */
 323       cif->abi = FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128;
 324     }
 325 #endif
 326   else
 327     return FFI_BAD_ABI;
 328 #if _CALL_ELF == 2
 329   cif->flags |= FLAG_ARG_NEEDS_PSAVE;
 330 #endif
 331   return ffi_prep_cif_linux64_core (cif);
 332 }
 333
 334
 335 /* ffi_prep_args64 is called by the assembly routine once stack space
 336    has been allocated for the function's arguments.
 337
 338    The stack layout we want looks like this:
 339
 340    |   Ret addr from ffi_call_LINUX64   8bytes  |       higher addresses
 341    |--------------------------------------------|
 342    |   CR save area                     8bytes  |
 343    |--------------------------------------------|
 344    |   Previous backchain pointer       8       |       stack pointer here
 345    |--------------------------------------------|<+ <<< on entry to
 346    |   Saved r28-r31                    4*8     | |     ffi_call_LINUX64
 347    |--------------------------------------------| |
 348    |   GPR registers r3-r10             8*8     | |
 349    |--------------------------------------------| |
 350    |   FPR registers f1-f13 (optional)  13*8    | |
 351    |--------------------------------------------| |
 352    |   Parameter save area                      | |
 353    |--------------------------------------------| |
 354    |   TOC save area                    8       | |
 355    |--------------------------------------------| |     stack   |
 356    |   Linker doubleword                8       | |     grows   |
 357    |--------------------------------------------| |     down    V
 358    |   Compiler doubleword              8       | |
 359    |--------------------------------------------| |     lower addresses
 360    |   Space for callee's LR            8       | |
 361    |--------------------------------------------| |
 362    |   CR save area                     8       | |
 363    |--------------------------------------------| |     stack pointer here
 364    |   Current backchain pointer        8       |-/     during
 365    |--------------------------------------------|   <<< ffi_call_LINUX64
 366
 367 */
 368
 369 void FFI_HIDDEN
 370 ffi_prep_args64 (extended_cif *ecif, unsigned long *const stack)
 371 {
 372   const unsigned long bytes = ecif->cif->bytes;
 373   const unsigned long flags = ecif->cif->flags;
 374
 375   typedef union
 376   {
 377     char *c;
 378     unsigned long *ul;
 379     float *f;
 380     double *d;
 381     size_t p;
 382   } valp;
 383
 384   /* 'stacktop' points at the previous backchain pointer.  */
 385   valp stacktop;
 386
 387   /* 'next_arg' points at the space for gpr3, and grows upwards as
 388      we use GPR registers, then continues at rest.  */
 389   valp gpr_base;
 390   valp gpr_end;
 391   valp rest;
 392   valp next_arg;
 393
 394   /* 'fpr_base' points at the space for fpr3, and grows upwards as
 395      we use FPR registers.  */
 396   valp fpr_base;
 397   unsigned int fparg_count;
 398
 399   unsigned int i, words, nargs, nfixedargs;
 400   ffi_type **ptr;
 401   double double_tmp;
 402   union
 403   {
 404     void **v;
 405     char **c;
 406     signed char **sc;
 407     unsigned char **uc;
 408     signed short **ss;
 409     unsigned short **us;
 410     signed int **si;
 411     unsigned int **ui;
 412     unsigned long **ul;
 413     float **f;
 414     double **d;
 415   } p_argv;
 416   unsigned long gprvalue;
 417   unsigned long align;
 418
 419   stacktop.c = (char *) stack + bytes;
 420   gpr_base.ul = stacktop.ul - ASM_NEEDS_REGISTERS64 - NUM_GPR_ARG_REGISTERS64;
 421   gpr_end.ul = gpr_base.ul + NUM_GPR_ARG_REGISTERS64;
 422 #if _CALL_ELF == 2
 423   rest.ul = stack + 4 + NUM_GPR_ARG_REGISTERS64;
 424 #else
 425   rest.ul = stack + 6 + NUM_GPR_ARG_REGISTERS64;
 426 #endif
 427   fpr_base.d = gpr_base.d - NUM_FPR_ARG_REGISTERS64;
 428   fparg_count = 0;
 429   next_arg.ul = gpr_base.ul;
 430
 431   /* Check that everything starts aligned properly.  */
 432   FFI_ASSERT (((unsigned long) (char *) stack & 0xF) == 0);
 433   FFI_ASSERT (((unsigned long) stacktop.c & 0xF) == 0);
 434   FFI_ASSERT ((bytes & 0xF) == 0);
 435
 436   /* Deal with return values that are actually pass-by-reference.  */
 437   if (flags & FLAG_RETVAL_REFERENCE)
 438     *next_arg.ul++ = (unsigned long) (char *) ecif->rvalue;
 439
 440   /* Now for the arguments.  */
 441   p_argv.v = ecif->avalue;
 442   nargs = ecif->cif->nargs;
 443 #if _CALL_ELF != 2
 444   nfixedargs = (unsigned) -1;
 445   if ((flags & FLAG_COMPAT) == 0)
 446 #endif
 447     nfixedargs = ecif->cif->nfixedargs;
 448   for (ptr = ecif->cif->arg_types, i = 0;
 449        i < nargs;
 450        i++, ptr++, p_argv.v++)
 451     {
 452 #if _CALL_ELF == 2
 453       unsigned int elt, elnum;
 454 #endif
 455
 456       switch ((*ptr)->type)
 457         {
 458 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 459         case FFI_TYPE_LONGDOUBLE:
 460           if ((ecif->cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
 461             {
 462               double_tmp = (*p_argv.d)[0];
 463               if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
 464                 {
 465                   *fpr_base.d++ = double_tmp;
 466 # if _CALL_ELF != 2
 467                   if ((flags & FLAG_COMPAT) != 0)
 468                     *next_arg.d = double_tmp;
 469 # endif
 470                 }
 471               else
 472                 *next_arg.d = double_tmp;
 473               if (++next_arg.ul == gpr_end.ul)
 474                 next_arg.ul = rest.ul;
 475               fparg_count++;
 476               double_tmp = (*p_argv.d)[1];
 477               if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
 478                 {
 479                   *fpr_base.d++ = double_tmp;
 480 # if _CALL_ELF != 2
 481                   if ((flags & FLAG_COMPAT) != 0)
 482                     *next_arg.d = double_tmp;
 483 # endif
 484                 }
 485               else
 486                 *next_arg.d = double_tmp;
 487               if (++next_arg.ul == gpr_end.ul)
 488                 next_arg.ul = rest.ul;
 489               fparg_count++;
 490               FFI_ASSERT (__LDBL_MANT_DIG__ == 106);
 491               FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
 492               break;
 493             }
 494           /* Fall through.  */
 495 #endif
 496         case FFI_TYPE_DOUBLE:
 497           double_tmp = **p_argv.d;
 498           if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
 499             {
 500               *fpr_base.d++ = double_tmp;
 501 #if _CALL_ELF != 2
 502               if ((flags & FLAG_COMPAT) != 0)
 503                 *next_arg.d = double_tmp;
 504 #endif
 505             }
 506           else
 507             *next_arg.d = double_tmp;
 508           if (++next_arg.ul == gpr_end.ul)
 509             next_arg.ul = rest.ul;
 510           fparg_count++;
 511           FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
 512           break;
 513
 514         case FFI_TYPE_FLOAT:
 515           double_tmp = **p_argv.f;
 516           if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
 517             {
 518               *fpr_base.d++ = double_tmp;
 519 #if _CALL_ELF != 2
 520               if ((flags & FLAG_COMPAT) != 0)
 521                 *next_arg.f = (float) double_tmp;
 522 #endif
 523             }
 524           else
 525             *next_arg.f = (float) double_tmp;
 526           if (++next_arg.ul == gpr_end.ul)
 527             next_arg.ul = rest.ul;
 528           fparg_count++;
 529           FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
 530           break;
 531
 532         case FFI_TYPE_STRUCT:
 533           if ((ecif->cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
 534             {
 535               align = (*ptr)->alignment;
 536               if (align > 16)
 537                 align = 16;
 538               if (align > 1)
 539                 next_arg.p = ALIGN (next_arg.p, align);
 540             }
 541 #if _CALL_ELF == 2
 542           elt = discover_homogeneous_aggregate (*ptr, &elnum);
 543           if (elt)
 544             {
 545               union {
 546                 void *v;
 547                 float *f;
 548                 double *d;
 549               } arg;
 550
 551               arg.v = *p_argv.v;
 552               if (elt == FFI_TYPE_FLOAT)
 553                 {
 554                   do
 555                     {
 556                       double_tmp = *arg.f++;
 557                       if (fparg_count < NUM_FPR_ARG_REGISTERS64
 558                           && i < nfixedargs)
 559                         *fpr_base.d++ = double_tmp;
 560                       else
 561                         *next_arg.f = (float) double_tmp;
 562                       if (++next_arg.f == gpr_end.f)
 563                         next_arg.f = rest.f;
 564                       fparg_count++;
 565                     }
 566                   while (--elnum != 0);
 567                   if ((next_arg.p & 3) != 0)
 568                     {
 569                       if (++next_arg.f == gpr_end.f)
 570                         next_arg.f = rest.f;
 571                     }
 572                 }
 573               else
 574                 do
 575                   {
 576                     double_tmp = *arg.d++;
 577                     if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
 578                       *fpr_base.d++ = double_tmp;
 579                     else
 580                       *next_arg.d = double_tmp;
 581                     if (++next_arg.d == gpr_end.d)
 582                       next_arg.d = rest.d;
 583                     fparg_count++;
 584                   }
 585                 while (--elnum != 0);
 586             }
 587           else
 588 #endif
 589             {
 590               words = ((*ptr)->size + 7) / 8;
 591               if (next_arg.ul >= gpr_base.ul && next_arg.ul + words > gpr_end.ul)
 592                 {
 593                   size_t first = gpr_end.c - next_arg.c;
 594                   memcpy (next_arg.c, *p_argv.c, first);
 595                   memcpy (rest.c, *p_argv.c + first, (*ptr)->size - first);
 596                   next_arg.c = rest.c + words * 8 - first;
 597                 }
 598               else
 599                 {
 600                   char *where = next_arg.c;
 601
 602 #ifndef __LITTLE_ENDIAN__
 603                   /* Structures with size less than eight bytes are passed
 604                      left-padded.  */
 605                   if ((*ptr)->size < 8)
 606                     where += 8 - (*ptr)->size;
 607 #endif
 608                   memcpy (where, *p_argv.c, (*ptr)->size);
 609                   next_arg.ul += words;
 610                   if (next_arg.ul == gpr_end.ul)
 611                     next_arg.ul = rest.ul;
 612                 }
 613             }
 614           break;
 615
 616         case FFI_TYPE_UINT8:
 617           gprvalue = **p_argv.uc;
 618           goto putgpr;
 619         case FFI_TYPE_SINT8:
 620           gprvalue = **p_argv.sc;
 621           goto putgpr;
 622         case FFI_TYPE_UINT16:
 623           gprvalue = **p_argv.us;
 624           goto putgpr;
 625         case FFI_TYPE_SINT16:
 626           gprvalue = **p_argv.ss;
 627           goto putgpr;
 628         case FFI_TYPE_UINT32:
 629           gprvalue = **p_argv.ui;
 630           goto putgpr;
 631         case FFI_TYPE_INT:
 632         case FFI_TYPE_SINT32:
 633           gprvalue = **p_argv.si;
 634           goto putgpr;
 635
 636         case FFI_TYPE_UINT64:
 637         case FFI_TYPE_SINT64:
 638         case FFI_TYPE_POINTER:
 639           gprvalue = **p_argv.ul;
 640         putgpr:
 641           *next_arg.ul++ = gprvalue;
 642           if (next_arg.ul == gpr_end.ul)
 643             next_arg.ul = rest.ul;
 644           break;
 645         }
 646     }
 647
 648   FFI_ASSERT (flags & FLAG_4_GPR_ARGUMENTS
 649               || (next_arg.ul >= gpr_base.ul
 650                   && next_arg.ul <= gpr_base.ul + 4));
 651 }
 652
 653
 654 #if _CALL_ELF == 2
 655 #define MIN_CACHE_LINE_SIZE 8
 656
 657 static void
 658 flush_icache (char *wraddr, char *xaddr, int size)
 659 {
 660   int i;
 661   for (i = 0; i < size; i += MIN_CACHE_LINE_SIZE)
 662     __asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;"
 663                       : : "r" (xaddr + i), "r" (wraddr + i) : "memory");
 664   __asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;" "sync;" "isync;"
 665                     : : "r"(xaddr + size - 1), "r"(wraddr + size - 1)
 666                     : "memory");
 667 }
 668 #endif
 669
 670
 671 ffi_status FFI_HIDDEN
 672 ffi_prep_closure_loc_linux64 (ffi_closure *closure,
 673                               ffi_cif *cif,
 674                               void (*fun) (ffi_cif *, void *, void **, void *),
 675                               void *user_data,
 676                               void *codeloc)
 677 {
 678 #if _CALL_ELF == 2
 679   unsigned int *tramp = (unsigned int *) &closure->tramp[0];
 680
 681   if (cif->abi < FFI_LINUX || cif->abi >= FFI_LAST_ABI)
 682     return FFI_BAD_ABI;
 683
 684   tramp[0] = 0xe96c0018;        /* 0:   ld      11,2f-0b(12)    */
 685   tramp[1] = 0xe98c0010;        /*      ld      12,1f-0b(12)    */
 686   tramp[2] = 0x7d8903a6;        /*      mtctr   12              */
 687   tramp[3] = 0x4e800420;        /*      bctr                    */
 688                                 /* 1:   .quad   function_addr   */
 689                                 /* 2:   .quad   context         */
 690   *(void **) &tramp[4] = (void *) ffi_closure_LINUX64;
 691   *(void **) &tramp[6] = codeloc;
 692   flush_icache ((char *) tramp, (char *) codeloc, 4 * 4);
 693 #else
 694   void **tramp = (void **) &closure->tramp[0];
 695
 696   if (cif->abi < FFI_LINUX || cif->abi >= FFI_LAST_ABI)
 697     return FFI_BAD_ABI;
 698
 699   /* Copy function address and TOC from ffi_closure_LINUX64 OPD.  */
 700   memcpy (&tramp[0], (void **) ffi_closure_LINUX64, sizeof (void *));
 701   tramp[1] = codeloc;
 702   memcpy (&tramp[2], (void **) ffi_closure_LINUX64 + 1, sizeof (void *));
 703 #endif
 704
 705   closure->cif = cif;
 706   closure->fun = fun;
 707   closure->user_data = user_data;
 708
 709   return FFI_OK;
 710 }
 711
 712
 713 int FFI_HIDDEN
 714 ffi_closure_helper_LINUX64 (ffi_cif *cif,
 715                             void (*fun) (ffi_cif *, void *, void **, void *),
 716                             void *user_data,
 717                             void *rvalue,
 718                             unsigned long *pst,
 719                             ffi_dblfl *pfr)
 720 {
 721   /* rvalue is the pointer to space for return value in closure assembly */
 722   /* pst is the pointer to parameter save area
 723      (r3-r10 are stored into its first 8 slots by ffi_closure_LINUX64) */
 724   /* pfr is the pointer to where f1-f13 are stored in ffi_closure_LINUX64 */
 725
 726   void **avalue;
 727   ffi_type **arg_types;
 728   unsigned long i, avn, nfixedargs;
 729   ffi_dblfl *end_pfr = pfr + NUM_FPR_ARG_REGISTERS64;
 730   unsigned long align;
 731
 732   avalue = alloca (cif->nargs * sizeof (void *));
 733
 734   /* Copy the caller's structure return value address so that the
 735      closure returns the data directly to the caller.  */
 736   if (cif->rtype->type == FFI_TYPE_STRUCT
 737       && (cif->flags & FLAG_RETURNS_SMST) == 0)
 738     {
 739       rvalue = (void *) *pst;
 740       pst++;
 741     }
 742
 743   i = 0;
 744   avn = cif->nargs;
 745 #if _CALL_ELF != 2
 746   nfixedargs = (unsigned) -1;
 747   if ((cif->flags & FLAG_COMPAT) == 0)
 748 #endif
 749     nfixedargs = cif->nfixedargs;
 750   arg_types = cif->arg_types;
 751
 752   /* Grab the addresses of the arguments from the stack frame.  */
 753   while (i < avn)
 754     {
 755       unsigned int elt, elnum;
 756
 757       switch (arg_types[i]->type)
 758         {
 759         case FFI_TYPE_SINT8:
 760         case FFI_TYPE_UINT8:
 761 #ifndef __LITTLE_ENDIAN__
 762           avalue[i] = (char *) pst + 7;
 763           pst++;
 764           break;
 765 #endif
 766
 767         case FFI_TYPE_SINT16:
 768         case FFI_TYPE_UINT16:
 769 #ifndef __LITTLE_ENDIAN__
 770           avalue[i] = (char *) pst + 6;
 771           pst++;
 772           break;
 773 #endif
 774
 775         case FFI_TYPE_SINT32:
 776         case FFI_TYPE_UINT32:
 777 #ifndef __LITTLE_ENDIAN__
 778           avalue[i] = (char *) pst + 4;
 779           pst++;
 780           break;
 781 #endif
 782
 783         case FFI_TYPE_SINT64:
 784         case FFI_TYPE_UINT64:
 785         case FFI_TYPE_POINTER:
 786           avalue[i] = pst;
 787           pst++;
 788           break;
 789
 790         case FFI_TYPE_STRUCT:
 791           if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
 792             {
 793               align = arg_types[i]->alignment;
 794               if (align > 16)
 795                 align = 16;
 796               if (align > 1)
 797                 pst = (unsigned long *) ALIGN ((size_t) pst, align);
 798             }
 799           elt = 0;
 800 #if _CALL_ELF == 2
 801           elt = discover_homogeneous_aggregate (arg_types[i], &elnum);
 802 #endif
 803           if (elt)
 804             {
 805               union {
 806                 void *v;
 807                 unsigned long *ul;
 808                 float *f;
 809                 double *d;
 810                 size_t p;
 811               } to, from;
 812
 813               /* Repackage the aggregate from its parts.  The
 814                  aggregate size is not greater than the space taken by
 815                  the registers so store back to the register/parameter
 816                  save arrays.  */
 817               if (pfr + elnum <= end_pfr)
 818                 to.v = pfr;
 819               else
 820                 to.v = pst;
 821
 822               avalue[i] = to.v;
 823               from.ul = pst;
 824               if (elt == FFI_TYPE_FLOAT)
 825                 {
 826                   do
 827                     {
 828                       if (pfr < end_pfr && i < nfixedargs)
 829                         {
 830                           *to.f = (float) pfr->d;
 831                           pfr++;
 832                         }
 833                       else
 834                         *to.f = *from.f;
 835                       to.f++;
 836                       from.f++;
 837                     }
 838                   while (--elnum != 0);
 839                 }
 840               else
 841                 {
 842                   do
 843                     {
 844                       if (pfr < end_pfr && i < nfixedargs)
 845                         {
 846                           *to.d = pfr->d;
 847                           pfr++;
 848                         }
 849                       else
 850                         *to.d = *from.d;
 851                       to.d++;
 852                       from.d++;
 853                     }
 854                   while (--elnum != 0);
 855                 }
 856             }
 857           else
 858             {
 859 #ifndef __LITTLE_ENDIAN__
 860               /* Structures with size less than eight bytes are passed
 861                  left-padded.  */
 862               if (arg_types[i]->size < 8)
 863                 avalue[i] = (char *) pst + 8 - arg_types[i]->size;
 864               else
 865 #endif
 866                 avalue[i] = pst;
 867             }
 868           pst += (arg_types[i]->size + 7) / 8;
 869           break;
 870
 871 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 872         case FFI_TYPE_LONGDOUBLE:
 873           if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
 874             {
 875               if (pfr + 1 < end_pfr && i + 1 < nfixedargs)
 876                 {
 877                   avalue[i] = pfr;
 878                   pfr += 2;
 879                 }
 880               else
 881                 {
 882                   if (pfr < end_pfr && i < nfixedargs)
 883                     {
 884                       /* Passed partly in f13 and partly on the stack.
 885                          Move it all to the stack.  */
 886                       *pst = *(unsigned long *) pfr;
 887                       pfr++;
 888                     }
 889                   avalue[i] = pst;
 890                 }
 891               pst += 2;
 892               break;
 893             }
 894           /* Fall through.  */
 895 #endif
 896         case FFI_TYPE_DOUBLE:
 897           /* On the outgoing stack all values are aligned to 8 */
 898           /* there are 13 64bit floating point registers */
 899
 900           if (pfr < end_pfr && i < nfixedargs)
 901             {
 902               avalue[i] = pfr;
 903               pfr++;
 904             }
 905           else
 906             avalue[i] = pst;
 907           pst++;
 908           break;
 909
 910         case FFI_TYPE_FLOAT:
 911           if (pfr < end_pfr && i < nfixedargs)
 912             {
 913               /* Float values are stored as doubles in the
 914                  ffi_closure_LINUX64 code.  Fix them here.  */
 915               pfr->f = (float) pfr->d;
 916               avalue[i] = pfr;
 917               pfr++;
 918             }
 919           else
 920             avalue[i] = pst;
 921           pst++;
 922           break;
 923
 924         default:
 925           FFI_ASSERT (0);
 926         }
 927
 928       i++;
 929     }
 930
 931   (*fun) (cif, rvalue, avalue, user_data);
 932
 933   /* Tell ffi_closure_LINUX64 how to perform return type promotions.  */
 934   if ((cif->flags & FLAG_RETURNS_SMST) != 0)
 935     {
 936       if ((cif->flags & FLAG_RETURNS_FP) == 0)
 937         return FFI_V2_TYPE_SMALL_STRUCT + cif->rtype->size - 1;
 938       else if ((cif->flags & FLAG_RETURNS_64BITS) != 0)
 939         return FFI_V2_TYPE_DOUBLE_HOMOG;
 940       else
 941         return FFI_V2_TYPE_FLOAT_HOMOG;
 942     }
 943   return cif->rtype->type;
 944 }
 945 #endif