The Ecere SDK - sdk/blob - deps/libffi-3.0.11/i686-pc-mingw32/include/ffi.h

   1 /* -----------------------------------------------------------------*-C-*-
   2    libffi 3.0.11 - Copyright (c) 2011 Anthony Green
   3                     - Copyright (c) 1996-2003, 2007, 2008 Red Hat, Inc.
   4
   5    Permission is hereby granted, free of charge, to any person
   6    obtaining a copy of this software and associated documentation
   7    files (the ``Software''), to deal in the Software without
   8    restriction, including without limitation the rights to use, copy,
   9    modify, merge, publish, distribute, sublicense, and/or sell copies
  10    of the Software, and to permit persons to whom the Software is
  11    furnished to do so, subject to the following conditions:
  12
  13    The above copyright notice and this permission notice shall be
  14    included in all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  17    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  20    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23    DEALINGS IN THE SOFTWARE.
  24
  25    ----------------------------------------------------------------------- */
  26
  27 /* -------------------------------------------------------------------
  28    The basic API is described in the README file.
  29
  30    The raw API is designed to bypass some of the argument packing
  31    and unpacking on architectures for which it can be avoided.
  32
  33    The closure API allows interpreted functions to be packaged up
  34    inside a C function pointer, so that they can be called as C functions,
  35    with no understanding on the client side that they are interpreted.
  36    It can also be used in other cases in which it is necessary to package
  37    up a user specified parameter and a function pointer as a single
  38    function pointer.
  39
  40    The closure API must be implemented in order to get its functionality,
  41    e.g. for use by gij.  Routines are provided to emulate the raw API
  42    if the underlying platform doesn't allow faster implementation.
  43
  44    More details on the raw and cloure API can be found in:
  45
  46    http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
  47
  48    and
  49
  50    http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
  51    -------------------------------------------------------------------- */
  52
  53 #ifndef LIBFFI_H
  54 #define LIBFFI_H
  55
  56 #ifdef __cplusplus
  57 extern "C" {
  58 #endif
  59
  60 /* Specify which architecture libffi is configured for. */
  61 #ifdef _W64
  62
  63 #ifndef X86_WIN64
  64 #define X86_WIN64
  65 #endif
  66
  67 #else
  68
  69 #ifndef X86_WIN32
  70 #define X86_WIN32
  71 #endif
  72
  73 #endif
  74
  75 /* ---- System configuration information --------------------------------- */
  76
  77 #include <ffitarget.h>
  78
  79 #ifndef LIBFFI_ASM
  80
  81 #ifdef _MSC_VER
  82 #define __attribute__(X)
  83 #endif
  84
  85 #include <stddef.h>
  86 #include <limits.h>
  87
  88 /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
  89    But we can find it either under the correct ANSI name, or under GNU
  90    C's internal name.  */
  91
  92 #define FFI_64_BIT_MAX 9223372036854775807
  93
  94 #ifdef LONG_LONG_MAX
  95 # define FFI_LONG_LONG_MAX LONG_LONG_MAX
  96 #else
  97 # ifdef LLONG_MAX
  98 #  define FFI_LONG_LONG_MAX LLONG_MAX
  99 #  ifdef _AIX52 /* or newer has C99 LLONG_MAX */
 100 #   undef FFI_64_BIT_MAX
 101 #   define FFI_64_BIT_MAX 9223372036854775807LL
 102 #  endif /* _AIX52 or newer */
 103 # else
 104 #  ifdef __GNUC__
 105 #   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
 106 #  endif
 107 #  ifdef _AIX /* AIX 5.1 and earlier have LONGLONG_MAX */
 108 #   ifndef __PPC64__
 109 #    if defined (__IBMC__) || defined (__IBMCPP__)
 110 #     define FFI_LONG_LONG_MAX LONGLONG_MAX
 111 #    endif
 112 #   endif /* __PPC64__ */
 113 #   undef  FFI_64_BIT_MAX
 114 #   define FFI_64_BIT_MAX 9223372036854775807LL
 115 #  endif
 116 # endif
 117 #endif
 118
 119 /* The closure code assumes that this works on pointers, i.e. a size_t  */
 120 /* can hold a pointer.                                                  */
 121
 122 typedef struct _ffi_type
 123 {
 124   size_t size;
 125   unsigned short alignment;
 126   unsigned short type;
 127   struct _ffi_type **elements;
 128 } ffi_type;
 129
 130 #ifndef LIBFFI_HIDE_BASIC_TYPES
 131 #if SCHAR_MAX == 127
 132 # define ffi_type_uchar                ffi_type_uint8
 133 # define ffi_type_schar                ffi_type_sint8
 134 #else
 135  #error "char size not supported"
 136 #endif
 137
 138 #if SHRT_MAX == 32767
 139 # define ffi_type_ushort       ffi_type_uint16
 140 # define ffi_type_sshort       ffi_type_sint16
 141 #elif SHRT_MAX == 2147483647
 142 # define ffi_type_ushort       ffi_type_uint32
 143 # define ffi_type_sshort       ffi_type_sint32
 144 #else
 145  #error "short size not supported"
 146 #endif
 147
 148 #if INT_MAX == 32767
 149 # define ffi_type_uint         ffi_type_uint16
 150 # define ffi_type_sint         ffi_type_sint16
 151 #elif INT_MAX == 2147483647
 152 # define ffi_type_uint         ffi_type_uint32
 153 # define ffi_type_sint         ffi_type_sint32
 154 #elif INT_MAX == 9223372036854775807
 155 # define ffi_type_uint         ffi_type_uint64
 156 # define ffi_type_sint         ffi_type_sint64
 157 #else
 158  #error "int size not supported"
 159 #endif
 160
 161 #if LONG_MAX == 2147483647
 162 # if FFI_LONG_LONG_MAX != FFI_64_BIT_MAX
 163  #error "no 64-bit data type supported"
 164 # endif
 165 #elif LONG_MAX != FFI_64_BIT_MAX
 166  #error "long size not supported"
 167 #endif
 168
 169 #if LONG_MAX == 2147483647
 170 # define ffi_type_ulong        ffi_type_uint32
 171 # define ffi_type_slong        ffi_type_sint32
 172 #elif LONG_MAX == FFI_64_BIT_MAX
 173 # define ffi_type_ulong        ffi_type_uint64
 174 # define ffi_type_slong        ffi_type_sint64
 175 #else
 176  #error "long size not supported"
 177 #endif
 178
 179 /* Need minimal decorations for DLLs to works on Windows. */
 180 /* GCC has autoimport and autoexport.  Rely on Libtool to */
 181 /* help MSVC export from a DLL, but always declare data   */
 182 /* to be imported for MSVC clients.  This costs an extra  */
 183 /* indirection for MSVC clients using the static version  */
 184 /* of the library, but don't worry about that.  Besides,  */
 185 /* as a workaround, they can define FFI_BUILDING if they  */
 186 /* *know* they are going to link with the static library. */
 187 #if defined _MSC_VER && !defined FFI_BUILDING
 188 #define FFI_EXTERN extern __declspec(dllimport)
 189 #else
 190 #define FFI_EXTERN extern
 191 #endif
 192
 193 /* These are defined in types.c */
 194 FFI_EXTERN ffi_type ffi_type_void;
 195 FFI_EXTERN ffi_type ffi_type_uint8;
 196 FFI_EXTERN ffi_type ffi_type_sint8;
 197 FFI_EXTERN ffi_type ffi_type_uint16;
 198 FFI_EXTERN ffi_type ffi_type_sint16;
 199 FFI_EXTERN ffi_type ffi_type_uint32;
 200 FFI_EXTERN ffi_type ffi_type_sint32;
 201 FFI_EXTERN ffi_type ffi_type_uint64;
 202 FFI_EXTERN ffi_type ffi_type_sint64;
 203 FFI_EXTERN ffi_type ffi_type_float;
 204 FFI_EXTERN ffi_type ffi_type_double;
 205 FFI_EXTERN ffi_type ffi_type_pointer;
 206
 207 #if 1
 208 FFI_EXTERN ffi_type ffi_type_longdouble;
 209 #else
 210 #define ffi_type_longdouble ffi_type_double
 211 #endif
 212 #endif /* LIBFFI_HIDE_BASIC_TYPES */
 213
 214 typedef enum {
 215   FFI_OK = 0,
 216   FFI_BAD_TYPEDEF,
 217   FFI_BAD_ABI
 218 } ffi_status;
 219
 220 typedef unsigned FFI_TYPE;
 221
 222 typedef struct {
 223   ffi_abi abi;
 224   unsigned nargs;
 225   ffi_type **arg_types;
 226   ffi_type *rtype;
 227   unsigned bytes;
 228   unsigned flags;
 229 #ifdef FFI_EXTRA_CIF_FIELDS
 230   FFI_EXTRA_CIF_FIELDS;
 231 #endif
 232 } ffi_cif;
 233
 234 /* Used internally, but overridden by some architectures */
 235 ffi_status ffi_prep_cif_core(ffi_cif *cif,
 236                              ffi_abi abi,
 237                              unsigned int isvariadic,
 238                              unsigned int nfixedargs,
 239                              unsigned int ntotalargs,
 240                              ffi_type *rtype,
 241                              ffi_type **atypes);
 242
 243 /* ---- Definitions for the raw API -------------------------------------- */
 244
 245 #ifndef FFI_SIZEOF_ARG
 246 # if LONG_MAX == 2147483647
 247 #  define FFI_SIZEOF_ARG        4
 248 # elif LONG_MAX == FFI_64_BIT_MAX
 249 #  define FFI_SIZEOF_ARG        8
 250 # endif
 251 #endif
 252
 253 #ifndef FFI_SIZEOF_JAVA_RAW
 254 #  define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG
 255 #endif
 256
 257 typedef union {
 258   ffi_sarg  sint;
 259   ffi_arg   uint;
 260   float     flt;
 261   char      data[FFI_SIZEOF_ARG];
 262   void*     ptr;
 263 } ffi_raw;
 264
 265 #if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8
 266 /* This is a special case for mips64/n32 ABI (and perhaps others) where
 267    sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8.  */
 268 typedef union {
 269   signed int    sint;
 270   unsigned int  uint;
 271   float         flt;
 272   char          data[FFI_SIZEOF_JAVA_RAW];
 273   void*         ptr;
 274 } ffi_java_raw;
 275 #else
 276 typedef ffi_raw ffi_java_raw;
 277 #endif
 278
 279
 280 void ffi_raw_call (ffi_cif *cif,
 281                    void (*fn)(void),
 282                    void *rvalue,
 283                    ffi_raw *avalue);
 284
 285 void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
 286 void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
 287 size_t ffi_raw_size (ffi_cif *cif);
 288
 289 /* This is analogous to the raw API, except it uses Java parameter      */
 290 /* packing, even on 64-bit machines.  I.e. on 64-bit machines           */
 291 /* longs and doubles are followed by an empty 64-bit word.              */
 292
 293 void ffi_java_raw_call (ffi_cif *cif,
 294                         void (*fn)(void),
 295                         void *rvalue,
 296                         ffi_java_raw *avalue);
 297
 298 void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw);
 299 void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args);
 300 size_t ffi_java_raw_size (ffi_cif *cif);
 301
 302 /* ---- Definitions for closures ----------------------------------------- */
 303
 304 #if FFI_CLOSURES
 305
 306 #ifdef _MSC_VER
 307 __declspec(align(8))
 308 #endif
 309 typedef struct {
 310 #if 0
 311   void *trampoline_table;
 312   void *trampoline_table_entry;
 313 #else
 314   char tramp[FFI_TRAMPOLINE_SIZE];
 315 #endif
 316   ffi_cif   *cif;
 317   void     (*fun)(ffi_cif*,void*,void**,void*);
 318   void      *user_data;
 319 #ifdef __GNUC__
 320 } ffi_closure __attribute__((aligned (8)));
 321 #else
 322 } ffi_closure;
 323 # ifdef __sgi
 324 #  pragma pack 0
 325 # endif
 326 #endif
 327
 328 void *ffi_closure_alloc (size_t size, void **code);
 329 void ffi_closure_free (void *);
 330
 331 ffi_status
 332 ffi_prep_closure (ffi_closure*,
 333                   ffi_cif *,
 334                   void (*fun)(ffi_cif*,void*,void**,void*),
 335                   void *user_data);
 336
 337 ffi_status
 338 ffi_prep_closure_loc (ffi_closure*,
 339                       ffi_cif *,
 340                       void (*fun)(ffi_cif*,void*,void**,void*),
 341                       void *user_data,
 342                       void*codeloc);
 343
 344 #ifdef __sgi
 345 # pragma pack 8
 346 #endif
 347 typedef struct {
 348 #if 0
 349   void *trampoline_table;
 350   void *trampoline_table_entry;
 351 #else
 352   char tramp[FFI_TRAMPOLINE_SIZE];
 353 #endif
 354   ffi_cif   *cif;
 355
 356 #if !FFI_NATIVE_RAW_API
 357
 358   /* if this is enabled, then a raw closure has the same layout
 359      as a regular closure.  We use this to install an intermediate
 360      handler to do the transaltion, void** -> ffi_raw*. */
 361
 362   void     (*translate_args)(ffi_cif*,void*,void**,void*);
 363   void      *this_closure;
 364
 365 #endif
 366
 367   void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
 368   void      *user_data;
 369
 370 } ffi_raw_closure;
 371
 372 typedef struct {
 373 #if 0
 374   void *trampoline_table;
 375   void *trampoline_table_entry;
 376 #else
 377   char tramp[FFI_TRAMPOLINE_SIZE];
 378 #endif
 379
 380   ffi_cif   *cif;
 381
 382 #if !FFI_NATIVE_RAW_API
 383
 384   /* if this is enabled, then a raw closure has the same layout
 385      as a regular closure.  We use this to install an intermediate
 386      handler to do the transaltion, void** -> ffi_raw*. */
 387
 388   void     (*translate_args)(ffi_cif*,void*,void**,void*);
 389   void      *this_closure;
 390
 391 #endif
 392
 393   void     (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
 394   void      *user_data;
 395
 396 } ffi_java_raw_closure;
 397
 398 ffi_status
 399 ffi_prep_raw_closure (ffi_raw_closure*,
 400                       ffi_cif *cif,
 401                       void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 402                       void *user_data);
 403
 404 ffi_status
 405 ffi_prep_raw_closure_loc (ffi_raw_closure*,
 406                           ffi_cif *cif,
 407                           void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 408                           void *user_data,
 409                           void *codeloc);
 410
 411 ffi_status
 412 ffi_prep_java_raw_closure (ffi_java_raw_closure*,
 413                            ffi_cif *cif,
 414                            void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 415                            void *user_data);
 416
 417 ffi_status
 418 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
 419                                ffi_cif *cif,
 420                                void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 421                                void *user_data,
 422                                void *codeloc);
 423
 424 #endif /* FFI_CLOSURES */
 425
 426 /* ---- Public interface definition -------------------------------------- */
 427
 428 ffi_status ffi_prep_cif(ffi_cif *cif,
 429                         ffi_abi abi,
 430                         unsigned int nargs,
 431                         ffi_type *rtype,
 432                         ffi_type **atypes);
 433
 434 ffi_status ffi_prep_cif_var(ffi_cif *cif,
 435                             ffi_abi abi,
 436                             unsigned int nfixedargs,
 437                             unsigned int ntotalargs,
 438                             ffi_type *rtype,
 439                             ffi_type **atypes);
 440
 441 void ffi_call(ffi_cif *cif,
 442               void (*fn)(void),
 443               void *rvalue,
 444               void **avalue);
 445
 446 /* Useful for eliminating compiler warnings */
 447 #define FFI_FN(f) ((void (*)(void))f)
 448
 449 /* ---- Definitions shared with assembly code ---------------------------- */
 450
 451 #endif
 452
 453 /* If these change, update src/mips/ffitarget.h. */
 454 #define FFI_TYPE_VOID       0
 455 #define FFI_TYPE_INT        1
 456 #define FFI_TYPE_FLOAT      2
 457 #define FFI_TYPE_DOUBLE     3
 458 #if 1
 459 #define FFI_TYPE_LONGDOUBLE 4
 460 #else
 461 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
 462 #endif
 463 #define FFI_TYPE_UINT8      5
 464 #define FFI_TYPE_SINT8      6
 465 #define FFI_TYPE_UINT16     7
 466 #define FFI_TYPE_SINT16     8
 467 #define FFI_TYPE_UINT32     9
 468 #define FFI_TYPE_SINT32     10
 469 #define FFI_TYPE_UINT64     11
 470 #define FFI_TYPE_SINT64     12
 471 #define FFI_TYPE_STRUCT     13
 472 #define FFI_TYPE_POINTER    14
 473
 474 /* This should always refer to the last type code (for sanity checks) */
 475 #define FFI_TYPE_LAST       FFI_TYPE_POINTER
 476
 477 #ifdef __cplusplus
 478 }
 479 #endif
 480
 481 #endif