include/ffi.h.in

   1 /* -----------------------------------------------------------------*-C-*-
   2    libffi @VERSION@ - Copyright (c) 2011, 2014, 2019 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    Most of the API is documented in doc/libffi.texi.
  29
  30    The raw API is designed to bypass some of the argument packing and
  31    unpacking on architectures for which it can be avoided.  Routines
  32    are provided to emulate the raw API if the underlying platform
  33    doesn't allow faster implementation.
  34
  35    More details on the raw API can be found in:
  36
  37    http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
  38
  39    and
  40
  41    http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
  42    -------------------------------------------------------------------- */
  43
  44 #ifndef LIBFFI_H
  45 #define LIBFFI_H
  46
  47 #ifdef __cplusplus
  48 extern "C" {
  49 #endif
  50
  51 /* Specify which architecture libffi is configured for. */
  52 #ifndef @TARGET@
  53 #define @TARGET@
  54 #endif
  55
  56 /* ---- System configuration information --------------------------------- */
  57
  58 #include <ffitarget.h>
  59
  60 #ifndef LIBFFI_ASM
  61
  62 #if defined(_MSC_VER) && !defined(__clang__)
  63 #define __attribute__(X)
  64 #endif
  65
  66 #include <stddef.h>
  67 #include <limits.h>
  68
  69 /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
  70    But we can find it either under the correct ANSI name, or under GNU
  71    C's internal name.  */
  72
  73 #define FFI_64_BIT_MAX 9223372036854775807
  74
  75 #ifdef LONG_LONG_MAX
  76 # define FFI_LONG_LONG_MAX LONG_LONG_MAX
  77 #else
  78 # ifdef LLONG_MAX
  79 #  define FFI_LONG_LONG_MAX LLONG_MAX
  80 #  ifdef _AIX52 /* or newer has C99 LLONG_MAX */
  81 #   undef FFI_64_BIT_MAX
  82 #   define FFI_64_BIT_MAX 9223372036854775807LL
  83 #  endif /* _AIX52 or newer */
  84 # else
  85 #  ifdef __GNUC__
  86 #   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
  87 #  endif
  88 #  ifdef _AIX /* AIX 5.1 and earlier have LONGLONG_MAX */
  89 #   ifndef __PPC64__
  90 #    if defined (__IBMC__) || defined (__IBMCPP__)
  91 #     define FFI_LONG_LONG_MAX LONGLONG_MAX
  92 #    endif
  93 #   endif /* __PPC64__ */
  94 #   undef  FFI_64_BIT_MAX
  95 #   define FFI_64_BIT_MAX 9223372036854775807LL
  96 #  endif
  97 # endif
  98 #endif
  99
 100 /* The closure code assumes that this works on pointers, i.e. a size_t
 101    can hold a pointer.  */
 102
 103 typedef struct _ffi_type
 104 {
 105   size_t size;
 106   unsigned short alignment;
 107   unsigned short type;
 108   struct _ffi_type **elements;
 109 } ffi_type;
 110
 111 /* Need minimal decorations for DLLs to work on Windows.  GCC has
 112    autoimport and autoexport.  Always mark externally visible symbols
 113    as dllimport for MSVC clients, even if it means an extra indirection
 114    when using the static version of the library.
 115    Besides, as a workaround, they can define FFI_BUILDING if they
 116    *know* they are going to link with the static library.  */
 117 #if defined _MSC_VER
 118 # if defined FFI_BUILDING_DLL /* Building libffi.DLL with msvcc.sh */
 119 #  define FFI_API __declspec(dllexport)
 120 # elif !defined FFI_BUILDING  /* Importing libffi.DLL */
 121 #  define FFI_API __declspec(dllimport)
 122 # else                        /* Building/linking static library */
 123 #  define FFI_API
 124 # endif
 125 #else
 126 # define FFI_API
 127 #endif
 128
 129 /* The externally visible type declarations also need the MSVC DLL
 130    decorations, or they will not be exported from the object file.  */
 131 #if defined LIBFFI_HIDE_BASIC_TYPES
 132 # define FFI_EXTERN FFI_API
 133 #else
 134 # define FFI_EXTERN extern FFI_API
 135 #endif
 136
 137 #ifndef LIBFFI_HIDE_BASIC_TYPES
 138 #if SCHAR_MAX == 127
 139 # define ffi_type_uchar                ffi_type_uint8
 140 # define ffi_type_schar                ffi_type_sint8
 141 #else
 142  #error "char size not supported"
 143 #endif
 144
 145 #if SHRT_MAX == 32767
 146 # define ffi_type_ushort       ffi_type_uint16
 147 # define ffi_type_sshort       ffi_type_sint16
 148 #elif SHRT_MAX == 2147483647
 149 # define ffi_type_ushort       ffi_type_uint32
 150 # define ffi_type_sshort       ffi_type_sint32
 151 #else
 152  #error "short size not supported"
 153 #endif
 154
 155 #if INT_MAX == 32767
 156 # define ffi_type_uint         ffi_type_uint16
 157 # define ffi_type_sint         ffi_type_sint16
 158 #elif INT_MAX == 2147483647
 159 # define ffi_type_uint         ffi_type_uint32
 160 # define ffi_type_sint         ffi_type_sint32
 161 #elif INT_MAX == 9223372036854775807
 162 # define ffi_type_uint         ffi_type_uint64
 163 # define ffi_type_sint         ffi_type_sint64
 164 #else
 165  #error "int size not supported"
 166 #endif
 167
 168 #if LONG_MAX == 2147483647
 169 # if FFI_LONG_LONG_MAX != FFI_64_BIT_MAX
 170  #error "no 64-bit data type supported"
 171 # endif
 172 #elif LONG_MAX != FFI_64_BIT_MAX
 173  #error "long size not supported"
 174 #endif
 175
 176 #if LONG_MAX == 2147483647
 177 # define ffi_type_ulong        ffi_type_uint32
 178 # define ffi_type_slong        ffi_type_sint32
 179 #elif LONG_MAX == FFI_64_BIT_MAX
 180 # define ffi_type_ulong        ffi_type_uint64
 181 # define ffi_type_slong        ffi_type_sint64
 182 #else
 183  #error "long size not supported"
 184 #endif
 185
 186 /* These are defined in types.c.  */
 187 FFI_EXTERN ffi_type ffi_type_void;
 188 FFI_EXTERN ffi_type ffi_type_uint8;
 189 FFI_EXTERN ffi_type ffi_type_sint8;
 190 FFI_EXTERN ffi_type ffi_type_uint16;
 191 FFI_EXTERN ffi_type ffi_type_sint16;
 192 FFI_EXTERN ffi_type ffi_type_uint32;
 193 FFI_EXTERN ffi_type ffi_type_sint32;
 194 FFI_EXTERN ffi_type ffi_type_uint64;
 195 FFI_EXTERN ffi_type ffi_type_sint64;
 196 FFI_EXTERN ffi_type ffi_type_float;
 197 FFI_EXTERN ffi_type ffi_type_double;
 198 FFI_EXTERN ffi_type ffi_type_pointer;
 199
 200 #if @HAVE_LONG_DOUBLE@
 201 FFI_EXTERN ffi_type ffi_type_longdouble;
 202 #else
 203 #define ffi_type_longdouble ffi_type_double
 204 #endif
 205
 206 #ifdef FFI_TARGET_HAS_COMPLEX_TYPE
 207 FFI_EXTERN ffi_type ffi_type_complex_float;
 208 FFI_EXTERN ffi_type ffi_type_complex_double;
 209 #if @HAVE_LONG_DOUBLE@
 210 FFI_EXTERN ffi_type ffi_type_complex_longdouble;
 211 #else
 212 #define ffi_type_complex_longdouble ffi_type_complex_double
 213 #endif
 214 #endif
 215 #endif /* LIBFFI_HIDE_BASIC_TYPES */
 216
 217 typedef enum {
 218   FFI_OK = 0,
 219   FFI_BAD_TYPEDEF,
 220   FFI_BAD_ABI
 221 } ffi_status;
 222
 223 typedef struct {
 224   ffi_abi abi;
 225   unsigned nargs;
 226   ffi_type **arg_types;
 227   ffi_type *rtype;
 228   unsigned bytes;
 229   unsigned flags;
 230 #ifdef FFI_EXTRA_CIF_FIELDS
 231   FFI_EXTRA_CIF_FIELDS;
 232 #endif
 233 } ffi_cif;
 234
 235 /* ---- Definitions for the raw API -------------------------------------- */
 236
 237 #ifndef FFI_SIZEOF_ARG
 238 # if LONG_MAX == 2147483647
 239 #  define FFI_SIZEOF_ARG        4
 240 # elif LONG_MAX == FFI_64_BIT_MAX
 241 #  define FFI_SIZEOF_ARG        8
 242 # endif
 243 #endif
 244
 245 #ifndef FFI_SIZEOF_JAVA_RAW
 246 #  define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG
 247 #endif
 248
 249 typedef union {
 250   ffi_sarg  sint;
 251   ffi_arg   uint;
 252   float     flt;
 253   char      data[FFI_SIZEOF_ARG];
 254   void*     ptr;
 255 } ffi_raw;
 256
 257 #if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8
 258 /* This is a special case for mips64/n32 ABI (and perhaps others) where
 259    sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8.  */
 260 typedef union {
 261   signed int    sint;
 262   unsigned int  uint;
 263   float         flt;
 264   char          data[FFI_SIZEOF_JAVA_RAW];
 265   void*         ptr;
 266 } ffi_java_raw;
 267 #else
 268 typedef ffi_raw ffi_java_raw;
 269 #endif
 270
 271
 272 FFI_API
 273 void ffi_raw_call (ffi_cif *cif,
 274                    void (*fn)(void),
 275                    void *rvalue,
 276                    ffi_raw *avalue);
 277
 278 FFI_API void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
 279 FFI_API void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
 280 FFI_API size_t ffi_raw_size (ffi_cif *cif);
 281
 282 /* This is analogous to the raw API, except it uses Java parameter
 283    packing, even on 64-bit machines.  I.e. on 64-bit machines longs
 284    and doubles are followed by an empty 64-bit word.  */
 285
 286 #if !FFI_NATIVE_RAW_API
 287 FFI_API
 288 void ffi_java_raw_call (ffi_cif *cif,
 289                         void (*fn)(void),
 290                         void *rvalue,
 291                         ffi_java_raw *avalue) __attribute__((deprecated));
 292 #endif
 293
 294 FFI_API
 295 void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw) __attribute__((deprecated));
 296 FFI_API
 297 void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args) __attribute__((deprecated));
 298 FFI_API
 299 size_t ffi_java_raw_size (ffi_cif *cif) __attribute__((deprecated));
 300
 301 /* ---- Definitions for closures ----------------------------------------- */
 302
 303 #if FFI_CLOSURES
 304
 305 #ifdef _MSC_VER
 306 __declspec(align(8))
 307 #endif
 308 typedef struct {
 309 #if @FFI_EXEC_TRAMPOLINE_TABLE@
 310   void *trampoline_table;
 311   void *trampoline_table_entry;
 312 #else
 313   union {
 314     char tramp[FFI_TRAMPOLINE_SIZE];
 315     void *ftramp;
 316   };
 317 #endif
 318   ffi_cif   *cif;
 319   void     (*fun)(ffi_cif*,void*,void**,void*);
 320   void      *user_data;
 321 } ffi_closure
 322 #ifdef __GNUC__
 323     __attribute__((aligned (8)))
 324 #endif
 325     ;
 326
 327 #ifndef __GNUC__
 328 # ifdef __sgi
 329 #  pragma pack 0
 330 # endif
 331 #endif
 332
 333 FFI_API void *ffi_closure_alloc (size_t size, void **code);
 334 FFI_API void ffi_closure_free (void *);
 335
 336 #if defined(PA_LINUX) || defined(PA_HPUX)
 337 #define FFI_CLOSURE_PTR(X) ((void *)((unsigned int)(X) | 2))
 338 #define FFI_RESTORE_PTR(X) ((void *)((unsigned int)(X) & ~3))
 339 #else
 340 #define FFI_CLOSURE_PTR(X) (X)
 341 #define FFI_RESTORE_PTR(X) (X)
 342 #endif
 343
 344 FFI_API ffi_status
 345 ffi_prep_closure (ffi_closure*,
 346                   ffi_cif *,
 347                   void (*fun)(ffi_cif*,void*,void**,void*),
 348                   void *user_data)
 349 #if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 405)
 350   __attribute__((deprecated ("use ffi_prep_closure_loc instead")))
 351 #elif defined(__GNUC__) && __GNUC__ >= 3
 352   __attribute__((deprecated))
 353 #endif
 354   ;
 355
 356 FFI_API ffi_status
 357 ffi_prep_closure_loc (ffi_closure*,
 358                       ffi_cif *,
 359                       void (*fun)(ffi_cif*,void*,void**,void*),
 360                       void *user_data,
 361                       void*codeloc);
 362
 363 #ifdef __sgi
 364 # pragma pack 8
 365 #endif
 366 typedef struct {
 367 #if @FFI_EXEC_TRAMPOLINE_TABLE@
 368   void *trampoline_table;
 369   void *trampoline_table_entry;
 370 #else
 371   char tramp[FFI_TRAMPOLINE_SIZE];
 372 #endif
 373   ffi_cif   *cif;
 374
 375 #if !FFI_NATIVE_RAW_API
 376
 377   /* If this is enabled, then a raw closure has the same layout
 378      as a regular closure.  We use this to install an intermediate
 379      handler to do the transaltion, void** -> ffi_raw*.  */
 380
 381   void     (*translate_args)(ffi_cif*,void*,void**,void*);
 382   void      *this_closure;
 383
 384 #endif
 385
 386   void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
 387   void      *user_data;
 388
 389 } ffi_raw_closure;
 390
 391 typedef struct {
 392 #if @FFI_EXEC_TRAMPOLINE_TABLE@
 393   void *trampoline_table;
 394   void *trampoline_table_entry;
 395 #else
 396   char tramp[FFI_TRAMPOLINE_SIZE];
 397 #endif
 398
 399   ffi_cif   *cif;
 400
 401 #if !FFI_NATIVE_RAW_API
 402
 403   /* If this is enabled, then a raw closure has the same layout
 404      as a regular closure.  We use this to install an intermediate
 405      handler to do the translation, void** -> ffi_raw*.  */
 406
 407   void     (*translate_args)(ffi_cif*,void*,void**,void*);
 408   void      *this_closure;
 409
 410 #endif
 411
 412   void     (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
 413   void      *user_data;
 414
 415 } ffi_java_raw_closure;
 416
 417 FFI_API ffi_status
 418 ffi_prep_raw_closure (ffi_raw_closure*,
 419                       ffi_cif *cif,
 420                       void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 421                       void *user_data);
 422
 423 FFI_API ffi_status
 424 ffi_prep_raw_closure_loc (ffi_raw_closure*,
 425                           ffi_cif *cif,
 426                           void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
 427                           void *user_data,
 428                           void *codeloc);
 429
 430 #if !FFI_NATIVE_RAW_API
 431 FFI_API ffi_status
 432 ffi_prep_java_raw_closure (ffi_java_raw_closure*,
 433                            ffi_cif *cif,
 434                            void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 435                            void *user_data) __attribute__((deprecated));
 436
 437 FFI_API ffi_status
 438 ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
 439                                ffi_cif *cif,
 440                                void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
 441                                void *user_data,
 442                                void *codeloc) __attribute__((deprecated));
 443 #endif
 444
 445 #endif /* FFI_CLOSURES */
 446
 447 #if FFI_GO_CLOSURES
 448
 449 typedef struct {
 450   void      *tramp;
 451   ffi_cif   *cif;
 452   void     (*fun)(ffi_cif*,void*,void**,void*);
 453 } ffi_go_closure;
 454
 455 FFI_API ffi_status ffi_prep_go_closure (ffi_go_closure*, ffi_cif *,
 456                                 void (*fun)(ffi_cif*,void*,void**,void*));
 457
 458 FFI_API void ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
 459                   void **avalue, void *closure);
 460
 461 #endif /* FFI_GO_CLOSURES */
 462
 463 /* ---- Public interface definition -------------------------------------- */
 464
 465 FFI_API
 466 ffi_status ffi_prep_cif(ffi_cif *cif,
 467                         ffi_abi abi,
 468                         unsigned int nargs,
 469                         ffi_type *rtype,
 470                         ffi_type **atypes);
 471
 472 FFI_API
 473 ffi_status ffi_prep_cif_var(ffi_cif *cif,
 474                             ffi_abi abi,
 475                             unsigned int nfixedargs,
 476                             unsigned int ntotalargs,
 477                             ffi_type *rtype,
 478                             ffi_type **atypes);
 479
 480 FFI_API
 481 void ffi_call(ffi_cif *cif,
 482               void (*fn)(void),
 483               void *rvalue,
 484               void **avalue);
 485
 486 FFI_API
 487 ffi_status ffi_get_struct_offsets (ffi_abi abi, ffi_type *struct_type,
 488                                    size_t *offsets);
 489
 490 /* Useful for eliminating compiler warnings.  */
 491 #define FFI_FN(f) ((void (*)(void))f)
 492
 493 /* ---- Definitions shared with assembly code ---------------------------- */
 494
 495 #endif
 496
 497 /* If these change, update src/mips/ffitarget.h. */
 498 #define FFI_TYPE_VOID       0
 499 #define FFI_TYPE_INT        1
 500 #define FFI_TYPE_FLOAT      2
 501 #define FFI_TYPE_DOUBLE     3
 502 #if @HAVE_LONG_DOUBLE@
 503 #define FFI_TYPE_LONGDOUBLE 4
 504 #else
 505 #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
 506 #endif
 507 #define FFI_TYPE_UINT8      5
 508 #define FFI_TYPE_SINT8      6
 509 #define FFI_TYPE_UINT16     7
 510 #define FFI_TYPE_SINT16     8
 511 #define FFI_TYPE_UINT32     9
 512 #define FFI_TYPE_SINT32     10
 513 #define FFI_TYPE_UINT64     11
 514 #define FFI_TYPE_SINT64     12
 515 #define FFI_TYPE_STRUCT     13
 516 #define FFI_TYPE_POINTER    14
 517 #define FFI_TYPE_COMPLEX    15
 518
 519 /* This should always refer to the last type code (for sanity checks).  */
 520 #define FFI_TYPE_LAST       FFI_TYPE_COMPLEX
 521
 522 #ifdef __cplusplus
 523 }
 524 #endif
 525
 526 #endif