libffi/src/cris/ffi.c

   1 /* -----------------------------------------------------------------------
   2    ffi.c - Copyright (c) 1998 Cygnus Solutions
   3            Copyright (c) 2004 Simon Posnjak
   4            Copyright (c) 2005 Axis Communications AB
   5            Copyright (C) 2007 Free Software Foundation, Inc.
   6
   7    CRIS 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 SIMON POSNJAK 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 #include <ffi.h>
  30 #include <ffi_common.h>
  31
  32 #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
  33
  34 static ffi_status
  35 initialize_aggregate_packed_struct (ffi_type * arg)
  36 {
  37   ffi_type **ptr;
  38
  39   FFI_ASSERT (arg != NULL);
  40
  41   FFI_ASSERT (arg->elements != NULL);
  42   FFI_ASSERT (arg->size == 0);
  43   FFI_ASSERT (arg->alignment == 0);
  44
  45   ptr = &(arg->elements[0]);
  46
  47   while ((*ptr) != NULL)
  48     {
  49       if (((*ptr)->size == 0)
  50           && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
  51         return FFI_BAD_TYPEDEF;
  52
  53       FFI_ASSERT (ffi_type_test ((*ptr)));
  54
  55       arg->size += (*ptr)->size;
  56
  57       arg->alignment = (arg->alignment > (*ptr)->alignment) ?
  58         arg->alignment : (*ptr)->alignment;
  59
  60       ptr++;
  61     }
  62
  63   if (arg->size == 0)
  64     return FFI_BAD_TYPEDEF;
  65   else
  66     return FFI_OK;
  67 }
  68
  69 int
  70 ffi_prep_args (char *stack, extended_cif * ecif)
  71 {
  72   unsigned int i;
  73   unsigned int struct_count = 0;
  74   void **p_argv;
  75   char *argp;
  76   ffi_type **p_arg;
  77
  78   argp = stack;
  79
  80   p_argv = ecif->avalue;
  81
  82   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
  83        (i != 0); i--, p_arg++)
  84     {
  85       size_t z;
  86
  87       switch ((*p_arg)->type)
  88         {
  89         case FFI_TYPE_STRUCT:
  90           {
  91             z = (*p_arg)->size;
  92             if (z <= 4)
  93               {
  94                 memcpy (argp, *p_argv, z);
  95                 z = 4;
  96               }
  97             else if (z <= 8)
  98               {
  99                 memcpy (argp, *p_argv, z);
 100                 z = 8;
 101               }
 102             else
 103               {
 104                 unsigned int uiLocOnStack;
 105                 z = sizeof (void *);
 106                 uiLocOnStack = 4 * ecif->cif->nargs + struct_count;
 107                 struct_count = struct_count + (*p_arg)->size;
 108                 *(unsigned int *) argp =
 109                   (unsigned int) (UINT32 *) (stack + uiLocOnStack);
 110                 memcpy ((stack + uiLocOnStack), *p_argv, (*p_arg)->size);
 111               }
 112             break;
 113           }
 114         default:
 115           z = (*p_arg)->size;
 116           if (z < sizeof (int))
 117             {
 118               switch ((*p_arg)->type)
 119                 {
 120                 case FFI_TYPE_SINT8:
 121                   *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv);
 122                   break;
 123
 124                 case FFI_TYPE_UINT8:
 125                   *(unsigned int *) argp =
 126                     (unsigned int) *(UINT8 *) (*p_argv);
 127                   break;
 128
 129                 case FFI_TYPE_SINT16:
 130                   *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv);
 131                   break;
 132
 133                 case FFI_TYPE_UINT16:
 134                   *(unsigned int *) argp =
 135                     (unsigned int) *(UINT16 *) (*p_argv);
 136                   break;
 137
 138                 default:
 139                   FFI_ASSERT (0);
 140                 }
 141               z = sizeof (int);
 142             }
 143           else if (z == sizeof (int))
 144             *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv);
 145           else
 146             memcpy (argp, *p_argv, z);
 147           break;
 148         }
 149       p_argv++;
 150       argp += z;
 151     }
 152
 153   return (struct_count);
 154 }
 155
 156 ffi_status FFI_HIDDEN
 157 ffi_prep_cif_core (ffi_cif * cif,
 158                    ffi_abi abi, unsigned int isvariadic,
 159                    unsigned int nfixedargs, unsigned int ntotalargs,
 160                    ffi_type * rtype, ffi_type ** atypes)
 161 {
 162   unsigned bytes = 0;
 163   unsigned int i;
 164   ffi_type **ptr;
 165
 166   FFI_ASSERT (cif != NULL);
 167   FFI_ASSERT((!isvariadic) || (nfixedargs >= 1));
 168   FFI_ASSERT(nfixedargs <= ntotalargs);
 169   FFI_ASSERT (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI);
 170
 171   cif->abi = abi;
 172   cif->arg_types = atypes;
 173   cif->nargs = ntotalargs;
 174   cif->rtype = rtype;
 175
 176   cif->flags = 0;
 177
 178   if ((cif->rtype->size == 0)
 179       && (initialize_aggregate_packed_struct (cif->rtype) != FFI_OK))
 180     return FFI_BAD_TYPEDEF;
 181
 182   FFI_ASSERT_VALID_TYPE (cif->rtype);
 183
 184   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
 185     {
 186       if (((*ptr)->size == 0)
 187           && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
 188         return FFI_BAD_TYPEDEF;
 189
 190       FFI_ASSERT_VALID_TYPE (*ptr);
 191
 192       if (((*ptr)->alignment - 1) & bytes)
 193         bytes = ALIGN (bytes, (*ptr)->alignment);
 194       if ((*ptr)->type == FFI_TYPE_STRUCT)
 195         {
 196           if ((*ptr)->size > 8)
 197             {
 198               bytes += (*ptr)->size;
 199               bytes += sizeof (void *);
 200             }
 201           else
 202             {
 203               if ((*ptr)->size > 4)
 204                 bytes += 8;
 205               else
 206                 bytes += 4;
 207             }
 208         }
 209       else
 210         bytes += STACK_ARG_SIZE ((*ptr)->size);
 211     }
 212
 213   cif->bytes = bytes;
 214
 215   return ffi_prep_cif_machdep (cif);
 216 }
 217
 218 ffi_status
 219 ffi_prep_cif_machdep (ffi_cif * cif)
 220 {
 221   switch (cif->rtype->type)
 222     {
 223     case FFI_TYPE_VOID:
 224     case FFI_TYPE_STRUCT:
 225     case FFI_TYPE_FLOAT:
 226     case FFI_TYPE_DOUBLE:
 227     case FFI_TYPE_SINT64:
 228     case FFI_TYPE_UINT64:
 229       cif->flags = (unsigned) cif->rtype->type;
 230       break;
 231
 232     default:
 233       cif->flags = FFI_TYPE_INT;
 234       break;
 235     }
 236
 237   return FFI_OK;
 238 }
 239
 240 extern void ffi_call_SYSV (int (*)(char *, extended_cif *),
 241                            extended_cif *,
 242                            unsigned, unsigned, unsigned *, void (*fn) ())
 243      __attribute__ ((__visibility__ ("hidden")));
 244
 245 void
 246 ffi_call (ffi_cif * cif, void (*fn) (), void *rvalue, void **avalue)
 247 {
 248   extended_cif ecif;
 249
 250   ecif.cif = cif;
 251   ecif.avalue = avalue;
 252
 253   if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
 254     {
 255       ecif.rvalue = alloca (cif->rtype->size);
 256     }
 257   else
 258     ecif.rvalue = rvalue;
 259
 260   switch (cif->abi)
 261     {
 262     case FFI_SYSV:
 263       ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes,
 264                      cif->flags, ecif.rvalue, fn);
 265       break;
 266     default:
 267       FFI_ASSERT (0);
 268       break;
 269     }
 270 }
 271
 272 /* Because the following variables are not exported outside libffi, we
 273    mark them hidden.  */
 274
 275 /* Assembly code for the jump stub.  */
 276 extern const char ffi_cris_trampoline_template[]
 277  __attribute__ ((__visibility__ ("hidden")));
 278
 279 /* Offset into ffi_cris_trampoline_template of where to put the
 280    ffi_prep_closure_inner function.  */
 281 extern const int ffi_cris_trampoline_fn_offset
 282  __attribute__ ((__visibility__ ("hidden")));
 283
 284 /* Offset into ffi_cris_trampoline_template of where to put the
 285    closure data.  */
 286 extern const int ffi_cris_trampoline_closure_offset
 287  __attribute__ ((__visibility__ ("hidden")));
 288
 289 /* This function is sibling-called (jumped to) by the closure
 290    trampoline.  We get R10..R13 at PARAMS[0..3] and a copy of [SP] at
 291    PARAMS[4] to simplify handling of a straddling parameter.  A copy
 292    of R9 is at PARAMS[5] and SP at PARAMS[6].  These parameters are
 293    put at the appropriate place in CLOSURE which is then executed and
 294    the return value is passed back to the caller.  */
 295
 296 static unsigned long long
 297 ffi_prep_closure_inner (void **params, ffi_closure* closure)
 298 {
 299   char *register_args = (char *) params;
 300   void *struct_ret = params[5];
 301   char *stack_args = params[6];
 302   char *ptr = register_args;
 303   ffi_cif *cif = closure->cif;
 304   ffi_type **arg_types = cif->arg_types;
 305
 306   /* Max room needed is number of arguments as 64-bit values.  */
 307   void **avalue = alloca (closure->cif->nargs * sizeof(void *));
 308   int i;
 309   int doing_regs;
 310   long long llret = 0;
 311
 312   /* Find the address of each argument.  */
 313   for (i = 0, doing_regs = 1; i < cif->nargs; i++)
 314     {
 315       /* Types up to and including 8 bytes go by-value.  */
 316       if (arg_types[i]->size <= 4)
 317         {
 318           avalue[i] = ptr;
 319           ptr += 4;
 320         }
 321       else if (arg_types[i]->size <= 8)
 322         {
 323           avalue[i] = ptr;
 324           ptr += 8;
 325         }
 326       else
 327         {
 328           FFI_ASSERT (arg_types[i]->type == FFI_TYPE_STRUCT);
 329
 330           /* Passed by-reference, so copy the pointer.  */
 331           avalue[i] = *(void **) ptr;
 332           ptr += 4;
 333         }
 334
 335       /* If we've handled more arguments than fit in registers, start
 336          looking at the those passed on the stack.  Step over the
 337          first one if we had a straddling parameter.  */
 338       if (doing_regs && ptr >= register_args + 4*4)
 339         {
 340           ptr = stack_args + ((ptr > register_args + 4*4) ? 4 : 0);
 341           doing_regs = 0;
 342         }
 343     }
 344
 345   /* Invoke the closure.  */
 346   (closure->fun) (cif,
 347
 348                   cif->rtype->type == FFI_TYPE_STRUCT
 349                   /* The caller allocated space for the return
 350                      structure, and passed a pointer to this space in
 351                      R9.  */
 352                   ? struct_ret
 353
 354                   /* We take advantage of being able to ignore that
 355                      the high part isn't set if the return value is
 356                      not in R10:R11, but in R10 only.  */
 357                   : (void *) &llret,
 358
 359                   avalue, closure->user_data);
 360
 361   return llret;
 362 }
 363
 364 /* API function: Prepare the trampoline.  */
 365
 366 ffi_status
 367 ffi_prep_closure_loc (ffi_closure* closure,
 368                       ffi_cif* cif,
 369                       void (*fun)(ffi_cif *, void *, void **, void*),
 370                       void *user_data,
 371                       void *codeloc)
 372 {
 373   void *innerfn = ffi_prep_closure_inner;
 374   FFI_ASSERT (cif->abi == FFI_SYSV);
 375   closure->cif  = cif;
 376   closure->user_data = user_data;
 377   closure->fun  = fun;
 378   memcpy (closure->tramp, ffi_cris_trampoline_template,
 379           FFI_CRIS_TRAMPOLINE_CODE_PART_SIZE);
 380   memcpy (closure->tramp + ffi_cris_trampoline_fn_offset,
 381           &innerfn, sizeof (void *));
 382   memcpy (closure->tramp + ffi_cris_trampoline_closure_offset,
 383           &codeloc, sizeof (void *));
 384
 385   return FFI_OK;
 386 }