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
 157 ffi_prep_cif (ffi_cif * cif,
 158               ffi_abi abi, unsigned int nargs,
 159               ffi_type * rtype, ffi_type ** atypes)
 160 {
 161   unsigned bytes = 0;
 162   unsigned int i;
 163   ffi_type **ptr;
 164
 165   FFI_ASSERT (cif != NULL);
 166   FFI_ASSERT ((abi > FFI_FIRST_ABI) && (abi <= FFI_DEFAULT_ABI));
 167
 168   cif->abi = abi;
 169   cif->arg_types = atypes;
 170   cif->nargs = nargs;
 171   cif->rtype = rtype;
 172
 173   cif->flags = 0;
 174
 175   if ((cif->rtype->size == 0)
 176       && (initialize_aggregate_packed_struct (cif->rtype) != FFI_OK))
 177     return FFI_BAD_TYPEDEF;
 178
 179   FFI_ASSERT_VALID_TYPE (cif->rtype);
 180
 181   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
 182     {
 183       if (((*ptr)->size == 0)
 184           && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
 185         return FFI_BAD_TYPEDEF;
 186
 187       FFI_ASSERT_VALID_TYPE (*ptr);
 188
 189       if (((*ptr)->alignment - 1) & bytes)
 190         bytes = ALIGN (bytes, (*ptr)->alignment);
 191       if ((*ptr)->type == FFI_TYPE_STRUCT)
 192         {
 193           if ((*ptr)->size > 8)
 194             {
 195               bytes += (*ptr)->size;
 196               bytes += sizeof (void *);
 197             }
 198           else
 199             {
 200               if ((*ptr)->size > 4)
 201                 bytes += 8;
 202               else
 203                 bytes += 4;
 204             }
 205         }
 206       else
 207         bytes += STACK_ARG_SIZE ((*ptr)->size);
 208     }
 209
 210   cif->bytes = bytes;
 211
 212   return ffi_prep_cif_machdep (cif);
 213 }
 214
 215 ffi_status
 216 ffi_prep_cif_machdep (ffi_cif * cif)
 217 {
 218   switch (cif->rtype->type)
 219     {
 220     case FFI_TYPE_VOID:
 221     case FFI_TYPE_STRUCT:
 222     case FFI_TYPE_FLOAT:
 223     case FFI_TYPE_DOUBLE:
 224     case FFI_TYPE_SINT64:
 225     case FFI_TYPE_UINT64:
 226       cif->flags = (unsigned) cif->rtype->type;
 227       break;
 228
 229     default:
 230       cif->flags = FFI_TYPE_INT;
 231       break;
 232     }
 233
 234   return FFI_OK;
 235 }
 236
 237 extern void ffi_call_SYSV (int (*)(char *, extended_cif *),
 238                            extended_cif *,
 239                            unsigned, unsigned, unsigned *, void (*fn) ())
 240      __attribute__ ((__visibility__ ("hidden")));
 241
 242 void
 243 ffi_call (ffi_cif * cif, void (*fn) (), void *rvalue, void **avalue)
 244 {
 245   extended_cif ecif;
 246
 247   ecif.cif = cif;
 248   ecif.avalue = avalue;
 249
 250   if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
 251     {
 252       ecif.rvalue = alloca (cif->rtype->size);
 253     }
 254   else
 255     ecif.rvalue = rvalue;
 256
 257   switch (cif->abi)
 258     {
 259     case FFI_SYSV:
 260       ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes,
 261                      cif->flags, ecif.rvalue, fn);
 262       break;
 263     default:
 264       FFI_ASSERT (0);
 265       break;
 266     }
 267 }
 268
 269 /* Because the following variables are not exported outside libffi, we
 270    mark them hidden.  */
 271
 272 /* Assembly code for the jump stub.  */
 273 extern const char ffi_cris_trampoline_template[]
 274  __attribute__ ((__visibility__ ("hidden")));
 275
 276 /* Offset into ffi_cris_trampoline_template of where to put the
 277    ffi_prep_closure_inner function.  */
 278 extern const int ffi_cris_trampoline_fn_offset
 279  __attribute__ ((__visibility__ ("hidden")));
 280
 281 /* Offset into ffi_cris_trampoline_template of where to put the
 282    closure data.  */
 283 extern const int ffi_cris_trampoline_closure_offset
 284  __attribute__ ((__visibility__ ("hidden")));
 285
 286 /* This function is sibling-called (jumped to) by the closure
 287    trampoline.  We get R10..R13 at PARAMS[0..3] and a copy of [SP] at
 288    PARAMS[4] to simplify handling of a straddling parameter.  A copy
 289    of R9 is at PARAMS[5] and SP at PARAMS[6].  These parameters are
 290    put at the appropriate place in CLOSURE which is then executed and
 291    the return value is passed back to the caller.  */
 292
 293 static unsigned long long
 294 ffi_prep_closure_inner (void **params, ffi_closure* closure)
 295 {
 296   char *register_args = (char *) params;
 297   void *struct_ret = params[5];
 298   char *stack_args = params[6];
 299   char *ptr = register_args;
 300   ffi_cif *cif = closure->cif;
 301   ffi_type **arg_types = cif->arg_types;
 302
 303   /* Max room needed is number of arguments as 64-bit values.  */
 304   void **avalue = alloca (closure->cif->nargs * sizeof(void *));
 305   int i;
 306   int doing_regs;
 307   long long llret = 0;
 308
 309   /* Find the address of each argument.  */
 310   for (i = 0, doing_regs = 1; i < cif->nargs; i++)
 311     {
 312       /* Types up to and including 8 bytes go by-value.  */
 313       if (arg_types[i]->size <= 4)
 314         {
 315           avalue[i] = ptr;
 316           ptr += 4;
 317         }
 318       else if (arg_types[i]->size <= 8)
 319         {
 320           avalue[i] = ptr;
 321           ptr += 8;
 322         }
 323       else
 324         {
 325           FFI_ASSERT (arg_types[i]->type == FFI_TYPE_STRUCT);
 326
 327           /* Passed by-reference, so copy the pointer.  */
 328           avalue[i] = *(void **) ptr;
 329           ptr += 4;
 330         }
 331
 332       /* If we've handled more arguments than fit in registers, start
 333          looking at the those passed on the stack.  Step over the
 334          first one if we had a straddling parameter.  */
 335       if (doing_regs && ptr >= register_args + 4*4)
 336         {
 337           ptr = stack_args + ((ptr > register_args + 4*4) ? 4 : 0);
 338           doing_regs = 0;
 339         }
 340     }
 341
 342   /* Invoke the closure.  */
 343   (closure->fun) (cif,
 344
 345                   cif->rtype->type == FFI_TYPE_STRUCT
 346                   /* The caller allocated space for the return
 347                      structure, and passed a pointer to this space in
 348                      R9.  */
 349                   ? struct_ret
 350
 351                   /* We take advantage of being able to ignore that
 352                      the high part isn't set if the return value is
 353                      not in R10:R11, but in R10 only.  */
 354                   : (void *) &llret,
 355
 356                   avalue, closure->user_data);
 357
 358   return llret;
 359 }
 360
 361 /* API function: Prepare the trampoline.  */
 362
 363 ffi_status
 364 ffi_prep_closure_loc (ffi_closure* closure,
 365                       ffi_cif* cif,
 366                       void (*fun)(ffi_cif *, void *, void **, void*),
 367                       void *user_data,
 368                       void *codeloc)
 369 {
 370   void *innerfn = ffi_prep_closure_inner;
 371   FFI_ASSERT (cif->abi == FFI_SYSV);
 372   closure->cif  = cif;
 373   closure->user_data = user_data;
 374   closure->fun  = fun;
 375   memcpy (closure->tramp, ffi_cris_trampoline_template,
 376           FFI_CRIS_TRAMPOLINE_CODE_PART_SIZE);
 377   memcpy (closure->tramp + ffi_cris_trampoline_fn_offset,
 378           &innerfn, sizeof (void *));
 379   memcpy (closure->tramp + ffi_cris_trampoline_closure_offset,
 380           &codeloc, sizeof (void *));
 381
 382   return FFI_OK;
 383 }