LCOV - app.info - objdir/js/src/ctypes/libffi/include/ffi.h

LCOV - code coverage report
| Current view: | directory - objdir/js/src/ctypes/libffi/include - ffi.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 1 | 1 | 100.0 %
| Date: | 2012-06-02 | Functions: | 1 | 1 | 100.0 %

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

Generated by: LCOV version 1.7