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
  12 /* ffi_prep_args is called by the assembly routine once stack space has
  13    been allocated for the function's arguments.  */
  14
  15 static void *
  16 ffi_prep_args (void *stack, extended_cif *ecif)
  17 {
  18   unsigned int i;
  19   int tmp;
  20   unsigned int avn;
  21   void **p_argv;
  22   char *argp;
  23   ffi_type **p_arg;
  24   void *struct_value_ptr;
  25
  26   tmp = 0;
  27   argp = stack;
  28
  29   if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
  30       && ecif->cif->rtype->size > 8)
  31     struct_value_ptr = ecif->rvalue;
  32   else
  33     struct_value_ptr = NULL;
  34
  35   avn = ecif->cif->nargs;
  36   p_argv = ecif->avalue;
  37
  38   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
  39        i != 0 && avn != 0;
  40        i--, p_arg++)
  41     {
  42       size_t z;
  43
  44       /* Align if necessary.  */
  45       if (((*p_arg)->alignment - 1) & (unsigned) argp)
  46         argp = (char *) ALIGN (argp, (*p_arg)->alignment);
  47
  48       if (avn != 0)
  49         {
  50           avn--;
  51           z = (*p_arg)->size;
  52           if (z < sizeof (int))
  53             {
  54               switch ((*p_arg)->type)
  55                 {
  56                 case FFI_TYPE_SINT8:
  57                   *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
  58                   break;
  59
  60                 case FFI_TYPE_UINT8:
  61                   *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
  62                   break;
  63
  64                 case FFI_TYPE_SINT16:
  65                   *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
  66                   break;
  67
  68                 case FFI_TYPE_UINT16:
  69                   *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
  70                   break;
  71
  72                 case FFI_TYPE_STRUCT:
  73                   memcpy (argp + sizeof (int) - z, *p_argv, z);
  74                   break;
  75
  76                 default:
  77                   FFI_ASSERT (0);
  78                 }
  79               z = sizeof (int);
  80             }
  81           else
  82             memcpy (argp, *p_argv, z);
  83           p_argv++;
  84           argp += z;
  85         }
  86     }
  87
  88   return struct_value_ptr;
  89 }
  90
  91 #define CIF_FLAGS_INT           1
  92 #define CIF_FLAGS_DINT          2
  93 #define CIF_FLAGS_FLOAT         4
  94 #define CIF_FLAGS_DOUBLE        8
  95 #define CIF_FLAGS_LDOUBLE       16
  96 #define CIF_FLAGS_POINTER       32
  97 #define CIF_FLAGS_STRUCT        64
  98
  99 /* Perform machine dependent cif processing */
 100 ffi_status
 101 ffi_prep_cif_machdep (ffi_cif *cif)
 102 {
 103   /* Set the return type flag */
 104   switch (cif->rtype->type)
 105     {
 106     case FFI_TYPE_VOID:
 107       cif->flags = 0;
 108       break;
 109
 110     case FFI_TYPE_STRUCT:
 111       if (cif->rtype->size > 4 && cif->rtype->size <= 8)
 112         cif->flags = CIF_FLAGS_DINT;
 113       else if (cif->rtype->size <= 4)
 114         cif->flags = CIF_FLAGS_STRUCT;
 115       else
 116         cif->flags = 0;
 117       break;
 118
 119     case FFI_TYPE_FLOAT:
 120       cif->flags = CIF_FLAGS_FLOAT;
 121       break;
 122
 123     case FFI_TYPE_DOUBLE:
 124       cif->flags = CIF_FLAGS_DOUBLE;
 125       break;
 126
 127     case FFI_TYPE_LONGDOUBLE:
 128       cif->flags = CIF_FLAGS_LDOUBLE;
 129       break;
 130
 131     case FFI_TYPE_POINTER:
 132       cif->flags = CIF_FLAGS_POINTER;
 133       break;
 134
 135     case FFI_TYPE_SINT64:
 136     case FFI_TYPE_UINT64:
 137       cif->flags = CIF_FLAGS_DINT;
 138       break;
 139
 140     default:
 141       cif->flags = CIF_FLAGS_INT;
 142       break;
 143     }
 144
 145   return FFI_OK;
 146 }
 147
 148 extern void ffi_call_SYSV (void *(*) (void *, extended_cif *),
 149                            extended_cif *,
 150                            unsigned, unsigned, unsigned,
 151                            void *, void (*fn) ());
 152
 153 void
 154 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
 155 {
 156   extended_cif ecif;
 157
 158   ecif.cif = cif;
 159   ecif.avalue = avalue;
 160
 161   /* If the return value is a struct and we don't have a return value
 162      address then we need to make one.  */
 163
 164   if (rvalue == NULL
 165       && cif->rtype->type == FFI_TYPE_STRUCT
 166       && cif->rtype->size > 8)
 167     ecif.rvalue = alloca (cif->rtype->size);
 168   else
 169     ecif.rvalue = rvalue;
 170
 171
 172   switch (cif->abi)
 173     {
 174     case FFI_SYSV:
 175       ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes,
 176                      cif->flags, cif->rtype->size * 8,
 177                      ecif.rvalue, fn);
 178       break;
 179
 180     default:
 181       FFI_ASSERT (0);
 182       break;
 183     }
 184 }