libffi/src/m68k/ffi.c

   1 /* -----------------------------------------------------------------------
   2    ffi.c
   3
   4    m68k Foreign Function Interface
   5    ----------------------------------------------------------------------- */
   6
   7 #include <ffi.h>
   8 #include <ffi_common.h>
   9
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <sys/syscall.h>
  13 #include <asm/cachectl.h>
  14
  15 void ffi_call_SYSV (extended_cif *,
  16                     unsigned, unsigned,
  17                     void *, void (*fn) ());
  18 void *ffi_prep_args (void *stack, extended_cif *ecif);
  19 void ffi_closure_SYSV (ffi_closure *);
  20 void ffi_closure_struct_SYSV (ffi_closure *);
  21 unsigned int ffi_closure_SYSV_inner (ffi_closure *closure,
  22                                      void *resp, void *args);
  23
  24 /* ffi_prep_args is called by the assembly routine once stack space has
  25    been allocated for the function's arguments.  */
  26
  27 void *
  28 ffi_prep_args (void *stack, extended_cif *ecif)
  29 {
  30   unsigned int i;
  31   void **p_argv;
  32   char *argp;
  33   ffi_type **p_arg;
  34   void *struct_value_ptr;
  35
  36   argp = stack;
  37
  38   if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
  39       && !ecif->cif->flags)
  40     struct_value_ptr = ecif->rvalue;
  41   else
  42     struct_value_ptr = NULL;
  43
  44   p_argv = ecif->avalue;
  45
  46   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
  47        i != 0;
  48        i--, p_arg++)
  49     {
  50       size_t z;
  51
  52       z = (*p_arg)->size;
  53       if (z < sizeof (int))
  54         {
  55           switch ((*p_arg)->type)
  56             {
  57             case FFI_TYPE_SINT8:
  58               *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
  59               break;
  60
  61             case FFI_TYPE_UINT8:
  62               *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
  63               break;
  64
  65             case FFI_TYPE_SINT16:
  66               *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
  67               break;
  68
  69             case FFI_TYPE_UINT16:
  70               *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
  71               break;
  72
  73             case FFI_TYPE_STRUCT:
  74               memcpy (argp + sizeof (int) - z, *p_argv, z);
  75               break;
  76
  77             default:
  78               FFI_ASSERT (0);
  79             }
  80           z = sizeof (int);
  81         }
  82       else
  83         {
  84           memcpy (argp, *p_argv, z);
  85
  86           /* Align if necessary.  */
  87           if ((sizeof(int) - 1) & z)
  88             z = ALIGN(z, sizeof(int));
  89         }
  90
  91       p_argv++;
  92       argp += z;
  93     }
  94
  95   return struct_value_ptr;
  96 }
  97
  98 #define CIF_FLAGS_INT           1
  99 #define CIF_FLAGS_DINT          2
 100 #define CIF_FLAGS_FLOAT         4
 101 #define CIF_FLAGS_DOUBLE        8
 102 #define CIF_FLAGS_LDOUBLE       16
 103 #define CIF_FLAGS_POINTER       32
 104 #define CIF_FLAGS_STRUCT1       64
 105 #define CIF_FLAGS_STRUCT2       128
 106
 107 /* Perform machine dependent cif processing */
 108 ffi_status
 109 ffi_prep_cif_machdep (ffi_cif *cif)
 110 {
 111   /* Set the return type flag */
 112   switch (cif->rtype->type)
 113     {
 114     case FFI_TYPE_VOID:
 115       cif->flags = 0;
 116       break;
 117
 118     case FFI_TYPE_STRUCT:
 119       switch (cif->rtype->size)
 120         {
 121         case 1:
 122           cif->flags = CIF_FLAGS_STRUCT1;
 123           break;
 124         case 2:
 125           cif->flags = CIF_FLAGS_STRUCT2;
 126           break;
 127         case 4:
 128           cif->flags = CIF_FLAGS_INT;
 129           break;
 130         case 8:
 131           cif->flags = CIF_FLAGS_DINT;
 132           break;
 133         default:
 134           cif->flags = 0;
 135           break;
 136         }
 137       break;
 138
 139     case FFI_TYPE_FLOAT:
 140       cif->flags = CIF_FLAGS_FLOAT;
 141       break;
 142
 143     case FFI_TYPE_DOUBLE:
 144       cif->flags = CIF_FLAGS_DOUBLE;
 145       break;
 146
 147     case FFI_TYPE_LONGDOUBLE:
 148       cif->flags = CIF_FLAGS_LDOUBLE;
 149       break;
 150
 151     case FFI_TYPE_POINTER:
 152       cif->flags = CIF_FLAGS_POINTER;
 153       break;
 154
 155     case FFI_TYPE_SINT64:
 156     case FFI_TYPE_UINT64:
 157       cif->flags = CIF_FLAGS_DINT;
 158       break;
 159
 160     default:
 161       cif->flags = CIF_FLAGS_INT;
 162       break;
 163     }
 164
 165   return FFI_OK;
 166 }
 167
 168 void
 169 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
 170 {
 171   extended_cif ecif;
 172
 173   ecif.cif = cif;
 174   ecif.avalue = avalue;
 175
 176   /* If the return value is a struct and we don't have a return value
 177      address then we need to make one.  */
 178
 179   if (rvalue == NULL
 180       && cif->rtype->type == FFI_TYPE_STRUCT
 181       && cif->rtype->size > 8)
 182     ecif.rvalue = alloca (cif->rtype->size);
 183   else
 184     ecif.rvalue = rvalue;
 185
 186   switch (cif->abi)
 187     {
 188     case FFI_SYSV:
 189       ffi_call_SYSV (&ecif, cif->bytes, cif->flags,
 190                      ecif.rvalue, fn);
 191       break;
 192
 193     default:
 194       FFI_ASSERT (0);
 195       break;
 196     }
 197 }
 198
 199 static void
 200 ffi_prep_incoming_args_SYSV (char *stack, void **avalue, ffi_cif *cif)
 201 {
 202   unsigned int i;
 203   void **p_argv;
 204   char *argp;
 205   ffi_type **p_arg;
 206
 207   argp = stack;
 208   p_argv = avalue;
 209
 210   for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
 211     {
 212       size_t z;
 213
 214       z = (*p_arg)->size;
 215       if (z <= 4)
 216         {
 217           *p_argv = (void *) (argp + 4 - z);
 218
 219           z = 4;
 220         }
 221       else
 222         {
 223           *p_argv = (void *) argp;
 224
 225           /* Align if necessary */
 226           if ((sizeof(int) - 1) & z)
 227             z = ALIGN(z, sizeof(int));
 228         }
 229
 230       p_argv++;
 231       argp += z;
 232     }
 233 }
 234
 235 unsigned int
 236 ffi_closure_SYSV_inner (ffi_closure *closure, void *resp, void *args)
 237 {
 238   ffi_cif *cif;
 239   void **arg_area;
 240
 241   cif = closure->cif;
 242   arg_area = (void**) alloca (cif->nargs * sizeof (void *));
 243
 244   ffi_prep_incoming_args_SYSV(args, arg_area, cif);
 245
 246   (closure->fun) (cif, resp, arg_area, closure->user_data);
 247
 248   return cif->flags;
 249 }
 250
 251 ffi_status
 252 ffi_prep_closure_loc (ffi_closure* closure,
 253                       ffi_cif* cif,
 254                       void (*fun)(ffi_cif*,void*,void**,void*),
 255                       void *user_data,
 256                       void *codeloc)
 257 {
 258   FFI_ASSERT (cif->abi == FFI_SYSV);
 259
 260   *(unsigned short *)closure->tramp = 0x207c;
 261   *(void **)(closure->tramp + 2) = codeloc;
 262   *(unsigned short *)(closure->tramp + 6) = 0x4ef9;
 263   if (cif->rtype->type == FFI_TYPE_STRUCT
 264       && !cif->flags)
 265     *(void **)(closure->tramp + 8) = ffi_closure_struct_SYSV;
 266   else
 267     *(void **)(closure->tramp + 8) = ffi_closure_SYSV;
 268
 269   syscall(SYS_cacheflush, codeloc, FLUSH_SCOPE_LINE,
 270           FLUSH_CACHE_BOTH, FFI_TRAMPOLINE_SIZE);
 271
 272   closure->cif  = cif;
 273   closure->user_data = user_data;
 274   closure->fun  = fun;
 275
 276   return FFI_OK;
 277 }
 278