shotgun/external_libs/libffi/src/java_raw_api.c

   1 /* -----------------------------------------------------------------------
   2    java_raw_api.c - Copyright (c) 1999, 2007  Red Hat, Inc.
   3
   4    Cloned from raw_api.c
   5
   6    Raw_api.c author: Kresten Krab Thorup <krab@gnu.org>
   7    Java_raw_api.c author: Hans-J. Boehm <hboehm@hpl.hp.com>
   8
   9    $Id $
  10
  11    Permission is hereby granted, free of charge, to any person obtaining
  12    a copy of this software and associated documentation files (the
  13    ``Software''), to deal in the Software without restriction, including
  14    without limitation the rights to use, copy, modify, merge, publish,
  15    distribute, sublicense, and/or sell copies of the Software, and to
  16    permit persons to whom the Software is furnished to do so, subject to
  17    the following conditions:
  18
  19    The above copyright notice and this permission notice shall be included
  20    in all copies or substantial portions of the Software.
  21
  22    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  23    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  26    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  27    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  28    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  29    DEALINGS IN THE SOFTWARE.
  30    ----------------------------------------------------------------------- */
  31
  32 /* This defines a Java- and 64-bit specific variant of the raw API.     */
  33 /* It assumes that "raw" argument blocks look like Java stacks on a     */
  34 /* 64-bit machine.  Arguments that can be stored in a single stack      */
  35 /* stack slots (longs, doubles) occupy 128 bits, but only the first     */
  36 /* 64 bits are actually used.                                           */
  37
  38 #include <ffi.h>
  39 #include <ffi_common.h>
  40 #include <stdlib.h>
  41
  42 #if !defined(NO_JAVA_RAW_API) && !defined(FFI_NO_RAW_API)
  43
  44 size_t
  45 ffi_java_raw_size (ffi_cif *cif)
  46 {
  47   size_t result = 0;
  48   int i;
  49
  50   ffi_type **at = cif->arg_types;
  51
  52   for (i = cif->nargs-1; i >= 0; i--, at++)
  53     {
  54       switch((*at) -> type) {
  55         case FFI_TYPE_UINT64:
  56         case FFI_TYPE_SINT64:
  57         case FFI_TYPE_DOUBLE:
  58           result += 2 * FFI_SIZEOF_JAVA_RAW;
  59           break;
  60         case FFI_TYPE_STRUCT:
  61           /* No structure parameters in Java.   */
  62           abort();
  63         default:
  64           result += FFI_SIZEOF_JAVA_RAW;
  65       }
  66     }
  67
  68   return result;
  69 }
  70
  71
  72 void
  73 ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args)
  74 {
  75   unsigned i;
  76   ffi_type **tp = cif->arg_types;
  77
  78 #if WORDS_BIGENDIAN
  79
  80   for (i = 0; i < cif->nargs; i++, tp++, args++)
  81     {
  82       switch ((*tp)->type)
  83         {
  84         case FFI_TYPE_UINT8:
  85         case FFI_TYPE_SINT8:
  86           *args = (void*) ((char*)(raw++) + 3);
  87           break;
  88
  89         case FFI_TYPE_UINT16:
  90         case FFI_TYPE_SINT16:
  91           *args = (void*) ((char*)(raw++) + 2);
  92           break;
  93
  94 #if FFI_SIZEOF_JAVA_RAW == 8
  95         case FFI_TYPE_UINT64:
  96         case FFI_TYPE_SINT64:
  97         case FFI_TYPE_DOUBLE:
  98           *args = (void *)raw;
  99           raw += 2;
 100           break;
 101 #endif
 102
 103         case FFI_TYPE_POINTER:
 104           *args = (void*) &(raw++)->ptr;
 105           break;
 106
 107         default:
 108           *args = raw;
 109           raw +=
 110             ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
 111         }
 112     }
 113
 114 #else /* WORDS_BIGENDIAN */
 115
 116 #if !PDP
 117
 118   /* then assume little endian */
 119   for (i = 0; i < cif->nargs; i++, tp++, args++)
 120     {
 121 #if FFI_SIZEOF_JAVA_RAW == 8
 122       switch((*tp)->type) {
 123         case FFI_TYPE_UINT64:
 124         case FFI_TYPE_SINT64:
 125         case FFI_TYPE_DOUBLE:
 126           *args = (void*) raw;
 127           raw += 2;
 128           break;
 129         default:
 130           *args = (void*) raw++;
 131       }
 132 #else /* FFI_SIZEOF_JAVA_RAW != 8 */
 133         *args = (void*) raw;
 134         raw +=
 135           ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
 136 #endif /* FFI_SIZEOF_JAVA_RAW == 8 */
 137     }
 138
 139 #else
 140 #error "pdp endian not supported"
 141 #endif /* ! PDP */
 142
 143 #endif /* WORDS_BIGENDIAN */
 144 }
 145
 146 void
 147 ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw)
 148 {
 149   unsigned i;
 150   ffi_type **tp = cif->arg_types;
 151
 152   for (i = 0; i < cif->nargs; i++, tp++, args++)
 153     {
 154       switch ((*tp)->type)
 155         {
 156         case FFI_TYPE_UINT8:
 157 #if WORDS_BIGENDIAN
 158           *(UINT32*)(raw++) = *(UINT8*) (*args);
 159 #else
 160           (raw++)->uint = *(UINT8*) (*args);
 161 #endif
 162           break;
 163
 164         case FFI_TYPE_SINT8:
 165 #if WORDS_BIGENDIAN
 166           *(SINT32*)(raw++) = *(SINT8*) (*args);
 167 #else
 168           (raw++)->sint = *(SINT8*) (*args);
 169 #endif
 170           break;
 171
 172         case FFI_TYPE_UINT16:
 173 #if WORDS_BIGENDIAN
 174           *(UINT32*)(raw++) = *(UINT16*) (*args);
 175 #else
 176           (raw++)->uint = *(UINT16*) (*args);
 177 #endif
 178           break;
 179
 180         case FFI_TYPE_SINT16:
 181 #if WORDS_BIGENDIAN
 182           *(SINT32*)(raw++) = *(SINT16*) (*args);
 183 #else
 184           (raw++)->sint = *(SINT16*) (*args);
 185 #endif
 186           break;
 187
 188         case FFI_TYPE_UINT32:
 189 #if WORDS_BIGENDIAN
 190           *(UINT32*)(raw++) = *(UINT32*) (*args);
 191 #else
 192           (raw++)->uint = *(UINT32*) (*args);
 193 #endif
 194           break;
 195
 196         case FFI_TYPE_SINT32:
 197 #if WORDS_BIGENDIAN
 198           *(SINT32*)(raw++) = *(SINT32*) (*args);
 199 #else
 200           (raw++)->sint = *(SINT32*) (*args);
 201 #endif
 202           break;
 203
 204         case FFI_TYPE_FLOAT:
 205           (raw++)->flt = *(FLOAT32*) (*args);
 206           break;
 207
 208 #if FFI_SIZEOF_JAVA_RAW == 8
 209         case FFI_TYPE_UINT64:
 210         case FFI_TYPE_SINT64:
 211         case FFI_TYPE_DOUBLE:
 212           raw->uint = *(UINT64*) (*args);
 213           raw += 2;
 214           break;
 215 #endif
 216
 217         case FFI_TYPE_POINTER:
 218           (raw++)->ptr = **(void***) args;
 219           break;
 220
 221         default:
 222 #if FFI_SIZEOF_JAVA_RAW == 8
 223           FFI_ASSERT(0);        /* Should have covered all cases */
 224 #else
 225           memcpy ((void*) raw->data, (void*)*args, (*tp)->size);
 226           raw +=
 227             ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
 228 #endif
 229         }
 230     }
 231 }
 232
 233 #if !FFI_NATIVE_RAW_API
 234
 235 static void
 236 ffi_java_rvalue_to_raw (ffi_cif *cif, void *rvalue)
 237 {
 238 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
 239   switch (cif->rtype->type)
 240     {
 241     case FFI_TYPE_UINT8:
 242     case FFI_TYPE_UINT16:
 243     case FFI_TYPE_UINT32:
 244       *(UINT64 *)rvalue <<= 32;
 245       break;
 246
 247     case FFI_TYPE_SINT8:
 248     case FFI_TYPE_SINT16:
 249     case FFI_TYPE_SINT32:
 250     case FFI_TYPE_INT:
 251 #if FFI_SIZEOF_JAVA_RAW == 4
 252     case FFI_TYPE_POINTER:
 253 #endif
 254       *(SINT64 *)rvalue <<= 32;
 255       break;
 256
 257     default:
 258       break;
 259     }
 260 #endif
 261 }
 262
 263 static void
 264 ffi_java_raw_to_rvalue (ffi_cif *cif, void *rvalue)
 265 {
 266 #if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
 267   switch (cif->rtype->type)
 268     {
 269     case FFI_TYPE_UINT8:
 270     case FFI_TYPE_UINT16:
 271     case FFI_TYPE_UINT32:
 272       *(UINT64 *)rvalue >>= 32;
 273       break;
 274
 275     case FFI_TYPE_SINT8:
 276     case FFI_TYPE_SINT16:
 277     case FFI_TYPE_SINT32:
 278     case FFI_TYPE_INT:
 279 #if FFI_SIZEOF_JAVA_RAW == 4
 280     case FFI_TYPE_POINTER:
 281 #endif
 282       *(SINT64 *)rvalue >>= 32;
 283       break;
 284
 285     default:
 286       break;
 287     }
 288 #endif
 289 }
 290
 291 /* This is a generic definition of ffi_raw_call, to be used if the
 292  * native system does not provide a machine-specific implementation.
 293  * Having this, allows code to be written for the raw API, without
 294  * the need for system-specific code to handle input in that format;
 295  * these following couple of functions will handle the translation forth
 296  * and back automatically. */
 297
 298 void ffi_java_raw_call (ffi_cif *cif, void (*fn)(), void *rvalue,
 299                         ffi_java_raw *raw)
 300 {
 301   void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
 302   ffi_java_raw_to_ptrarray (cif, raw, avalue);
 303   ffi_call (cif, fn, rvalue, avalue);
 304   ffi_java_rvalue_to_raw (cif, rvalue);
 305 }
 306
 307 #if FFI_CLOSURES                /* base system provides closures */
 308
 309 static void
 310 ffi_java_translate_args (ffi_cif *cif, void *rvalue,
 311                     void **avalue, void *user_data)
 312 {
 313   ffi_java_raw *raw = (ffi_java_raw*)alloca (ffi_java_raw_size (cif));
 314   ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
 315
 316   ffi_java_ptrarray_to_raw (cif, avalue, raw);
 317   (*cl->fun) (cif, rvalue, raw, cl->user_data);
 318   ffi_java_raw_to_rvalue (cif, rvalue);
 319 }
 320
 321 ffi_status
 322 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure* cl,
 323                                ffi_cif *cif,
 324                                void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 325                                void *user_data,
 326                                void *codeloc)
 327 {
 328   ffi_status status;
 329
 330   status = ffi_prep_closure_loc ((ffi_closure*) cl,
 331                                  cif,
 332                                  &ffi_java_translate_args,
 333                                  codeloc,
 334                                  codeloc);
 335   if (status == FFI_OK)
 336     {
 337       cl->fun       = fun;
 338       cl->user_data = user_data;
 339     }
 340
 341   return status;
 342 }
 343
 344 /* Again, here is the generic version of ffi_prep_raw_closure, which
 345  * will install an intermediate "hub" for translation of arguments from
 346  * the pointer-array format, to the raw format */
 347
 348 ffi_status
 349 ffi_prep_java_raw_closure (ffi_java_raw_closure* cl,
 350                            ffi_cif *cif,
 351                            void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 352                            void *user_data)
 353 {
 354   return ffi_prep_java_raw_closure_loc (cl, cif, fun, user_data, cl);
 355 }
 356
 357 #endif /* FFI_CLOSURES */
 358 #endif /* !FFI_NATIVE_RAW_API */
 359 #endif /* !FFI_NO_RAW_API */