libffi/src/vax/ffi.c

   1 /*
   2  * Copyright (c) 2013 Miodrag Vallat.  <miod@openbsd.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * ``Software''), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included
  13  * in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  19  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  20  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  21  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /*
  25  * vax Foreign Function Interface
  26  *
  27  * This file attempts to provide all the FFI entry points which can reliably
  28  * be implemented in C.
  29  */
  30
  31 #include <ffi.h>
  32 #include <ffi_common.h>
  33
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36
  37 #define CIF_FLAGS_CHAR          1       /* for struct only */
  38 #define CIF_FLAGS_SHORT         2       /* for struct only */
  39 #define CIF_FLAGS_INT           4
  40 #define CIF_FLAGS_DINT          8
  41
  42 /*
  43  * Foreign Function Interface API
  44  */
  45
  46 void ffi_call_elfbsd (extended_cif *, unsigned, unsigned, void *,
  47                        void (*) ());
  48 void *ffi_prep_args (extended_cif *ecif, void *stack);
  49
  50 void *
  51 ffi_prep_args (extended_cif *ecif, void *stack)
  52 {
  53   unsigned int i;
  54   void **p_argv;
  55   char *argp;
  56   ffi_type **p_arg;
  57   void *struct_value_ptr;
  58
  59   argp = stack;
  60
  61   if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
  62       && !ecif->cif->flags)
  63     struct_value_ptr = ecif->rvalue;
  64   else
  65     struct_value_ptr = NULL;
  66
  67   p_argv = ecif->avalue;
  68
  69   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
  70        i != 0;
  71        i--, p_arg++)
  72     {
  73       size_t z;
  74
  75       z = (*p_arg)->size;
  76       if (z < sizeof (int))
  77         {
  78           switch ((*p_arg)->type)
  79             {
  80             case FFI_TYPE_SINT8:
  81               *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
  82               break;
  83
  84             case FFI_TYPE_UINT8:
  85               *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
  86               break;
  87
  88             case FFI_TYPE_SINT16:
  89               *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
  90               break;
  91
  92             case FFI_TYPE_UINT16:
  93               *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
  94               break;
  95
  96             case FFI_TYPE_STRUCT:
  97               memcpy (argp, *p_argv, z);
  98               break;
  99
 100             default:
 101               FFI_ASSERT (0);
 102             }
 103           z = sizeof (int);
 104         }
 105       else
 106         {
 107           memcpy (argp, *p_argv, z);
 108
 109           /* Align if necessary.  */
 110           if ((sizeof(int) - 1) & z)
 111             z = ALIGN(z, sizeof(int));
 112         }
 113
 114       p_argv++;
 115       argp += z;
 116     }
 117
 118   return struct_value_ptr;
 119 }
 120
 121 ffi_status
 122 ffi_prep_cif_machdep (ffi_cif *cif)
 123 {
 124   /* Set the return type flag */
 125   switch (cif->rtype->type)
 126     {
 127     case FFI_TYPE_VOID:
 128       cif->flags = 0;
 129       break;
 130
 131     case FFI_TYPE_STRUCT:
 132       if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT &&
 133           cif->rtype->elements[1])
 134         {
 135           cif->flags = 0;
 136           break;
 137         }
 138
 139       if (cif->rtype->size == sizeof (char))
 140         cif->flags = CIF_FLAGS_CHAR;
 141       else if (cif->rtype->size == sizeof (short))
 142         cif->flags = CIF_FLAGS_SHORT;
 143       else if (cif->rtype->size == sizeof (int))
 144         cif->flags = CIF_FLAGS_INT;
 145       else if (cif->rtype->size == 2 * sizeof (int))
 146         cif->flags = CIF_FLAGS_DINT;
 147       else
 148         cif->flags = 0;
 149       break;
 150
 151     default:
 152       if (cif->rtype->size <= sizeof (int))
 153         cif->flags = CIF_FLAGS_INT;
 154       else
 155         cif->flags = CIF_FLAGS_DINT;
 156       break;
 157     }
 158
 159   return FFI_OK;
 160 }
 161
 162 void
 163 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
 164 {
 165   extended_cif ecif;
 166
 167   ecif.cif = cif;
 168   ecif.avalue = avalue;
 169
 170   /* If the return value is a struct and we don't have a return value
 171      address then we need to make one.  */
 172
 173   if (rvalue == NULL
 174       && cif->rtype->type == FFI_TYPE_STRUCT
 175       && cif->flags == 0)
 176     ecif.rvalue = alloca (cif->rtype->size);
 177   else
 178     ecif.rvalue = rvalue;
 179
 180   switch (cif->abi)
 181     {
 182     case FFI_ELFBSD:
 183       ffi_call_elfbsd (&ecif, cif->bytes, cif->flags, ecif.rvalue, fn);
 184       break;
 185
 186     default:
 187       FFI_ASSERT (0);
 188       break;
 189     }
 190 }
 191
 192 /*
 193  * Closure API
 194  */
 195
 196 void ffi_closure_elfbsd (void);
 197 void ffi_closure_struct_elfbsd (void);
 198 unsigned int ffi_closure_elfbsd_inner (ffi_closure *, void *, char *);
 199
 200 static void
 201 ffi_prep_closure_elfbsd (ffi_cif *cif, void **avalue, char *stackp)
 202 {
 203   unsigned int i;
 204   void **p_argv;
 205   ffi_type **p_arg;
 206
 207   p_argv = avalue;
 208
 209   for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
 210     {
 211       size_t z;
 212
 213       z = (*p_arg)->size;
 214       *p_argv = stackp;
 215
 216       /* Align if necessary */
 217       if ((sizeof (int) - 1) & z)
 218         z = ALIGN(z, sizeof (int));
 219
 220       p_argv++;
 221       stackp += z;
 222     }
 223 }
 224
 225 unsigned int
 226 ffi_closure_elfbsd_inner (ffi_closure *closure, void *resp, char *stack)
 227 {
 228   ffi_cif *cif;
 229   void **arg_area;
 230
 231   cif = closure->cif;
 232   arg_area = (void **) alloca (cif->nargs * sizeof (void *));
 233
 234   ffi_prep_closure_elfbsd (cif, arg_area, stack);
 235
 236   (closure->fun) (cif, resp, arg_area, closure->user_data);
 237
 238   return cif->flags;
 239 }
 240
 241 ffi_status
 242 ffi_prep_closure_loc (ffi_closure *closure, ffi_cif *cif,
 243                       void (*fun)(ffi_cif *, void *, void **, void *),
 244                       void *user_data, void *codeloc)
 245 {
 246   char *tramp = (char *) codeloc;
 247   void *fn;
 248
 249   FFI_ASSERT (cif->abi == FFI_ELFBSD);
 250
 251   /* entry mask */
 252   *(unsigned short *)(tramp + 0) = 0x0000;
 253   /* movl #closure, r0 */
 254   tramp[2] = 0xd0;
 255   tramp[3] = 0x8f;
 256   *(unsigned int *)(tramp + 4) = (unsigned int) closure;
 257   tramp[8] = 0x50;
 258
 259   if (cif->rtype->type == FFI_TYPE_STRUCT
 260       && !cif->flags)
 261     fn = &ffi_closure_struct_elfbsd;
 262   else
 263     fn = &ffi_closure_elfbsd;
 264
 265   /* jmpl #fn */
 266   tramp[9] = 0x17;
 267   tramp[10] = 0xef;
 268   *(unsigned int *)(tramp + 11) = (unsigned int)fn + 2 -
 269                                   (unsigned int)tramp - 9 - 6;
 270
 271   closure->cif = cif;
 272   closure->user_data = user_data;
 273   closure->fun = fun;
 274
 275   return FFI_OK;
 276 }