LCOV - app.info - js/src/ctypes/libffi/src/prep_cif.c

LCOV - code coverage report
| Current view: | directory - js/src/ctypes/libffi/src - prep_cif.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 39 | 0 | 0.0 %
| Date: | 2012-04-07 | Functions: | 3 | 0 | 0.0 %

           1                 : /* -----------------------------------------------------------------------
           2                 :    prep_cif.c - Copyright (c) 1996, 1998, 2007  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                 : #include <ffi.h>
          26                 : #include <ffi_common.h>
          27                 : #include <stdlib.h>
          28                 :
          29                 : /* Round up to FFI_SIZEOF_ARG. */
          30                 :
          31                 : #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
          32                 :
          33                 : /* Perform machine independent initialization of aggregate type
          34                 :    specifications. */
          35                 :
          36               0 : static ffi_status initialize_aggregate(ffi_type *arg)
          37                 : {
          38                 :   ffi_type **ptr;
          39                 :
          40               0 :   FFI_ASSERT(arg != NULL);
          41                 :
          42               0 :   FFI_ASSERT(arg->elements != NULL);
          43               0 :   FFI_ASSERT(arg->size == 0);
          44               0 :   FFI_ASSERT(arg->alignment == 0);
          45                 :
          46               0 :   ptr = &(arg->elements[0]);
          47                 :
          48               0 :   while ((*ptr) != NULL)
          49                 :     {
          50               0 :       if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
          51               0 :         return FFI_BAD_TYPEDEF;
          52                 :
          53                 :       /* Perform a sanity check on the argument type */
          54               0 :       FFI_ASSERT_VALID_TYPE(*ptr);
          55                 :
          56               0 :       arg->size = ALIGN(arg->size, (*ptr)->alignment);
          57               0 :       arg->size += (*ptr)->size;
          58                 :
          59               0 :       arg->alignment = (arg->alignment > (*ptr)->alignment) ?
          60               0 :         arg->alignment : (*ptr)->alignment;
          61                 :
          62               0 :       ptr++;
          63                 :     }
          64                 :
          65                 :   /* Structure size includes tail padding.  This is important for
          66                 :      structures that fit in one register on ABIs like the PowerPC64
          67                 :      Linux ABI that right justify small structs in a register.
          68                 :      It's also needed for nested structure layout, for example
          69                 :      struct A { long a; char b; }; struct B { struct A x; char y; };
          70                 :      should find y at an offset of 2*sizeof(long) and result in a
          71                 :      total size of 3*sizeof(long).  */
          72               0 :   arg->size = ALIGN (arg->size, arg->alignment);
          73                 :
          74               0 :   if (arg->size == 0)
          75               0 :     return FFI_BAD_TYPEDEF;
          76                 :   else
          77               0 :     return FFI_OK;
          78                 : }
          79                 :
          80                 : #ifndef __CRIS__
          81                 : /* The CRIS ABI specifies structure elements to have byte
          82                 :    alignment only, so it completely overrides this functions,
          83                 :    which assumes "natural" alignment and padding.  */
          84                 :
          85                 : /* Perform machine independent ffi_cif preparation, then call
          86                 :    machine dependent routine. */
          87                 :
          88               0 : ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, unsigned int nargs,
          89                 :                         ffi_type *rtype, ffi_type **atypes)
          90                 : {
          91               0 :   unsigned bytes = 0;
          92                 :   unsigned int i;
          93                 :   ffi_type **ptr;
          94                 :
          95               0 :   FFI_ASSERT(cif != NULL);
          96               0 :   FFI_ASSERT(abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI);
          97                 :
          98               0 :   cif->abi = abi;
          99               0 :   cif->arg_types = atypes;
         100               0 :   cif->nargs = nargs;
         101               0 :   cif->rtype = rtype;
         102                 :
         103               0 :   cif->flags = 0;
         104                 :
         105                 :   /* Initialize the return type if necessary */
         106               0 :   if ((cif->rtype->size == 0) && (initialize_aggregate(cif->rtype) != FFI_OK))
         107               0 :     return FFI_BAD_TYPEDEF;
         108                 :
         109                 :   /* Perform a sanity check on the return type */
         110               0 :   FFI_ASSERT_VALID_TYPE(cif->rtype);
         111                 :
         112                 :   /* x86, x86-64 and s390 stack space allocation is handled in prep_machdep. */
         113                 : #if !defined M68K && !defined X86_ANY && !defined S390 && !defined PA
         114                 :   /* Make space for the return structure pointer */
         115                 :   if (cif->rtype->type == FFI_TYPE_STRUCT
         116                 : #ifdef SPARC
         117                 :       && (cif->abi != FFI_V9 || cif->rtype->size > 32)
         118                 : #endif
         119                 :      )
         120                 :     bytes = STACK_ARG_SIZE(sizeof(void*));
         121                 : #endif
         122                 :
         123               0 :   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
         124                 :     {
         125                 :
         126                 :       /* Initialize any uninitialized aggregate type definitions */
         127               0 :       if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
         128               0 :         return FFI_BAD_TYPEDEF;
         129                 :
         130                 :       /* Perform a sanity check on the argument type, do this
         131                 :          check after the initialization.  */
         132               0 :       FFI_ASSERT_VALID_TYPE(*ptr);
         133                 :
         134                 : #if !defined X86_ANY && !defined S390 && !defined PA
         135                 : #ifdef SPARC
         136                 :       if (((*ptr)->type == FFI_TYPE_STRUCT
         137                 :            && ((*ptr)->size > 16 || cif->abi != FFI_V9))
         138                 :           || ((*ptr)->type == FFI_TYPE_LONGDOUBLE
         139                 :               && cif->abi != FFI_V9))
         140                 :         bytes += sizeof(void*);
         141                 :       else
         142                 : #endif
         143                 :         {
         144                 :           /* Add any padding if necessary */
         145                 :           if (((*ptr)->alignment - 1) & bytes)
         146                 :             bytes = ALIGN(bytes, (*ptr)->alignment);
         147                 :
         148                 :           bytes += STACK_ARG_SIZE((*ptr)->size);
         149                 :         }
         150                 : #endif
         151                 :     }
         152                 :
         153               0 :   cif->bytes = bytes;
         154                 :
         155                 :   /* Perform machine dependent cif processing */
         156               0 :   return ffi_prep_cif_machdep(cif);
         157                 : }
         158                 : #endif /* not __CRIS__ */
         159                 :
         160                 : #if FFI_CLOSURES
         161                 :
         162                 : ffi_status
         163               0 : ffi_prep_closure (ffi_closure* closure,
         164                 :                   ffi_cif* cif,
         165                 :                   void (*fun)(ffi_cif*,void*,void**,void*),
         166                 :                   void *user_data)
         167                 : {
         168               0 :   return ffi_prep_closure_loc (closure, cif, fun, user_data, closure);
         169                 : }
         170                 :
         171                 : #endif

Generated by: LCOV version 1.7