libffi/src/raw_api.c

   1 /* -----------------------------------------------------------------------
   2    raw_api.c - Copyright (c) 1999  Red Hat, Inc.
   3
   4    Author: Kresten Krab Thorup <krab@gnu.org>
   5
   6    $Id $
   7
   8    Permission is hereby granted, free of charge, to any person obtaining
   9    a copy of this software and associated documentation files (the
  10    ``Software''), to deal in the Software without restriction, including
  11    without limitation the rights to use, copy, modify, merge, publish,
  12    distribute, sublicense, and/or sell copies of the Software, and to
  13    permit persons to whom the Software is furnished to do so, subject to
  14    the following conditions:
  15
  16    The above copyright notice and this permission notice shall be included
  17    in all copies or substantial portions of the Software.
  18
  19    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22    IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25    OTHER DEALINGS IN THE SOFTWARE.
  26    ----------------------------------------------------------------------- */
  27
  28 /* This file defines generic functions for use with the raw api. */
  29
  30 #include <ffi.h>
  31 #include <ffi_common.h>
  32
  33 #if !FFI_NO_RAW_API
  34
  35 size_t
  36 ffi_raw_size (ffi_cif *cif)
  37 {
  38   size_t result = 0;
  39   int i;
  40
  41   ffi_type **at = cif->arg_types;
  42
  43   for (i = cif->nargs-1; i >= 0; i--, at++)
  44     {
  45 #if !FFI_NO_STRUCTS
  46       if ((*at)->type == FFI_TYPE_STRUCT)
  47         result += ALIGN (sizeof (void*), FFI_SIZEOF_ARG);
  48       else
  49 #endif
  50         result += ALIGN ((*at)->size, FFI_SIZEOF_ARG);
  51     }
  52
  53   return result;
  54 }
  55
  56
  57 void
  58 ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args)
  59 {
  60   unsigned i;
  61   ffi_type **tp = cif->arg_types;
  62
  63 #if WORDS_BIGENDIAN
  64
  65   for (i = 0; i < cif->nargs; i++, tp++, args++)
  66     {
  67       switch ((*tp)->type)
  68         {
  69         case FFI_TYPE_UINT8:
  70         case FFI_TYPE_SINT8:
  71           *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 1);
  72           break;
  73
  74         case FFI_TYPE_UINT16:
  75         case FFI_TYPE_SINT16:
  76           *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 2);
  77           break;
  78
  79 #if FFI_SIZEOF_ARG >= 4
  80         case FFI_TYPE_UINT32:
  81         case FFI_TYPE_SINT32:
  82           *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 4);
  83           break;
  84 #endif
  85
  86 #if !FFI_NO_STRUCTS
  87         case FFI_TYPE_STRUCT:
  88           *args = (raw++)->ptr;
  89           break;
  90 #endif
  91
  92         case FFI_TYPE_POINTER:
  93           *args = (void*) &(raw++)->ptr;
  94           break;
  95
  96         default:
  97           *args = raw;
  98           raw += ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
  99         }
 100     }
 101
 102 #else /* WORDS_BIGENDIAN */
 103
 104 #if !PDP
 105
 106   /* then assume little endian */
 107   for (i = 0; i < cif->nargs; i++, tp++, args++)
 108     {
 109 #if !FFI_NO_STRUCTS
 110       if ((*tp)->type == FFI_TYPE_STRUCT)
 111         {
 112           *args = (raw++)->ptr;
 113         }
 114       else
 115 #endif
 116         {
 117           *args = (void*) raw;
 118           raw += ALIGN ((*tp)->size, sizeof (void*)) / sizeof (void*);
 119         }
 120     }
 121
 122 #else
 123 #error "pdp endian not supported"
 124 #endif /* ! PDP */
 125
 126 #endif /* WORDS_BIGENDIAN */
 127 }
 128
 129 void
 130 ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw)
 131 {
 132   unsigned i;
 133   ffi_type **tp = cif->arg_types;
 134
 135   for (i = 0; i < cif->nargs; i++, tp++, args++)
 136     {
 137       switch ((*tp)->type)
 138         {
 139         case FFI_TYPE_UINT8:
 140           (raw++)->uint = *(UINT8*) (*args);
 141           break;
 142
 143         case FFI_TYPE_SINT8:
 144           (raw++)->sint = *(SINT8*) (*args);
 145           break;
 146
 147         case FFI_TYPE_UINT16:
 148           (raw++)->uint = *(UINT16*) (*args);
 149           break;
 150
 151         case FFI_TYPE_SINT16:
 152           (raw++)->sint = *(SINT16*) (*args);
 153           break;
 154
 155 #if FFI_SIZEOF_ARG >= 4
 156         case FFI_TYPE_UINT32:
 157           (raw++)->uint = *(UINT32*) (*args);
 158           break;
 159
 160         case FFI_TYPE_SINT32:
 161           (raw++)->sint = *(SINT32*) (*args);
 162           break;
 163 #endif
 164
 165 #if !FFI_NO_STRUCTS
 166         case FFI_TYPE_STRUCT:
 167           (raw++)->ptr = *args;
 168           break;
 169 #endif
 170
 171         case FFI_TYPE_POINTER:
 172           (raw++)->ptr = **(void***) args;
 173           break;
 174
 175         default:
 176           memcpy ((void*) raw->data, (void*)*args, (*tp)->size);
 177           raw += ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
 178         }
 179     }
 180 }
 181
 182 #if !FFI_NATIVE_RAW_API
 183
 184
 185 /* This is a generic definition of ffi_raw_call, to be used if the
 186  * native system does not provide a machine-specific implementation.
 187  * Having this, allows code to be written for the raw API, without
 188  * the need for system-specific code to handle input in that format;
 189  * these following couple of functions will handle the translation forth
 190  * and back automatically. */
 191
 192 void ffi_raw_call (/*@dependent@*/ ffi_cif *cif,
 193                    void (*fn)(),
 194                    /*@out@*/ void *rvalue,
 195                    /*@dependent@*/ ffi_raw *raw)
 196 {
 197   void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
 198   ffi_raw_to_ptrarray (cif, raw, avalue);
 199   ffi_call (cif, fn, rvalue, avalue);
 200 }
 201
 202 #if FFI_CLOSURES                /* base system provides closures */
 203
 204 static void
 205 ffi_translate_args (ffi_cif *cif, void *rvalue,
 206                     void **avalue, void *user_data)
 207 {
 208   ffi_raw *raw = (ffi_raw*)alloca (ffi_raw_size (cif));
 209   ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
 210
 211   ffi_ptrarray_to_raw (cif, avalue, raw);
 212   (*cl->fun) (cif, rvalue, raw, cl->user_data);
 213 }
 214
 215 /* Again, here is the generic version of ffi_prep_raw_closure, which
 216  * will install an intermediate "hub" for translation of arguments from
 217  * the pointer-array format, to the raw format */
 218
 219 ffi_status
 220 ffi_prep_raw_closure (ffi_raw_closure* cl,
 221                       ffi_cif *cif,
 222                       void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 223                       void *user_data)
 224 {
 225   ffi_status status;
 226
 227   status = ffi_prep_closure ((ffi_closure*) cl,
 228                              cif,
 229                              &ffi_translate_args,
 230                              (void*)cl);
 231   if (status == FFI_OK)
 232     {
 233       cl->fun       = fun;
 234       cl->user_data = user_data;
 235     }
 236
 237   return status;
 238 }
 239
 240 #endif /* FFI_CLOSURES */
 241 #endif /* !FFI_NATIVE_RAW_API */
 242 #endif /* !FFI_NO_RAW_API */