modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/prep_cif.c

@@ -27,16 +27,16 @@
  #include <ffi_common.h>
  #include <stdlib.h>
  
  /* Round up to FFI_SIZEOF_ARG. */
  
- #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
+ #define STACK_ARG_SIZE(x) FFI_ALIGN(x, FFI_SIZEOF_ARG)
  
  /* Perform machine independent initialization of aggregate type
     specifications. */
  
- static ffi_status initialize_aggregate(ffi_type *arg)
+ static ffi_status initialize_aggregate(ffi_type *arg, size_t *offsets)
  {
    ffi_type **ptr;
  
    if (UNLIKELY(arg == NULL || arg->elements == NULL))
      return FFI_BAD_TYPEDEF;

@@ -50,17 +50,19 @@
      return FFI_BAD_TYPEDEF;
  
    while ((*ptr) != NULL)
      {
        if (UNLIKELY(((*ptr)->size == 0)
-             && (initialize_aggregate((*ptr)) != FFI_OK)))
+             && (initialize_aggregate((*ptr), NULL) != FFI_OK)))
      return FFI_BAD_TYPEDEF;
  
        /* Perform a sanity check on the argument type */
        FFI_ASSERT_VALID_TYPE(*ptr);
  
-       arg->size = ALIGN(arg->size, (*ptr)->alignment);
+       arg->size = FFI_ALIGN(arg->size, (*ptr)->alignment);
+       if (offsets)
+     *offsets++ = arg->size;
        arg->size += (*ptr)->size;
  
        arg->alignment = (arg->alignment > (*ptr)->alignment) ?
      arg->alignment : (*ptr)->alignment;
  

@@ -72,11 +74,11 @@
       Linux ABI that right justify small structs in a register.
       It's also needed for nested structure layout, for example
       struct A { long a; char b; }; struct B { struct A x; char y; };
       should find y at an offset of 2*sizeof(long) and result in a
       total size of 3*sizeof(long).  */
-   arg->size = ALIGN (arg->size, arg->alignment);
+   arg->size = FFI_ALIGN (arg->size, arg->alignment);
  
    /* On some targets, the ABI defines that structures have an additional
       alignment beyond the "natural" one based on their elements.  */
  #ifdef FFI_AGGREGATE_ALIGNMENT
    if (FFI_AGGREGATE_ALIGNMENT > arg->alignment)

@@ -125,17 +127,20 @@
    cif->arg_types = atypes;
    cif->nargs = ntotalargs;
    cif->rtype = rtype;
  
    cif->flags = 0;
- 
+ #ifdef _M_ARM64
+   cif->is_variadic = isvariadic;
+ #endif
  #if HAVE_LONG_DOUBLE_VARIANT
    ffi_prep_types (abi);
  #endif
  
    /* Initialize the return type if necessary */
-   if ((cif->rtype->size == 0) && (initialize_aggregate(cif->rtype) != FFI_OK))
+   if ((cif->rtype->size == 0)
+       && (initialize_aggregate(cif->rtype, NULL) != FFI_OK))
      return FFI_BAD_TYPEDEF;
  
  #ifndef FFI_TARGET_HAS_COMPLEX_TYPE
    if (rtype->type == FFI_TYPE_COMPLEX)
      abort();

@@ -145,13 +150,10 @@
  
    /* x86, x86-64 and s390 stack space allocation is handled in prep_machdep. */
  #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION
    /* Make space for the return structure pointer */
    if (cif->rtype->type == FFI_TYPE_STRUCT
- #ifdef SPARC
-       && (cif->abi != FFI_V9 || cif->rtype->size > 32)
- #endif
  #ifdef TILE
        && (cif->rtype->size > 10 * FFI_SIZEOF_ARG)
  #endif
  #ifdef XTENSA
        && (cif->rtype->size > 16)

@@ -165,11 +167,12 @@
  
    for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
      {
  
        /* Initialize any uninitialized aggregate type definitions */
-       if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
+       if (((*ptr)->size == 0)
+       && (initialize_aggregate((*ptr), NULL) != FFI_OK))
      return FFI_BAD_TYPEDEF;
  
  #ifndef FFI_TARGET_HAS_COMPLEX_TYPE
        if ((*ptr)->type == FFI_TYPE_COMPLEX)
      abort();

@@ -177,22 +180,14 @@
        /* Perform a sanity check on the argument type, do this
       check after the initialization.  */
        FFI_ASSERT_VALID_TYPE(*ptr);
  
  #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION
- #ifdef SPARC
-       if (((*ptr)->type == FFI_TYPE_STRUCT
-        && ((*ptr)->size > 16 || cif->abi != FFI_V9))
-       || ((*ptr)->type == FFI_TYPE_LONGDOUBLE
-           && cif->abi != FFI_V9))
-     bytes += sizeof(void*);
-       else
- #endif
      {
        /* Add any padding if necessary */
        if (((*ptr)->alignment - 1) & bytes)
-         bytes = (unsigned)ALIGN(bytes, (*ptr)->alignment);
+         bytes = (unsigned)FFI_ALIGN(bytes, (*ptr)->alignment);
  
  #ifdef TILE
        if (bytes < 10 * FFI_SIZEOF_ARG &&
            bytes + STACK_ARG_SIZE((*ptr)->size) > 10 * FFI_SIZEOF_ARG)
          {

@@ -204,11 +199,11 @@
  #ifdef XTENSA
        if (bytes <= 6*4 && bytes + STACK_ARG_SIZE((*ptr)->size) > 6*4)
          bytes = 6*4;
  #endif
  
-       bytes += STACK_ARG_SIZE((*ptr)->size);
+       bytes += (unsigned int)STACK_ARG_SIZE((*ptr)->size);
      }
  #endif
      }
  
    cif->bytes = bytes;

@@ -249,5 +244,20 @@
  {
    return ffi_prep_closure_loc (closure, cif, fun, user_data, closure);
  }
  
  #endif
+ 
+ ffi_status
+ ffi_get_struct_offsets (ffi_abi abi, ffi_type *struct_type, size_t *offsets)
+ {
+   if (! (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI))
+     return FFI_BAD_ABI;
+   if (struct_type->type != FFI_TYPE_STRUCT)
+     return FFI_BAD_TYPEDEF;
+ 
+ #if HAVE_LONG_DOUBLE_VARIANT
+   ffi_prep_types (abi);
+ #endif
+ 
+   return initialize_aggregate(struct_type, offsets);
+ }