libffi/src/java_raw_api.c

   1 /* -----------------------------------------------------------------------
   2    java_raw_api.c - Copyright (c) 1999, 2007, 2008  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       *(SINT64 *)rvalue >>= 32;
 280       break;
 281
 282     default:
 283       break;
 284     }
 285 #endif
 286 }
 287
 288 /* This is a generic definition of ffi_raw_call, to be used if the
 289  * native system does not provide a machine-specific implementation.
 290  * Having this, allows code to be written for the raw API, without
 291  * the need for system-specific code to handle input in that format;
 292  * these following couple of functions will handle the translation forth
 293  * and back automatically. */
 294
 295 void ffi_java_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue,
 296                         ffi_java_raw *raw)
 297 {
 298   void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
 299   ffi_java_raw_to_ptrarray (cif, raw, avalue);
 300   ffi_call (cif, fn, rvalue, avalue);
 301   ffi_java_rvalue_to_raw (cif, rvalue);
 302 }
 303
 304 #if FFI_CLOSURES                /* base system provides closures */
 305
 306 static void
 307 ffi_java_translate_args (ffi_cif *cif, void *rvalue,
 308                     void **avalue, void *user_data)
 309 {
 310   ffi_java_raw *raw = (ffi_java_raw*)alloca (ffi_java_raw_size (cif));
 311   ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
 312
 313   ffi_java_ptrarray_to_raw (cif, avalue, raw);
 314   (*cl->fun) (cif, rvalue, raw, cl->user_data);
 315   ffi_java_raw_to_rvalue (cif, rvalue);
 316 }
 317
 318 ffi_status
 319 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure* cl,
 320                                ffi_cif *cif,
 321                                void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 322                                void *user_data,
 323                                void *codeloc)
 324 {
 325   ffi_status status;
 326
 327   status = ffi_prep_closure_loc ((ffi_closure*) cl,
 328                                  cif,
 329                                  &ffi_java_translate_args,
 330                                  codeloc,
 331                                  codeloc);
 332   if (status == FFI_OK)
 333     {
 334       cl->fun       = fun;
 335       cl->user_data = user_data;
 336     }
 337
 338   return status;
 339 }
 340
 341 /* Again, here is the generic version of ffi_prep_raw_closure, which
 342  * will install an intermediate "hub" for translation of arguments from
 343  * the pointer-array format, to the raw format */
 344
 345 ffi_status
 346 ffi_prep_java_raw_closure (ffi_java_raw_closure* cl,
 347                            ffi_cif *cif,
 348                            void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 349                            void *user_data)
 350 {
 351   return ffi_prep_java_raw_closure_loc (cl, cif, fun, user_data, cl);
 352 }
 353
 354 #endif /* FFI_CLOSURES */
 355 #endif /* !FFI_NATIVE_RAW_API */
 356 #endif /* !FFI_NO_RAW_API */