cybrid_api_id_ruby 0.117.26 → 0.117.28

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/java_raw_api.c

@@ -1,374 +0,0 @@
-/* -----------------------------------------------------------------------
-   java_raw_api.c - Copyright (c) 1999, 2007, 2008  Red Hat, Inc.
-
-   Cloned from raw_api.c
-
-   Raw_api.c author: Kresten Krab Thorup <krab@gnu.org>
-   Java_raw_api.c author: Hans-J. Boehm <hboehm@hpl.hp.com>
-
-   $Id $
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of this software and associated documentation files (the
-   ``Software''), to deal in the Software without restriction, including
-   without limitation the rights to use, copy, modify, merge, publish,
-   distribute, sublicense, and/or sell copies of the Software, and to
-   permit persons to whom the Software is furnished to do so, subject to
-   the following conditions:
-
-   The above copyright notice and this permission notice shall be included
-   in all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-   ----------------------------------------------------------------------- */
-
-/* This defines a Java- and 64-bit specific variant of the raw API.	*/
-/* It assumes that "raw" argument blocks look like Java stacks on a	*/
-/* 64-bit machine.  Arguments that can be stored in a single stack	*/
-/* stack slots (longs, doubles) occupy 128 bits, but only the first	*/
-/* 64 bits are actually used.						*/
-
-#include <ffi.h>
-#include <ffi_common.h>
-#include <stdlib.h>
-
-#if !defined(NO_JAVA_RAW_API)
-
-size_t
-ffi_java_raw_size (ffi_cif *cif)
-{
-  size_t result = 0;
-  int i;
-
-  ffi_type **at = cif->arg_types;
-
-  for (i = cif->nargs-1; i >= 0; i--, at++)
-    {
-      switch((*at) -> type) {
-	case FFI_TYPE_UINT64:
-	case FFI_TYPE_SINT64:
-	case FFI_TYPE_DOUBLE:
-	  result += 2 * FFI_SIZEOF_JAVA_RAW;
-	  break;
-	case FFI_TYPE_STRUCT:
-	  /* No structure parameters in Java.	*/
-	  abort();
-	case FFI_TYPE_COMPLEX:
-	  /* Not supported yet.  */
-	  abort();
-	default:
-	  result += FFI_SIZEOF_JAVA_RAW;
-      }
-    }
-
-  return result;
-}
-
-
-void
-ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args)
-{
-  unsigned i;
-  ffi_type **tp = cif->arg_types;
-
-#if WORDS_BIGENDIAN
-
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {
-      switch ((*tp)->type)
-	{
-	case FFI_TYPE_UINT8:
-	case FFI_TYPE_SINT8:
-	  *args = (void*) ((char*)(raw++) + 3);
-	  break;
-
-	case FFI_TYPE_UINT16:
-	case FFI_TYPE_SINT16:
-	  *args = (void*) ((char*)(raw++) + 2);
-	  break;
-
-#if FFI_SIZEOF_JAVA_RAW == 8
-	case FFI_TYPE_UINT64:
-	case FFI_TYPE_SINT64:
-	case FFI_TYPE_DOUBLE:
-	  *args = (void *)raw;
-	  raw += 2;
-	  break;
-#endif
-
-	case FFI_TYPE_POINTER:
-	  *args = (void*) &(raw++)->ptr;
-	  break;
-
-	case FFI_TYPE_COMPLEX:
-	  /* Not supported yet.  */
-	  abort();
-
-	default:
-	  *args = raw;
-	  raw +=
-	    FFI_ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
-	}
-    }
-
-#else /* WORDS_BIGENDIAN */
-
-#if !PDP
-
-  /* then assume little endian */
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {
-#if FFI_SIZEOF_JAVA_RAW == 8
-      switch((*tp)->type) {
-	case FFI_TYPE_UINT64:
-	case FFI_TYPE_SINT64:
-	case FFI_TYPE_DOUBLE:
-	  *args = (void*) raw;
-	  raw += 2;
-	  break;
-	case FFI_TYPE_COMPLEX:
-	  /* Not supported yet.  */
-	  abort();
-	default:
-	  *args = (void*) raw++;
-      }
-#else /* FFI_SIZEOF_JAVA_RAW != 8 */
-	*args = (void*) raw;
-	raw +=
-	  FFI_ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
-#endif /* FFI_SIZEOF_JAVA_RAW == 8 */
-    }
-
-#else
-#error "pdp endian not supported"
-#endif /* ! PDP */
-
-#endif /* WORDS_BIGENDIAN */
-}
-
-void
-ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw)
-{
-  unsigned i;
-  ffi_type **tp = cif->arg_types;
-
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {
-      switch ((*tp)->type)
-	{
-	case FFI_TYPE_UINT8:
-#if WORDS_BIGENDIAN
-	  *(UINT32*)(raw++) = *(UINT8*) (*args);
-#else
-	  (raw++)->uint = *(UINT8*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_SINT8:
-#if WORDS_BIGENDIAN
-	  *(SINT32*)(raw++) = *(SINT8*) (*args);
-#else
-	  (raw++)->sint = *(SINT8*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_UINT16:
-#if WORDS_BIGENDIAN
-	  *(UINT32*)(raw++) = *(UINT16*) (*args);
-#else
-	  (raw++)->uint = *(UINT16*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_SINT16:
-#if WORDS_BIGENDIAN
-	  *(SINT32*)(raw++) = *(SINT16*) (*args);
-#else
-	  (raw++)->sint = *(SINT16*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_UINT32:
-#if WORDS_BIGENDIAN
-	  *(UINT32*)(raw++) = *(UINT32*) (*args);
-#else
-	  (raw++)->uint = *(UINT32*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_SINT32:
-#if WORDS_BIGENDIAN
-	  *(SINT32*)(raw++) = *(SINT32*) (*args);
-#else
-	  (raw++)->sint = *(SINT32*) (*args);
-#endif
-	  break;
-
-	case FFI_TYPE_FLOAT:
-	  (raw++)->flt = *(FLOAT32*) (*args);
-	  break;
-
-#if FFI_SIZEOF_JAVA_RAW == 8
-	case FFI_TYPE_UINT64:
-	case FFI_TYPE_SINT64:
-	case FFI_TYPE_DOUBLE:
-	  raw->uint = *(UINT64*) (*args);
-	  raw += 2;
-	  break;
-#endif
-
-	case FFI_TYPE_POINTER:
-	  (raw++)->ptr = **(void***) args;
-	  break;
-
-	default:
-#if FFI_SIZEOF_JAVA_RAW == 8
-	  FFI_ASSERT(0);	/* Should have covered all cases */
-#else
-	  memcpy ((void*) raw->data, (void*)*args, (*tp)->size);
-	  raw +=
-	    FFI_ALIGN ((*tp)->size, sizeof(ffi_java_raw)) / sizeof(ffi_java_raw);
-#endif
-	}
-    }
-}
-
-#if !FFI_NATIVE_RAW_API
-
-static void
-ffi_java_rvalue_to_raw (ffi_cif *cif, void *rvalue)
-{
-#if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
-  switch (cif->rtype->type)
-    {
-    case FFI_TYPE_UINT8:
-    case FFI_TYPE_UINT16:
-    case FFI_TYPE_UINT32:
-      *(UINT64 *)rvalue <<= 32;
-      break;
-
-    case FFI_TYPE_SINT8:
-    case FFI_TYPE_SINT16:
-    case FFI_TYPE_SINT32:
-    case FFI_TYPE_INT:
-#if FFI_SIZEOF_JAVA_RAW == 4
-    case FFI_TYPE_POINTER:
-#endif
-      *(SINT64 *)rvalue <<= 32;
-      break;
-
-    case FFI_TYPE_COMPLEX:
-      /* Not supported yet.  */
-      abort();
-
-    default:
-      break;
-    }
-#endif
-}
-
-static void
-ffi_java_raw_to_rvalue (ffi_cif *cif, void *rvalue)
-{
-#if WORDS_BIGENDIAN && FFI_SIZEOF_ARG == 8
-  switch (cif->rtype->type)
-    {
-    case FFI_TYPE_UINT8:
-    case FFI_TYPE_UINT16:
-    case FFI_TYPE_UINT32:
-      *(UINT64 *)rvalue >>= 32;
-      break;
-
-    case FFI_TYPE_SINT8:
-    case FFI_TYPE_SINT16:
-    case FFI_TYPE_SINT32:
-    case FFI_TYPE_INT:
-      *(SINT64 *)rvalue >>= 32;
-      break;
-
-    case FFI_TYPE_COMPLEX:
-      /* Not supported yet.  */
-      abort();
-
-    default:
-      break;
-    }
-#endif
-}
-
-/* This is a generic definition of ffi_raw_call, to be used if the
- * native system does not provide a machine-specific implementation.
- * Having this, allows code to be written for the raw API, without
- * the need for system-specific code to handle input in that format;
- * these following couple of functions will handle the translation forth
- * and back automatically. */
-
-void ffi_java_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue,
-			ffi_java_raw *raw)
-{
-  void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
-  ffi_java_raw_to_ptrarray (cif, raw, avalue);
-  ffi_call (cif, fn, rvalue, avalue);
-  ffi_java_rvalue_to_raw (cif, rvalue);
-}
-
-#if FFI_CLOSURES		/* base system provides closures */
-
-static void
-ffi_java_translate_args (ffi_cif *cif, void *rvalue,
-		    void **avalue, void *user_data)
-{
-  ffi_java_raw *raw = (ffi_java_raw*)alloca (ffi_java_raw_size (cif));
-  ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
-
-  ffi_java_ptrarray_to_raw (cif, avalue, raw);
-  (*cl->fun) (cif, rvalue, (ffi_raw*)raw, cl->user_data);
-  ffi_java_raw_to_rvalue (cif, rvalue);
-}
-
-ffi_status
-ffi_prep_java_raw_closure_loc (ffi_java_raw_closure* cl,
-			       ffi_cif *cif,
-			       void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
-			       void *user_data,
-			       void *codeloc)
-{
-  ffi_status status;
-
-  status = ffi_prep_closure_loc ((ffi_closure*) cl,
-				 cif,
-				 &ffi_java_translate_args,
-				 codeloc,
-				 codeloc);
-  if (status == FFI_OK)
-    {
-      cl->fun       = fun;
-      cl->user_data = user_data;
-    }
-
-  return status;
-}
-
-/* Again, here is the generic version of ffi_prep_raw_closure, which
- * will install an intermediate "hub" for translation of arguments from
- * the pointer-array format, to the raw format */
-
-ffi_status
-ffi_prep_java_raw_closure (ffi_java_raw_closure* cl,
-			   ffi_cif *cif,
-			   void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
-			   void *user_data)
-{
-  return ffi_prep_java_raw_closure_loc (cl, cif, fun, user_data, cl);
-}
-
-#endif /* FFI_CLOSURES */
-#endif /* !FFI_NATIVE_RAW_API */
-#endif /* !NO_JAVA_RAW_API */

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/kvx/asm.h

@@ -1,5 +0,0 @@
-/* args are passed on registers from r0 up to r11 => 12*8 bytes */
-#define REG_ARGS_SIZE (12*8)
-#define KVX_REGISTER_SIZE (8)
-#define KVX_ABI_SLOT_SIZE (KVX_REGISTER_SIZE)
-#define KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE (4*KVX_ABI_SLOT_SIZE)

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/kvx/ffi.c

@@ -1,273 +0,0 @@
-/* Copyright (c) 2020 Kalray
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-``Software''), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
-
-#if defined(__kvx__)
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <fficonfig.h>
-#include <ffi.h>
-#include "ffi_common.h"
-#include "asm.h"
-
-#define ALIGN(x, a) ALIGN_MASK(x, (typeof(x))(a) - 1)
-#define ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
-#define KVX_ABI_STACK_ALIGNMENT (32)
-#define KVX_ABI_STACK_ARG_ALIGNMENT (8)
-#define max(a,b) ((a) > (b) ? (a) : (b))
-
-#ifdef FFI_DEBUG
-#define DEBUG_PRINT(...) do{ fprintf( stderr, __VA_ARGS__ ); } while(0)
-#else
-#define DEBUG_PRINT(...)
-#endif
-
-struct ret_value {
-	unsigned long int r0;
-	unsigned long int r1;
-	unsigned long int r2;
-	unsigned long int r3;
-};
-
-extern struct ret_value ffi_call_SYSV(unsigned total_size,
-                                      unsigned size,
-                                      extended_cif *ecif,
-                                      unsigned *rvalue_addr,
-                                      void *fn,
-                                      unsigned int_ext_method);
-
-/* Perform machine dependent cif processing */
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  cif->flags = cif->rtype->size;
-  return FFI_OK;
-}
-
-/* ffi_prep_args is called by the assembly routine once stack space
-   has been allocated for the function's arguments */
-
-void *ffi_prep_args(char *stack, unsigned int arg_slots_size, extended_cif *ecif)
-{
-  char *stacktemp = stack;
-  char *current_arg_passed_by_value = stack + arg_slots_size;
-  int i, s;
-  ffi_type **arg;
-  int count = 0;
-  ffi_cif *cif = ecif->cif;
-  void **argv = ecif->avalue;
-
-  arg = cif->arg_types;
-
-  DEBUG_PRINT("stack: %p\n", stack);
-  DEBUG_PRINT("arg_slots_size: %u\n", arg_slots_size);
-  DEBUG_PRINT("current_arg_passed_by_value: %p\n", current_arg_passed_by_value);
-  DEBUG_PRINT("ecif: %p\n", ecif);
-  DEBUG_PRINT("ecif->avalue: %p\n", ecif->avalue);
-
-  for (i = 0; i < cif->nargs; i++) {
-
-    s = KVX_ABI_SLOT_SIZE;
-    switch((*arg)->type) {
-      case FFI_TYPE_SINT8:
-      case FFI_TYPE_UINT8:
-      case FFI_TYPE_SINT16:
-      case FFI_TYPE_UINT16:
-      case FFI_TYPE_SINT32:
-      case FFI_TYPE_UINT32:
-      case FFI_TYPE_FLOAT:
-      case FFI_TYPE_DOUBLE:
-      case FFI_TYPE_UINT64:
-      case FFI_TYPE_SINT64:
-      case FFI_TYPE_POINTER:
-        DEBUG_PRINT("INT64/32/16/8/FLOAT/DOUBLE or POINTER @%p\n", stack);
-        *(uint64_t *) stack = *(uint64_t *)(* argv);
-        break;
-
-      case FFI_TYPE_COMPLEX:
-        if ((*arg)->size == 8)
-          *(_Complex float *) stack = *(_Complex float *)(* argv);
-        else if ((*arg)->size == 16) {
-          *(_Complex double *) stack = *(_Complex double *)(* argv);
-          s = 16;
-        } else
-          abort();
-        break;
-      case FFI_TYPE_STRUCT: {
-        char *value;
-        unsigned int written_size = 0;
-        DEBUG_PRINT("struct by value @%p\n", stack);
-        if ((*arg)->size > KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE) {
-          DEBUG_PRINT("big struct\n");
-          *(uint64_t *) stack = (uintptr_t)current_arg_passed_by_value;
-          value = current_arg_passed_by_value;
-          current_arg_passed_by_value += (*arg)->size;
-          written_size = KVX_ABI_SLOT_SIZE;
-        } else {
-          value = stack;
-          written_size = (*arg)->size;
-        }
-        memcpy(value, *argv, (*arg)->size);
-        s = ALIGN(written_size, KVX_ABI_STACK_ARG_ALIGNMENT);
-        break;
-      }
-      default:
-        printf("Error: unsupported arg type %d\n", (*arg)->type);
-        abort();
-        break;
-
-    }
-    stack += s;
-    count += s;
-    argv++;
-    arg++;
-  }
-#ifdef FFI_DEBUG
-  FFI_ASSERT(((intptr_t)(stacktemp + REG_ARGS_SIZE) & (KVX_ABI_STACK_ALIGNMENT-1)) == 0);
-#endif
-  return stacktemp + REG_ARGS_SIZE;
-}
-
-/* Perform machine dependent cif processing when we have a variadic function */
-
-ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned int nfixedargs,
-                                    unsigned int ntotalargs)
-{
-  cif->flags = cif->rtype->size;
-  return FFI_OK;
-}
-
-static unsigned long handle_small_int_ext(kvx_intext_method *int_ext_method,
-                                          const ffi_type *rtype)
-{
-  switch (rtype->type) {
-    case FFI_TYPE_SINT8:
-      *int_ext_method = KVX_RET_SXBD;
-      return KVX_REGISTER_SIZE;
-
-    case FFI_TYPE_SINT16:
-      *int_ext_method = KVX_RET_SXHD;
-      return KVX_REGISTER_SIZE;
-
-    case FFI_TYPE_SINT32:
-      *int_ext_method = KVX_RET_SXWD;
-      return KVX_REGISTER_SIZE;
-
-    case FFI_TYPE_UINT8:
-      *int_ext_method = KVX_RET_ZXBD;
-      return KVX_REGISTER_SIZE;
-
-    case FFI_TYPE_UINT16:
-      *int_ext_method = KVX_RET_ZXHD;
-      return KVX_REGISTER_SIZE;
-
-    case FFI_TYPE_UINT32:
-      *int_ext_method = KVX_RET_ZXWD;
-      return KVX_REGISTER_SIZE;
-
-    default:
-      *int_ext_method = KVX_RET_NONE;
-      return rtype->size;
-  }
-}
-
-void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
-{
-  int i;
-  unsigned long int slot_fitting_args_size = 0;
-  unsigned long int total_size = 0;
-  unsigned long int big_struct_size = 0;
-  kvx_intext_method int_extension_method;
-  ffi_type **arg;
-  struct ret_value local_rvalue = {0};
-  size_t wb_size;
-
-
-  /* Calculate size to allocate on stack */
-  for (i = 0, arg = cif->arg_types; i < cif->nargs; i++, arg++) {
-    DEBUG_PRINT("argument %d, type %d, size %lu\n", i, (*arg)->type, (*arg)->size);
-    if (((*arg)->type == FFI_TYPE_STRUCT) || ((*arg)->type == FFI_TYPE_COMPLEX)) {
-      if ((*arg)->size <= KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE) {
-        slot_fitting_args_size += ALIGN((*arg)->size, KVX_ABI_SLOT_SIZE);
-      } else {
-        slot_fitting_args_size += KVX_ABI_SLOT_SIZE; /* aggregate passed by reference */
-        big_struct_size += ALIGN((*arg)->size, KVX_ABI_SLOT_SIZE);
-      }
-    } else if ((*arg)->size <= KVX_ABI_SLOT_SIZE) {
-      slot_fitting_args_size += KVX_ABI_SLOT_SIZE;
-    } else {
-      printf("Error: unsupported arg size %ld arg type %d\n", (*arg)->size, (*arg)->type);
-      abort(); /* should never happen? */
-    }
-  }
-
-  extended_cif ecif;
-  ecif.cif = cif;
-  ecif.avalue = avalue;
-  ecif.rvalue = rvalue;
-
-  /* This implementation allocates anyway for all register based args */
-  slot_fitting_args_size = max(slot_fitting_args_size, REG_ARGS_SIZE);
-  total_size = slot_fitting_args_size + big_struct_size;
-  total_size = ALIGN(total_size, KVX_ABI_STACK_ALIGNMENT);
-
-  /* wb_size: write back size, the size we will need to write back to user
-   * provided buffer. In theory it should always be cif->flags which is
-   * cif->rtype->size. But libffi API mandates that for integral types
-   * of size <= system register size, then we *MUST* write back
-   * the size of system register size.
-   * in our case, if size <= 8 bytes we must write back 8 bytes.
-   * floats, complex and structs are not affected, only integrals.
-   */
-  wb_size = handle_small_int_ext(&int_extension_method, cif->rtype);
-
-  switch (cif->abi) {
-    case FFI_SYSV:
-      DEBUG_PRINT("total_size: %lu\n", total_size);
-      DEBUG_PRINT("slot fitting args size: %lu\n", slot_fitting_args_size);
-      DEBUG_PRINT("rvalue: %p\n", rvalue);
-      DEBUG_PRINT("fn: %p\n", fn);
-      DEBUG_PRINT("rsize: %u\n", cif->flags);
-      DEBUG_PRINT("wb_size: %u\n", wb_size);
-      DEBUG_PRINT("int_extension_method: %u\n", int_extension_method);
-      local_rvalue = ffi_call_SYSV(total_size, slot_fitting_args_size,
-                                   &ecif, rvalue, fn, int_extension_method);
-      if ((cif->flags <= KVX_ABI_MAX_AGGREGATE_IN_REG_SIZE)
-          && (cif->rtype->type != FFI_TYPE_VOID))
-        memcpy(rvalue, &local_rvalue, wb_size);
-      break;
-    default:
-      abort();
-      break;
-  }
-}
-
-/* Closures not supported yet */
-ffi_status
-ffi_prep_closure_loc (ffi_closure* closure,
-                      ffi_cif* cif,
-                      void (*fun)(ffi_cif*,void*,void**,void*),
-                      void *user_data,
-                      void *codeloc)
-{
-  return FFI_BAD_ABI;
-}
-
-#endif /* (__kvx__) */