libffi/include/ffi.h.in

   1 /* -----------------------------------------------------------------*-C-*-
   2    libffi @VERSION@ - Copyright (c) 1996-2003  Red Hat, Inc.
   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, EXPRESS
  16    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18    IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21    OTHER DEALINGS IN THE SOFTWARE.
  22
  23    ----------------------------------------------------------------------- */
  24
  25 /* -------------------------------------------------------------------
  26    The basic API is described in the README file.
  27
  28    The raw API is designed to bypass some of the argument packing
  29    and unpacking on architectures for which it can be avoided.
  30
  31    The closure API allows interpreted functions to be packaged up
  32    inside a C function pointer, so that they can be called as C functions,
  33    with no understanding on the client side that they are interpreted.
  34    It can also be used in other cases in which it is necessary to package
  35    up a user specified parameter and a function pointer as a single
  36    function pointer.
  37
  38    The closure API must be implemented in order to get its functionality,
  39    e.g. for use by gij.  Routines are provided to emulate the raw API
  40    if the underlying platform doesn't allow faster implementation.
  41
  42    More details on the raw and cloure API can be found in:
  43
  44    http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
  45
  46    and
  47
  48    http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
  49    -------------------------------------------------------------------- */
  50
  51 #ifndef LIBFFI_H
  52 #define LIBFFI_H
  53
  54 #ifdef __cplusplus
  55 extern "C" {
  56 #endif
  57
  58 /* Specify which architecture libffi is configured for. */
  59 #define @TARGET@
  60
  61 /* ---- System configuration information --------------------------------- */
  62
  63 #include <ffitarget.h>
  64
  65 #ifndef LIBFFI_ASM
  66
  67 #include <stddef.h>
  68 #include <limits.h>
  69
  70 /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
  71    But we can find it either under the correct ANSI name, or under GNU
  72    C's internal name.  */
  73 #ifdef LONG_LONG_MAX
  74 # define FFI_LONG_LONG_MAX LONG_LONG_MAX
  75 #else
  76 # ifdef LLONG_MAX
  77 #  define FFI_LONG_LONG_MAX LLONG_MAX
  78 # else
  79 #  ifdef __GNUC__
  80 #   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
  81 #  endif
  82 # endif
  83 #endif
  84
  85 #if SCHAR_MAX == 127
  86 # define ffi_type_uchar                ffi_type_uint8
  87 # define ffi_type_schar                ffi_type_sint8
  88 #else
  89  #error "char size not supported"
  90 #endif
  91
  92 #if SHRT_MAX == 32767
  93 # define ffi_type_ushort       ffi_type_uint16
  94 # define ffi_type_sshort       ffi_type_sint16
  95 #elif SHRT_MAX == 2147483647
  96 # define ffi_type_ushort       ffi_type_uint32
  97 # define ffi_type_sshort       ffi_type_sint32
  98 #else
  99  #error "short size not supported"
 100 #endif
 101
 102 #if INT_MAX == 32767
 103 # define ffi_type_uint         ffi_type_uint16
 104 # define ffi_type_sint         ffi_type_sint16
 105 #elif INT_MAX == 2147483647
 106 # define ffi_type_uint         ffi_type_uint32
 107 # define ffi_type_sint         ffi_type_sint32
 108 #elif INT_MAX == 9223372036854775807
 109 # define ffi_type_uint         ffi_type_uint64
 110 # define ffi_type_sint         ffi_type_sint64
 111 #else
 112  #error "int size not supported"
 113 #endif
 114
 115 #if LONG_MAX == 2147483647
 116 # if FFI_LONG_LONG_MAX != 9223372036854775807
 117  #error "no 64-bit data type supported"
 118 # endif
 119 #elif LONG_MAX != 9223372036854775807
 120  #error "long size not supported"
 121 #endif
 122
 123 #if LONG_MAX == 2147483647
 124 # define ffi_type_ulong        ffi_type_uint32
 125 # define ffi_type_slong        ffi_type_sint32
 126 #elif LONG_MAX == 9223372036854775807
 127 # define ffi_type_ulong        ffi_type_uint64
 128 # define ffi_type_slong        ffi_type_sint64
 129 #else
 130  #error "long size not supported"
 131 #endif
 132
 133 /* The closure code assumes that this works on pointers, i.e. a size_t  */
 134 /* can hold a pointer.                                                  */
 135
 136 typedef struct _ffi_type
 137 {
 138   size_t size;
 139   unsigned short alignment;
 140   unsigned short type;
 141   struct _ffi_type **elements;
 142 } ffi_type;
 143
 144 /* These are defined in types.c */
 145 extern ffi_type ffi_type_void;
 146 extern ffi_type ffi_type_uint8;
 147 extern ffi_type ffi_type_sint8;
 148 extern ffi_type ffi_type_uint16;
 149 extern ffi_type ffi_type_sint16;
 150 extern ffi_type ffi_type_uint32;
 151 extern ffi_type ffi_type_sint32;
 152 extern ffi_type ffi_type_uint64;
 153 extern ffi_type ffi_type_sint64;
 154 extern ffi_type ffi_type_float;
 155 extern ffi_type ffi_type_double;
 156 extern ffi_type ffi_type_longdouble;
 157 extern ffi_type ffi_type_pointer;
 158
 159
 160 typedef enum {
 161   FFI_OK = 0,
 162   FFI_BAD_TYPEDEF,
 163   FFI_BAD_ABI
 164 } ffi_status;
 165
 166 typedef unsigned FFI_TYPE;
 167
 168 typedef struct {
 169   ffi_abi abi;
 170   unsigned nargs;
 171   ffi_type **arg_types;
 172   ffi_type *rtype;
 173   unsigned bytes;
 174   unsigned flags;
 175 #ifdef FFI_EXTRA_CIF_FIELDS
 176   FFI_EXTRA_CIF_FIELDS;
 177 #endif
 178 } ffi_cif;
 179
 180 /* ---- Definitions for the raw API -------------------------------------- */
 181
 182 #ifndef FFI_SIZEOF_ARG
 183 # if LONG_MAX == 2147483647
 184 #  define FFI_SIZEOF_ARG        4
 185 # elif LONG_MAX == 9223372036854775807
 186 #  define FFI_SIZEOF_ARG        8
 187 # endif
 188 #endif
 189
 190 typedef union {
 191   ffi_sarg  sint;
 192   ffi_arg   uint;
 193   float     flt;
 194   char      data[FFI_SIZEOF_ARG];
 195   void*     ptr;
 196 } ffi_raw;
 197
 198 void ffi_raw_call (ffi_cif *cif,
 199                    void (*fn)(),
 200                    void *rvalue,
 201                    ffi_raw *avalue);
 202
 203 void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
 204 void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
 205 size_t ffi_raw_size (ffi_cif *cif);
 206
 207 /* This is analogous to the raw API, except it uses Java parameter      */
 208 /* packing, even on 64-bit machines.  I.e. on 64-bit machines           */
 209 /* longs and doubles are followed by an empty 64-bit word.              */
 210
 211 void ffi_java_raw_call (ffi_cif *cif,
 212                         void (*fn)(),
 213                         void *rvalue,
 214                         ffi_raw *avalue);
 215
 216 void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
 217 void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
 218 size_t ffi_java_raw_size (ffi_cif *cif);
 219
 220 /* ---- Definitions for closures ----------------------------------------- */
 221
 222 #if FFI_CLOSURES
 223
 224 typedef struct {
 225   char tramp[FFI_TRAMPOLINE_SIZE];
 226   ffi_cif   *cif;
 227   void     (*fun)(ffi_cif*,void*,void**,void*);
 228   void      *user_data;
 229 } ffi_closure __attribute__((aligned (8)));
 230
 231 ffi_status
 232 ffi_prep_closure (ffi_closure*,
 233                   ffi_cif *,
 234                   void (*fun)(ffi_cif*,void*,void**,void*),
 235                   void *user_data);
 236
 237 typedef struct {
 238   char tramp[FFI_TRAMPOLINE_SIZE];
 239
 240   ffi_cif   *cif;
 241
 242 #if !FFI_NATIVE_RAW_API
 243
 244   /* if this is enabled, then a raw closure has the same layout
 245      as a regular closure.  We use this to install an intermediate
 246      handler to do the transaltion, void** -> ffi_raw*. */
 247
 248   void     (*translate_args)(ffi_cif*,void*,void**,void*);
 249   void      *this_closure;
 250
 251 #endif
 252
 253   void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
 254   void      *user_data;
 255
 256 } ffi_raw_closure;
 257
 258 ffi_status
 259 ffi_prep_raw_closure (ffi_raw_closure*,
 260                       ffi_cif *cif,
 261                       void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 262                       void *user_data);
 263
 264 ffi_status
 265 ffi_prep_java_raw_closure (ffi_raw_closure*,
 266                            ffi_cif *cif,
 267                            void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 268                            void *user_data);
 269
 270 #endif /* FFI_CLOSURES */
 271
 272 /* ---- Public interface definition -------------------------------------- */
 273
 274 ffi_status ffi_prep_cif(ffi_cif *cif,
 275                         ffi_abi abi,
 276                         unsigned int nargs,
 277                         ffi_type *rtype,
 278                         ffi_type **atypes);
 279
 280 void ffi_call(ffi_cif *cif,
 281               void (*fn)(),
 282               void *rvalue,
 283               void **avalue);
 284
 285 /* Useful for eliminating compiler warnings */
 286 #define FFI_FN(f) ((void (*)())f)
 287
 288 /* ---- Definitions shared with assembly code ---------------------------- */
 289
 290 #endif
 291
 292 /* If these change, update src/mips/ffitarget.h. */
 293 #define FFI_TYPE_VOID       0
 294 #define FFI_TYPE_INT        1
 295 #define FFI_TYPE_FLOAT      2
 296 #define FFI_TYPE_DOUBLE     3
 297 #if @HAVE_LONG_DOUBLE@
 298 #define FFI_TYPE_LONGDOUBLE 4
 299 #else
 300 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
 301 #endif
 302 #define FFI_TYPE_UINT8      5
 303 #define FFI_TYPE_SINT8      6
 304 #define FFI_TYPE_UINT16     7
 305 #define FFI_TYPE_SINT16     8
 306 #define FFI_TYPE_UINT32     9
 307 #define FFI_TYPE_SINT32     10
 308 #define FFI_TYPE_UINT64     11
 309 #define FFI_TYPE_SINT64     12
 310 #define FFI_TYPE_STRUCT     13
 311 #define FFI_TYPE_POINTER    14
 312
 313 /* This should always refer to the last type code (for sanity checks) */
 314 #define FFI_TYPE_LAST       FFI_TYPE_POINTER
 315
 316 #ifdef __cplusplus
 317 }
 318 #endif
 319
 320 #endif
 321