Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

1 files changed, 854 insertions, 854 deletions

diff --git a/contrib/restricted/libffi/src/arm/ffi.c b/contrib/restricted/libffi/src/arm/ffi.c
index 4e270718a3..95cebf49ee 100644
--- a/contrib/restricted/libffi/src/arm/ffi.c
+++ b/contrib/restricted/libffi/src/arm/ffi.c
@@ -1,854 +1,854 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2011 Timothy Wall
-           Copyright (c) 2011 Plausible Labs Cooperative, Inc.
-           Copyright (c) 2011 Anthony Green
-	   Copyright (c) 2011 Free Software Foundation
-           Copyright (c) 1998, 2008, 2011  Red Hat, Inc.
-
-   ARM Foreign Function Interface
-
-   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(__arm__) || defined(_M_ARM)
-#include <fficonfig.h>
-#include <ffi.h>
-#include <ffi_common.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include "internal.h"
-
-#if defined(_MSC_VER) && defined(_M_ARM)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-
-#if FFI_EXEC_TRAMPOLINE_TABLE
-
-#ifdef __MACH__
-#include <mach/machine/vm_param.h>
-#endif
-
-#else
-#ifndef _M_ARM
-extern unsigned int ffi_arm_trampoline[2] FFI_HIDDEN;
-#else
-extern unsigned int ffi_arm_trampoline[3] FFI_HIDDEN;
-#endif
-#endif
-
-/* Forward declares. */
-static int vfp_type_p (const ffi_type *);
-static void layout_vfp_args (ffi_cif *);
-
-static void *
-ffi_align (ffi_type *ty, void *p)
-{
-  /* Align if necessary */
-  size_t alignment;
-#ifdef _WIN32_WCE
-  alignment = 4;
-#else
-  alignment = ty->alignment;
-  if (alignment < 4)
-    alignment = 4;
-#endif
-  return (void *) FFI_ALIGN (p, alignment);
-}
-
-static size_t
-ffi_put_arg (ffi_type *ty, void *src, void *dst)
-{
-  size_t z = ty->size;
-
-  switch (ty->type)
-    {
-    case FFI_TYPE_SINT8:
-      *(UINT32 *)dst = *(SINT8 *)src;
-      break;
-    case FFI_TYPE_UINT8:
-      *(UINT32 *)dst = *(UINT8 *)src;
-      break;
-    case FFI_TYPE_SINT16:
-      *(UINT32 *)dst = *(SINT16 *)src;
-      break;
-    case FFI_TYPE_UINT16:
-      *(UINT32 *)dst = *(UINT16 *)src;
-      break;
-
-    case FFI_TYPE_INT:
-    case FFI_TYPE_SINT32:
-    case FFI_TYPE_UINT32:
-    case FFI_TYPE_POINTER:
-#ifndef _MSC_VER
-    case FFI_TYPE_FLOAT:
-#endif
-      *(UINT32 *)dst = *(UINT32 *)src;
-      break;
-
-#ifdef _MSC_VER
-    // casting a float* to a UINT32* doesn't work on Windows
-    case FFI_TYPE_FLOAT:
-        *(uintptr_t *)dst = 0;
-        *(float *)dst = *(float *)src;
-        break;
-#endif
-
-    case FFI_TYPE_SINT64:
-    case FFI_TYPE_UINT64:
-    case FFI_TYPE_DOUBLE:
-      *(UINT64 *)dst = *(UINT64 *)src;
-      break;
-
-    case FFI_TYPE_STRUCT:
-    case FFI_TYPE_COMPLEX:
-      memcpy (dst, src, z);
-      break;
-
-    default:
-      abort();
-    }
-
-  return FFI_ALIGN (z, 4);
-}
-
-/* ffi_prep_args is called once stack space has been allocated
-   for the function's arguments.
-
-   The vfp_space parameter is the load area for VFP regs, the return
-   value is cif->vfp_used (word bitset of VFP regs used for passing
-   arguments). These are only used for the VFP hard-float ABI.
-*/
-static void
-ffi_prep_args_SYSV (ffi_cif *cif, int flags, void *rvalue,
-		    void **avalue, char *argp)
-{
-  ffi_type **arg_types = cif->arg_types;
-  int i, n;
-
-  if (flags == ARM_TYPE_STRUCT)
-    {
-      *(void **) argp = rvalue;
-      argp += 4;
-    }
-
-  for (i = 0, n = cif->nargs; i < n; i++)
-    {
-      ffi_type *ty = arg_types[i];
-      argp = ffi_align (ty, argp);
-      argp += ffi_put_arg (ty, avalue[i], argp);
-    }
-}
-
-static void
-ffi_prep_args_VFP (ffi_cif *cif, int flags, void *rvalue,
-                   void **avalue, char *stack, char *vfp_space)
-{
-  ffi_type **arg_types = cif->arg_types;
-  int i, n, vi = 0;
-  char *argp, *regp, *eo_regp;
-  char stack_used = 0;
-  char done_with_regs = 0;
-
-  /* The first 4 words on the stack are used for values
-     passed in core registers.  */
-  regp = stack;
-  eo_regp = argp = regp + 16;
-
-  /* If the function returns an FFI_TYPE_STRUCT in memory,
-     that address is passed in r0 to the function.  */
-  if (flags == ARM_TYPE_STRUCT)
-    {
-      *(void **) regp = rvalue;
-      regp += 4;
-    }
-
-  for (i = 0, n = cif->nargs; i < n; i++)
-    {
-      ffi_type *ty = arg_types[i];
-      void *a = avalue[i];
-      int is_vfp_type = vfp_type_p (ty);
-
-      /* Allocated in VFP registers. */
-      if (vi < cif->vfp_nargs && is_vfp_type)
-	{
-	  char *vfp_slot = vfp_space + cif->vfp_args[vi++] * 4;
-	  ffi_put_arg (ty, a, vfp_slot);
-	  continue;
-	}
-      /* Try allocating in core registers. */
-      else if (!done_with_regs && !is_vfp_type)
-	{
-	  char *tregp = ffi_align (ty, regp);
-	  size_t size = ty->size;
-	  size = (size < 4) ? 4 : size;	// pad
-	  /* Check if there is space left in the aligned register
-	     area to place the argument.  */
-	  if (tregp + size <= eo_regp)
-	    {
-	      regp = tregp + ffi_put_arg (ty, a, tregp);
-	      done_with_regs = (regp == argp);
-	      // ensure we did not write into the stack area
-	      FFI_ASSERT (regp <= argp);
-	      continue;
-	    }
-	  /* In case there are no arguments in the stack area yet,
-	     the argument is passed in the remaining core registers
-	     and on the stack.  */
-	  else if (!stack_used)
-	    {
-	      stack_used = 1;
-	      done_with_regs = 1;
-	      argp = tregp + ffi_put_arg (ty, a, tregp);
-	      FFI_ASSERT (eo_regp < argp);
-	      continue;
-	    }
-	}
-      /* Base case, arguments are passed on the stack */
-      stack_used = 1;
-      argp = ffi_align (ty, argp);
-      argp += ffi_put_arg (ty, a, argp);
-    }
-}
-
-/* Perform machine dependent cif processing */
-ffi_status FFI_HIDDEN
-ffi_prep_cif_machdep (ffi_cif *cif)
-{
-  int flags = 0, cabi = cif->abi;
-  size_t bytes = cif->bytes;
-
-  /* Map out the register placements of VFP register args.  The VFP
-     hard-float calling conventions are slightly more sophisticated
-     than the base calling conventions, so we do it here instead of
-     in ffi_prep_args(). */
-  if (cabi == FFI_VFP)
-    layout_vfp_args (cif);
-
-  /* Set the return type flag */
-  switch (cif->rtype->type)
-    {
-    case FFI_TYPE_VOID:
-      flags = ARM_TYPE_VOID;
-      break;
-
-    case FFI_TYPE_INT:
-    case FFI_TYPE_UINT8:
-    case FFI_TYPE_SINT8:
-    case FFI_TYPE_UINT16:
-    case FFI_TYPE_SINT16:
-    case FFI_TYPE_UINT32:
-    case FFI_TYPE_SINT32:
-    case FFI_TYPE_POINTER:
-      flags = ARM_TYPE_INT;
-      break;
-
-    case FFI_TYPE_SINT64:
-    case FFI_TYPE_UINT64:
-      flags = ARM_TYPE_INT64;
-      break;
-
-    case FFI_TYPE_FLOAT:
-      flags = (cabi == FFI_VFP ? ARM_TYPE_VFP_S : ARM_TYPE_INT);
-      break;
-    case FFI_TYPE_DOUBLE:
-      flags = (cabi == FFI_VFP ? ARM_TYPE_VFP_D : ARM_TYPE_INT64);
-      break;
-
-    case FFI_TYPE_STRUCT:
-    case FFI_TYPE_COMPLEX:
-      if (cabi == FFI_VFP)
-	{
-	  int h = vfp_type_p (cif->rtype);
-
-	  flags = ARM_TYPE_VFP_N;
-	  if (h == 0x100 + FFI_TYPE_FLOAT)
-	    flags = ARM_TYPE_VFP_S;
-	  if (h == 0x100 + FFI_TYPE_DOUBLE)
-	    flags = ARM_TYPE_VFP_D;
-	  if (h != 0)
-	      break;
-	}
-
-      /* A Composite Type not larger than 4 bytes is returned in r0.
-	 A Composite Type larger than 4 bytes, or whose size cannot
-	 be determined statically ... is stored in memory at an
-	 address passed [in r0].  */
-      if (cif->rtype->size <= 4)
-	flags = ARM_TYPE_INT;
-      else
-	{
-	  flags = ARM_TYPE_STRUCT;
-	  bytes += 4;
-	}
-      break;
-
-    default:
-      abort();
-    }
-
-  /* Round the stack up to a multiple of 8 bytes.  This isn't needed
-     everywhere, but it is on some platforms, and it doesn't harm anything
-     when it isn't needed.  */
-  bytes = FFI_ALIGN (bytes, 8);
-
-  /* Minimum stack space is the 4 register arguments that we pop.  */
-  if (bytes < 4*4)
-    bytes = 4*4;
-
-  cif->bytes = bytes;
-  cif->flags = flags;
-
-  return FFI_OK;
-}
-
-/* Perform machine dependent cif processing for variadic calls */
-ffi_status FFI_HIDDEN
-ffi_prep_cif_machdep_var (ffi_cif * cif,
-			  unsigned int nfixedargs, unsigned int ntotalargs)
-{
-  /* VFP variadic calls actually use the SYSV ABI */
-  if (cif->abi == FFI_VFP)
-    cif->abi = FFI_SYSV;
-
-  return ffi_prep_cif_machdep (cif);
-}
-
-/* Prototypes for assembly functions, in sysv.S.  */
-
-struct call_frame
-{
-  void *fp;
-  void *lr;
-  void *rvalue;
-  int flags;
-  void *closure;
-};
-
-extern void ffi_call_SYSV (void *stack, struct call_frame *,
-			   void (*fn) (void)) FFI_HIDDEN;
-extern void ffi_call_VFP (void *vfp_space, struct call_frame *,
-			   void (*fn) (void), unsigned vfp_used) FFI_HIDDEN;
-
-static void
-ffi_call_int (ffi_cif * cif, void (*fn) (void), void *rvalue,
-	      void **avalue, void *closure)
-{
-  int flags = cif->flags;
-  ffi_type *rtype = cif->rtype;
-  size_t bytes, rsize, vfp_size;
-  char *stack, *vfp_space, *new_rvalue;
-  struct call_frame *frame;
-
-  rsize = 0;
-  if (rvalue == NULL)
-    {
-      /* If the return value is a struct and we don't have a return
-	 value address then we need to make one.  Otherwise the return
-	 value is in registers and we can ignore them.  */
-      if (flags == ARM_TYPE_STRUCT)
-	rsize = rtype->size;
-      else
-	flags = ARM_TYPE_VOID;
-    }
-  else if (flags == ARM_TYPE_VFP_N)
-    {
-      /* Largest case is double x 4. */
-      rsize = 32;
-    }
-  else if (flags == ARM_TYPE_INT && rtype->type == FFI_TYPE_STRUCT)
-    rsize = 4;
-
-  /* Largest case.  */
-  vfp_size = (cif->abi == FFI_VFP && cif->vfp_used ? 8*8: 0);
-
-  bytes = cif->bytes;
-  stack = alloca (vfp_size + bytes + sizeof(struct call_frame) + rsize);
-
-  vfp_space = NULL;
-  if (vfp_size)
-    {
-      vfp_space = stack;
-      stack += vfp_size;
-    }
-
-  frame = (struct call_frame *)(stack + bytes);
-
-  new_rvalue = rvalue;
-  if (rsize)
-    new_rvalue = (void *)(frame + 1);
-
-  frame->rvalue = new_rvalue;
-  frame->flags = flags;
-  frame->closure = closure;
-
-  if (vfp_space)
-    {
-      ffi_prep_args_VFP (cif, flags, new_rvalue, avalue, stack, vfp_space);
-      ffi_call_VFP (vfp_space, frame, fn, cif->vfp_used);
-    }
-  else
-    {
-      ffi_prep_args_SYSV (cif, flags, new_rvalue, avalue, stack);
-      ffi_call_SYSV (stack, frame, fn);
-    }
-
-  if (rvalue && rvalue != new_rvalue)
-    memcpy (rvalue, new_rvalue, rtype->size);
-}
-
-void
-ffi_call (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue)
-{
-  ffi_call_int (cif, fn, rvalue, avalue, NULL);
-}
-
-void
-ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue,
-	     void **avalue, void *closure)
-{
-  ffi_call_int (cif, fn, rvalue, avalue, closure);
-}
-
-static void *
-ffi_prep_incoming_args_SYSV (ffi_cif *cif, void *rvalue,
-			     char *argp, void **avalue)
-{
-  ffi_type **arg_types = cif->arg_types;
-  int i, n;
-
-  if (cif->flags == ARM_TYPE_STRUCT)
-    {
-      rvalue = *(void **) argp;
-      argp += 4;
-    }
-  else
-    {
-      if (cif->rtype->size && cif->rtype->size < 4)
-        *(uint32_t *) rvalue = 0;
-    }
-
-  for (i = 0, n = cif->nargs; i < n; i++)
-    {
-      ffi_type *ty = arg_types[i];
-      size_t z = ty->size;
-
-      argp = ffi_align (ty, argp);
-      avalue[i] = (void *) argp;
-      argp += z;
-    }
-
-  return rvalue;
-}
-
-static void *
-ffi_prep_incoming_args_VFP (ffi_cif *cif, void *rvalue, char *stack,
-			    char *vfp_space, void **avalue)
-{
-  ffi_type **arg_types = cif->arg_types;
-  int i, n, vi = 0;
-  char *argp, *regp, *eo_regp;
-  char done_with_regs = 0;
-  char stack_used = 0;
-
-  regp = stack;
-  eo_regp = argp = regp + 16;
-
-  if (cif->flags == ARM_TYPE_STRUCT)
-    {
-      rvalue = *(void **) regp;
-      regp += 4;
-    }
-
-  for (i = 0, n = cif->nargs; i < n; i++)
-    {
-      ffi_type *ty = arg_types[i];
-      int is_vfp_type = vfp_type_p (ty);
-      size_t z = ty->size;
-
-      if (vi < cif->vfp_nargs && is_vfp_type)
-	{
-	  avalue[i] = vfp_space + cif->vfp_args[vi++] * 4;
-	  continue;
-	}
-      else if (!done_with_regs && !is_vfp_type)
-	{
-	  char *tregp = ffi_align (ty, regp);
-
-	  z = (z < 4) ? 4 : z;	// pad
-
-	  /* If the arguments either fits into the registers or uses registers
-	     and stack, while we haven't read other things from the stack */
-	  if (tregp + z <= eo_regp || !stack_used)
-	    {
-	      /* Because we're little endian, this is what it turns into.  */
-	      avalue[i] = (void *) tregp;
-	      regp = tregp + z;
-
-	      /* If we read past the last core register, make sure we
-		 have not read from the stack before and continue
-		 reading after regp.  */
-	      if (regp > eo_regp)
-		{
-		  FFI_ASSERT (!stack_used);
-		  argp = regp;
-		}
-	      if (regp >= eo_regp)
-		{
-		  done_with_regs = 1;
-		  stack_used = 1;
-		}
-	      continue;
-	    }
-	}
-
-      stack_used = 1;
-      argp = ffi_align (ty, argp);
-      avalue[i] = (void *) argp;
-      argp += z;
-    }
-
-  return rvalue;
-}
-
-struct closure_frame
-{
-  char vfp_space[8*8] __attribute__((aligned(8)));
-  char result[8*4];
-  char argp[];
-};
-
-int FFI_HIDDEN
-ffi_closure_inner_SYSV (ffi_cif *cif,
-		        void (*fun) (ffi_cif *, void *, void **, void *),
-		        void *user_data,
-		        struct closure_frame *frame)
-{
-  void **avalue = (void **) alloca (cif->nargs * sizeof (void *));
-  void *rvalue = ffi_prep_incoming_args_SYSV (cif, frame->result,
-					      frame->argp, avalue);
-  fun (cif, rvalue, avalue, user_data);
-  return cif->flags;
-}
-
-int FFI_HIDDEN
-ffi_closure_inner_VFP (ffi_cif *cif,
-		       void (*fun) (ffi_cif *, void *, void **, void *),
-		       void *user_data,
-		       struct closure_frame *frame)
-{
-  void **avalue = (void **) alloca (cif->nargs * sizeof (void *));
-  void *rvalue = ffi_prep_incoming_args_VFP (cif, frame->result, frame->argp,
-					     frame->vfp_space, avalue);
-  fun (cif, rvalue, avalue, user_data);
-  return cif->flags;
-}
-
-void ffi_closure_SYSV (void) FFI_HIDDEN;
-void ffi_closure_VFP (void) FFI_HIDDEN;
-void ffi_go_closure_SYSV (void) FFI_HIDDEN;
-void ffi_go_closure_VFP (void) FFI_HIDDEN;
-
-/* the cif must already be prep'ed */
-
-ffi_status
-ffi_prep_closure_loc (ffi_closure * closure,
-		      ffi_cif * cif,
-		      void (*fun) (ffi_cif *, void *, void **, void *),
-		      void *user_data, void *codeloc)
-{
-  void (*closure_func) (void) = ffi_closure_SYSV;
-
-  if (cif->abi == FFI_VFP)
-    {
-      /* We only need take the vfp path if there are vfp arguments.  */
-      if (cif->vfp_used)
-	closure_func = ffi_closure_VFP;
-    }
-  else if (cif->abi != FFI_SYSV)
-    return FFI_BAD_ABI;
-
-#if FFI_EXEC_TRAMPOLINE_TABLE
-  void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
-  config[0] = closure;
-  config[1] = closure_func;
-#else
-
-#ifndef _M_ARM
-  memcpy(closure->tramp, ffi_arm_trampoline, 8);
-#else
-  // cast away function type so MSVC doesn't set the lower bit of the function pointer
-  memcpy(closure->tramp, (void*)((uintptr_t)ffi_arm_trampoline & 0xFFFFFFFE), FFI_TRAMPOLINE_CLOSURE_OFFSET);
-#endif
-
-#if defined (__QNX__)
-  msync(closure->tramp, 8, 0x1000000);	/* clear data map */
-  msync(codeloc, 8, 0x1000000);	/* clear insn map */
-#elif defined(_MSC_VER)
-  FlushInstructionCache(GetCurrentProcess(), closure->tramp, FFI_TRAMPOLINE_SIZE);
-#else
-  __clear_cache(closure->tramp, closure->tramp + 8);	/* clear data map */
-  __clear_cache(codeloc, codeloc + 8);			/* clear insn map */
-#endif
-#ifdef _M_ARM
-  *(void(**)(void))(closure->tramp + FFI_TRAMPOLINE_CLOSURE_FUNCTION) = closure_func;
-#else
-  *(void (**)(void))(closure->tramp + 8) = closure_func;
-#endif
-#endif
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-  return FFI_OK;
-}
-
-ffi_status
-ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif,
-		     void (*fun) (ffi_cif *, void *, void **, void *))
-{
-  void (*closure_func) (void) = ffi_go_closure_SYSV;
-
-  if (cif->abi == FFI_VFP)
-    {
-      /* We only need take the vfp path if there are vfp arguments.  */
-      if (cif->vfp_used)
-	closure_func = ffi_go_closure_VFP;
-    }
-  else if (cif->abi != FFI_SYSV)
-    return FFI_BAD_ABI;
-
-  closure->tramp = closure_func;
-  closure->cif = cif;
-  closure->fun = fun;
-
-  return FFI_OK;
-}
-
-/* Below are routines for VFP hard-float support. */
-
-/* A subroutine of vfp_type_p.  Given a structure type, return the type code
-   of the first non-structure element.  Recurse for structure elements.
-   Return -1 if the structure is in fact empty, i.e. no nested elements.  */
-
-static int
-is_hfa0 (const ffi_type *ty)
-{
-  ffi_type **elements = ty->elements;
-  int i, ret = -1;
-
-  if (elements != NULL)
-    for (i = 0; elements[i]; ++i)
-      {
-        ret = elements[i]->type;
-        if (ret == FFI_TYPE_STRUCT || ret == FFI_TYPE_COMPLEX)
-          {
-            ret = is_hfa0 (elements[i]);
-            if (ret < 0)
-              continue;
-          }
-        break;
-      }
-
-  return ret;
-}
-
-/* A subroutine of vfp_type_p.  Given a structure type, return true if all
-   of the non-structure elements are the same as CANDIDATE.  */
-
-static int
-is_hfa1 (const ffi_type *ty, int candidate)
-{
-  ffi_type **elements = ty->elements;
-  int i;
-
-  if (elements != NULL)
-    for (i = 0; elements[i]; ++i)
-      {
-        int t = elements[i]->type;
-        if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX)
-          {
-            if (!is_hfa1 (elements[i], candidate))
-              return 0;
-          }
-        else if (t != candidate)
-          return 0;
-      }
-
-  return 1;
-}
-
-/* Determine if TY is an homogenous floating point aggregate (HFA).
-   That is, a structure consisting of 1 to 4 members of all the same type,
-   where that type is a floating point scalar.
-
-   Returns non-zero iff TY is an HFA.  The result is an encoded value where
-   bits 0-7 contain the type code, and bits 8-10 contain the element count.  */
-
-static int
-vfp_type_p (const ffi_type *ty)
-{
-  ffi_type **elements;
-  int candidate, i;
-  size_t size, ele_count;
-
-  /* Quickest tests first.  */
-  candidate = ty->type;
-  switch (ty->type)
-    {
-    default:
-      return 0;
-    case FFI_TYPE_FLOAT:
-    case FFI_TYPE_DOUBLE:
-      ele_count = 1;
-      goto done;
-    case FFI_TYPE_COMPLEX:
-      candidate = ty->elements[0]->type;
-      if (candidate != FFI_TYPE_FLOAT && candidate != FFI_TYPE_DOUBLE)
-	return 0;
-      ele_count = 2;
-      goto done;
-    case FFI_TYPE_STRUCT:
-      break;
-    }
-
-  /* No HFA types are smaller than 4 bytes, or larger than 32 bytes.  */
-  size = ty->size;
-  if (size < 4 || size > 32)
-    return 0;
-
-  /* Find the type of the first non-structure member.  */
-  elements = ty->elements;
-  candidate = elements[0]->type;
-  if (candidate == FFI_TYPE_STRUCT || candidate == FFI_TYPE_COMPLEX)
-    {
-      for (i = 0; ; ++i)
-        {
-          candidate = is_hfa0 (elements[i]);
-          if (candidate >= 0)
-            break;
-        }
-    }
-
-  /* If the first member is not a floating point type, it's not an HFA.
-     Also quickly re-check the size of the structure.  */
-  switch (candidate)
-    {
-    case FFI_TYPE_FLOAT:
-      ele_count = size / sizeof(float);
-      if (size != ele_count * sizeof(float))
-        return 0;
-      break;
-    case FFI_TYPE_DOUBLE:
-      ele_count = size / sizeof(double);
-      if (size != ele_count * sizeof(double))
-        return 0;
-      break;
-    default:
-      return 0;
-    }
-  if (ele_count > 4)
-    return 0;
-
-  /* Finally, make sure that all scalar elements are the same type.  */
-  for (i = 0; elements[i]; ++i)
-    {
-      int t = elements[i]->type;
-      if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX)
-        {
-          if (!is_hfa1 (elements[i], candidate))
-            return 0;
-        }
-      else if (t != candidate)
-        return 0;
-    }
-
-  /* All tests succeeded.  Encode the result.  */
- done:
-  return (ele_count << 8) | candidate;
-}
-
-static int
-place_vfp_arg (ffi_cif *cif, int h)
-{
-  unsigned short reg = cif->vfp_reg_free;
-  int align = 1, nregs = h >> 8;
-
-  if ((h & 0xff) == FFI_TYPE_DOUBLE)
-    align = 2, nregs *= 2;
-
-  /* Align register number. */
-  if ((reg & 1) && align == 2)
-    reg++;
-
-  while (reg + nregs <= 16)
-    {
-      int s, new_used = 0;
-      for (s = reg; s < reg + nregs; s++)
-	{
-	  new_used |= (1 << s);
-	  if (cif->vfp_used & (1 << s))
-	    {
-	      reg += align;
-	      goto next_reg;
-	    }
-	}
-      /* Found regs to allocate. */
-      cif->vfp_used |= new_used;
-      cif->vfp_args[cif->vfp_nargs++] = (signed char)reg;
-
-      /* Update vfp_reg_free. */
-      if (cif->vfp_used & (1 << cif->vfp_reg_free))
-	{
-	  reg += nregs;
-	  while (cif->vfp_used & (1 << reg))
-	    reg += 1;
-	  cif->vfp_reg_free = reg;
-	}
-      return 0;
-    next_reg:;
-    }
-  // done, mark all regs as used
-  cif->vfp_reg_free = 16;
-  cif->vfp_used = 0xFFFF;
-  return 1;
-}
-
-static void
-layout_vfp_args (ffi_cif * cif)
-{
-  unsigned int i;
-  /* Init VFP fields */
-  cif->vfp_used = 0;
-  cif->vfp_nargs = 0;
-  cif->vfp_reg_free = 0;
-  memset (cif->vfp_args, -1, 16);	/* Init to -1. */
-
-  for (i = 0; i < cif->nargs; i++)
-    {
-      int h = vfp_type_p (cif->arg_types[i]);
-      if (h && place_vfp_arg (cif, h) == 1)
-	break;
-    }
-}
-
-#endif /* __arm__ or _M_ARM */
+/* ----------------------------------------------------------------------- 
+   ffi.c - Copyright (c) 2011 Timothy Wall 
+           Copyright (c) 2011 Plausible Labs Cooperative, Inc. 
+           Copyright (c) 2011 Anthony Green 
+	   Copyright (c) 2011 Free Software Foundation 
+           Copyright (c) 1998, 2008, 2011  Red Hat, Inc. 
+ 
+   ARM Foreign Function Interface 
+ 
+   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(__arm__) || defined(_M_ARM) 
+#include <fficonfig.h> 
+#include <ffi.h> 
+#include <ffi_common.h> 
+#include <stdint.h> 
+#include <stdlib.h> 
+#include "internal.h" 
+ 
+#if defined(_MSC_VER) && defined(_M_ARM) 
+#define WIN32_LEAN_AND_MEAN 
+#include <windows.h> 
+#endif 
+ 
+#if FFI_EXEC_TRAMPOLINE_TABLE 
+ 
+#ifdef __MACH__ 
+#include <mach/machine/vm_param.h> 
+#endif 
+ 
+#else 
+#ifndef _M_ARM 
+extern unsigned int ffi_arm_trampoline[2] FFI_HIDDEN; 
+#else 
+extern unsigned int ffi_arm_trampoline[3] FFI_HIDDEN; 
+#endif 
+#endif 
+ 
+/* Forward declares. */ 
+static int vfp_type_p (const ffi_type *); 
+static void layout_vfp_args (ffi_cif *); 
+ 
+static void * 
+ffi_align (ffi_type *ty, void *p) 
+{ 
+  /* Align if necessary */ 
+  size_t alignment; 
+#ifdef _WIN32_WCE 
+  alignment = 4; 
+#else 
+  alignment = ty->alignment; 
+  if (alignment < 4) 
+    alignment = 4; 
+#endif 
+  return (void *) FFI_ALIGN (p, alignment); 
+} 
+ 
+static size_t 
+ffi_put_arg (ffi_type *ty, void *src, void *dst) 
+{ 
+  size_t z = ty->size; 
+ 
+  switch (ty->type) 
+    { 
+    case FFI_TYPE_SINT8: 
+      *(UINT32 *)dst = *(SINT8 *)src; 
+      break; 
+    case FFI_TYPE_UINT8: 
+      *(UINT32 *)dst = *(UINT8 *)src; 
+      break; 
+    case FFI_TYPE_SINT16: 
+      *(UINT32 *)dst = *(SINT16 *)src; 
+      break; 
+    case FFI_TYPE_UINT16: 
+      *(UINT32 *)dst = *(UINT16 *)src; 
+      break; 
+ 
+    case FFI_TYPE_INT: 
+    case FFI_TYPE_SINT32: 
+    case FFI_TYPE_UINT32: 
+    case FFI_TYPE_POINTER: 
+#ifndef _MSC_VER 
+    case FFI_TYPE_FLOAT: 
+#endif 
+      *(UINT32 *)dst = *(UINT32 *)src; 
+      break; 
+ 
+#ifdef _MSC_VER 
+    // casting a float* to a UINT32* doesn't work on Windows 
+    case FFI_TYPE_FLOAT: 
+        *(uintptr_t *)dst = 0; 
+        *(float *)dst = *(float *)src; 
+        break; 
+#endif 
+ 
+    case FFI_TYPE_SINT64: 
+    case FFI_TYPE_UINT64: 
+    case FFI_TYPE_DOUBLE: 
+      *(UINT64 *)dst = *(UINT64 *)src; 
+      break; 
+ 
+    case FFI_TYPE_STRUCT: 
+    case FFI_TYPE_COMPLEX: 
+      memcpy (dst, src, z); 
+      break; 
+ 
+    default: 
+      abort(); 
+    } 
+ 
+  return FFI_ALIGN (z, 4); 
+} 
+ 
+/* ffi_prep_args is called once stack space has been allocated 
+   for the function's arguments. 
+ 
+   The vfp_space parameter is the load area for VFP regs, the return 
+   value is cif->vfp_used (word bitset of VFP regs used for passing 
+   arguments). These are only used for the VFP hard-float ABI. 
+*/ 
+static void 
+ffi_prep_args_SYSV (ffi_cif *cif, int flags, void *rvalue, 
+		    void **avalue, char *argp) 
+{ 
+  ffi_type **arg_types = cif->arg_types; 
+  int i, n; 
+ 
+  if (flags == ARM_TYPE_STRUCT) 
+    { 
+      *(void **) argp = rvalue; 
+      argp += 4; 
+    } 
+ 
+  for (i = 0, n = cif->nargs; i < n; i++) 
+    { 
+      ffi_type *ty = arg_types[i]; 
+      argp = ffi_align (ty, argp); 
+      argp += ffi_put_arg (ty, avalue[i], argp); 
+    } 
+} 
+ 
+static void 
+ffi_prep_args_VFP (ffi_cif *cif, int flags, void *rvalue, 
+                   void **avalue, char *stack, char *vfp_space) 
+{ 
+  ffi_type **arg_types = cif->arg_types; 
+  int i, n, vi = 0; 
+  char *argp, *regp, *eo_regp; 
+  char stack_used = 0; 
+  char done_with_regs = 0; 
+ 
+  /* The first 4 words on the stack are used for values 
+     passed in core registers.  */ 
+  regp = stack; 
+  eo_regp = argp = regp + 16; 
+ 
+  /* If the function returns an FFI_TYPE_STRUCT in memory, 
+     that address is passed in r0 to the function.  */ 
+  if (flags == ARM_TYPE_STRUCT) 
+    { 
+      *(void **) regp = rvalue; 
+      regp += 4; 
+    } 
+ 
+  for (i = 0, n = cif->nargs; i < n; i++) 
+    { 
+      ffi_type *ty = arg_types[i]; 
+      void *a = avalue[i]; 
+      int is_vfp_type = vfp_type_p (ty); 
+ 
+      /* Allocated in VFP registers. */ 
+      if (vi < cif->vfp_nargs && is_vfp_type) 
+	{ 
+	  char *vfp_slot = vfp_space + cif->vfp_args[vi++] * 4; 
+	  ffi_put_arg (ty, a, vfp_slot); 
+	  continue; 
+	} 
+      /* Try allocating in core registers. */ 
+      else if (!done_with_regs && !is_vfp_type) 
+	{ 
+	  char *tregp = ffi_align (ty, regp); 
+	  size_t size = ty->size; 
+	  size = (size < 4) ? 4 : size;	// pad 
+	  /* Check if there is space left in the aligned register 
+	     area to place the argument.  */ 
+	  if (tregp + size <= eo_regp) 
+	    { 
+	      regp = tregp + ffi_put_arg (ty, a, tregp); 
+	      done_with_regs = (regp == argp); 
+	      // ensure we did not write into the stack area 
+	      FFI_ASSERT (regp <= argp); 
+	      continue; 
+	    } 
+	  /* In case there are no arguments in the stack area yet, 
+	     the argument is passed in the remaining core registers 
+	     and on the stack.  */ 
+	  else if (!stack_used) 
+	    { 
+	      stack_used = 1; 
+	      done_with_regs = 1; 
+	      argp = tregp + ffi_put_arg (ty, a, tregp); 
+	      FFI_ASSERT (eo_regp < argp); 
+	      continue; 
+	    } 
+	} 
+      /* Base case, arguments are passed on the stack */ 
+      stack_used = 1; 
+      argp = ffi_align (ty, argp); 
+      argp += ffi_put_arg (ty, a, argp); 
+    } 
+} 
+ 
+/* Perform machine dependent cif processing */ 
+ffi_status FFI_HIDDEN 
+ffi_prep_cif_machdep (ffi_cif *cif) 
+{ 
+  int flags = 0, cabi = cif->abi; 
+  size_t bytes = cif->bytes; 
+ 
+  /* Map out the register placements of VFP register args.  The VFP 
+     hard-float calling conventions are slightly more sophisticated 
+     than the base calling conventions, so we do it here instead of 
+     in ffi_prep_args(). */ 
+  if (cabi == FFI_VFP) 
+    layout_vfp_args (cif); 
+ 
+  /* Set the return type flag */ 
+  switch (cif->rtype->type) 
+    { 
+    case FFI_TYPE_VOID: 
+      flags = ARM_TYPE_VOID; 
+      break; 
+ 
+    case FFI_TYPE_INT: 
+    case FFI_TYPE_UINT8: 
+    case FFI_TYPE_SINT8: 
+    case FFI_TYPE_UINT16: 
+    case FFI_TYPE_SINT16: 
+    case FFI_TYPE_UINT32: 
+    case FFI_TYPE_SINT32: 
+    case FFI_TYPE_POINTER: 
+      flags = ARM_TYPE_INT; 
+      break; 
+ 
+    case FFI_TYPE_SINT64: 
+    case FFI_TYPE_UINT64: 
+      flags = ARM_TYPE_INT64; 
+      break; 
+ 
+    case FFI_TYPE_FLOAT: 
+      flags = (cabi == FFI_VFP ? ARM_TYPE_VFP_S : ARM_TYPE_INT); 
+      break; 
+    case FFI_TYPE_DOUBLE: 
+      flags = (cabi == FFI_VFP ? ARM_TYPE_VFP_D : ARM_TYPE_INT64); 
+      break; 
+ 
+    case FFI_TYPE_STRUCT: 
+    case FFI_TYPE_COMPLEX: 
+      if (cabi == FFI_VFP) 
+	{ 
+	  int h = vfp_type_p (cif->rtype); 
+ 
+	  flags = ARM_TYPE_VFP_N; 
+	  if (h == 0x100 + FFI_TYPE_FLOAT) 
+	    flags = ARM_TYPE_VFP_S; 
+	  if (h == 0x100 + FFI_TYPE_DOUBLE) 
+	    flags = ARM_TYPE_VFP_D; 
+	  if (h != 0) 
+	      break; 
+	} 
+ 
+      /* A Composite Type not larger than 4 bytes is returned in r0. 
+	 A Composite Type larger than 4 bytes, or whose size cannot 
+	 be determined statically ... is stored in memory at an 
+	 address passed [in r0].  */ 
+      if (cif->rtype->size <= 4) 
+	flags = ARM_TYPE_INT; 
+      else 
+	{ 
+	  flags = ARM_TYPE_STRUCT; 
+	  bytes += 4; 
+	} 
+      break; 
+ 
+    default: 
+      abort(); 
+    } 
+ 
+  /* Round the stack up to a multiple of 8 bytes.  This isn't needed 
+     everywhere, but it is on some platforms, and it doesn't harm anything 
+     when it isn't needed.  */ 
+  bytes = FFI_ALIGN (bytes, 8); 
+ 
+  /* Minimum stack space is the 4 register arguments that we pop.  */ 
+  if (bytes < 4*4) 
+    bytes = 4*4; 
+ 
+  cif->bytes = bytes; 
+  cif->flags = flags; 
+ 
+  return FFI_OK; 
+} 
+ 
+/* Perform machine dependent cif processing for variadic calls */ 
+ffi_status FFI_HIDDEN 
+ffi_prep_cif_machdep_var (ffi_cif * cif, 
+			  unsigned int nfixedargs, unsigned int ntotalargs) 
+{ 
+  /* VFP variadic calls actually use the SYSV ABI */ 
+  if (cif->abi == FFI_VFP) 
+    cif->abi = FFI_SYSV; 
+ 
+  return ffi_prep_cif_machdep (cif); 
+} 
+ 
+/* Prototypes for assembly functions, in sysv.S.  */ 
+ 
+struct call_frame 
+{ 
+  void *fp; 
+  void *lr; 
+  void *rvalue; 
+  int flags; 
+  void *closure; 
+}; 
+ 
+extern void ffi_call_SYSV (void *stack, struct call_frame *, 
+			   void (*fn) (void)) FFI_HIDDEN; 
+extern void ffi_call_VFP (void *vfp_space, struct call_frame *, 
+			   void (*fn) (void), unsigned vfp_used) FFI_HIDDEN; 
+ 
+static void 
+ffi_call_int (ffi_cif * cif, void (*fn) (void), void *rvalue, 
+	      void **avalue, void *closure) 
+{ 
+  int flags = cif->flags; 
+  ffi_type *rtype = cif->rtype; 
+  size_t bytes, rsize, vfp_size; 
+  char *stack, *vfp_space, *new_rvalue; 
+  struct call_frame *frame; 
+ 
+  rsize = 0; 
+  if (rvalue == NULL) 
+    { 
+      /* If the return value is a struct and we don't have a return 
+	 value address then we need to make one.  Otherwise the return 
+	 value is in registers and we can ignore them.  */ 
+      if (flags == ARM_TYPE_STRUCT) 
+	rsize = rtype->size; 
+      else 
+	flags = ARM_TYPE_VOID; 
+    } 
+  else if (flags == ARM_TYPE_VFP_N) 
+    { 
+      /* Largest case is double x 4. */ 
+      rsize = 32; 
+    } 
+  else if (flags == ARM_TYPE_INT && rtype->type == FFI_TYPE_STRUCT) 
+    rsize = 4; 
+ 
+  /* Largest case.  */ 
+  vfp_size = (cif->abi == FFI_VFP && cif->vfp_used ? 8*8: 0); 
+ 
+  bytes = cif->bytes; 
+  stack = alloca (vfp_size + bytes + sizeof(struct call_frame) + rsize); 
+ 
+  vfp_space = NULL; 
+  if (vfp_size) 
+    { 
+      vfp_space = stack; 
+      stack += vfp_size; 
+    } 
+ 
+  frame = (struct call_frame *)(stack + bytes); 
+ 
+  new_rvalue = rvalue; 
+  if (rsize) 
+    new_rvalue = (void *)(frame + 1); 
+ 
+  frame->rvalue = new_rvalue; 
+  frame->flags = flags; 
+  frame->closure = closure; 
+ 
+  if (vfp_space) 
+    { 
+      ffi_prep_args_VFP (cif, flags, new_rvalue, avalue, stack, vfp_space); 
+      ffi_call_VFP (vfp_space, frame, fn, cif->vfp_used); 
+    } 
+  else 
+    { 
+      ffi_prep_args_SYSV (cif, flags, new_rvalue, avalue, stack); 
+      ffi_call_SYSV (stack, frame, fn); 
+    } 
+ 
+  if (rvalue && rvalue != new_rvalue) 
+    memcpy (rvalue, new_rvalue, rtype->size); 
+} 
+ 
+void 
+ffi_call (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue) 
+{ 
+  ffi_call_int (cif, fn, rvalue, avalue, NULL); 
+} 
+ 
+void 
+ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue, 
+	     void **avalue, void *closure) 
+{ 
+  ffi_call_int (cif, fn, rvalue, avalue, closure); 
+} 
+ 
+static void * 
+ffi_prep_incoming_args_SYSV (ffi_cif *cif, void *rvalue, 
+			     char *argp, void **avalue) 
+{ 
+  ffi_type **arg_types = cif->arg_types; 
+  int i, n; 
+ 
+  if (cif->flags == ARM_TYPE_STRUCT) 
+    { 
+      rvalue = *(void **) argp; 
+      argp += 4; 
+    } 
+  else 
+    { 
+      if (cif->rtype->size && cif->rtype->size < 4) 
+        *(uint32_t *) rvalue = 0; 
+    } 
+ 
+  for (i = 0, n = cif->nargs; i < n; i++) 
+    { 
+      ffi_type *ty = arg_types[i]; 
+      size_t z = ty->size; 
+ 
+      argp = ffi_align (ty, argp); 
+      avalue[i] = (void *) argp; 
+      argp += z; 
+    } 
+ 
+  return rvalue; 
+} 
+ 
+static void * 
+ffi_prep_incoming_args_VFP (ffi_cif *cif, void *rvalue, char *stack, 
+			    char *vfp_space, void **avalue) 
+{ 
+  ffi_type **arg_types = cif->arg_types; 
+  int i, n, vi = 0; 
+  char *argp, *regp, *eo_regp; 
+  char done_with_regs = 0; 
+  char stack_used = 0; 
+ 
+  regp = stack; 
+  eo_regp = argp = regp + 16; 
+ 
+  if (cif->flags == ARM_TYPE_STRUCT) 
+    { 
+      rvalue = *(void **) regp; 
+      regp += 4; 
+    } 
+ 
+  for (i = 0, n = cif->nargs; i < n; i++) 
+    { 
+      ffi_type *ty = arg_types[i]; 
+      int is_vfp_type = vfp_type_p (ty); 
+      size_t z = ty->size; 
+ 
+      if (vi < cif->vfp_nargs && is_vfp_type) 
+	{ 
+	  avalue[i] = vfp_space + cif->vfp_args[vi++] * 4; 
+	  continue; 
+	} 
+      else if (!done_with_regs && !is_vfp_type) 
+	{ 
+	  char *tregp = ffi_align (ty, regp); 
+ 
+	  z = (z < 4) ? 4 : z;	// pad 
+ 
+	  /* If the arguments either fits into the registers or uses registers 
+	     and stack, while we haven't read other things from the stack */ 
+	  if (tregp + z <= eo_regp || !stack_used) 
+	    { 
+	      /* Because we're little endian, this is what it turns into.  */ 
+	      avalue[i] = (void *) tregp; 
+	      regp = tregp + z; 
+ 
+	      /* If we read past the last core register, make sure we 
+		 have not read from the stack before and continue 
+		 reading after regp.  */ 
+	      if (regp > eo_regp) 
+		{ 
+		  FFI_ASSERT (!stack_used); 
+		  argp = regp; 
+		} 
+	      if (regp >= eo_regp) 
+		{ 
+		  done_with_regs = 1; 
+		  stack_used = 1; 
+		} 
+	      continue; 
+	    } 
+	} 
+ 
+      stack_used = 1; 
+      argp = ffi_align (ty, argp); 
+      avalue[i] = (void *) argp; 
+      argp += z; 
+    } 
+ 
+  return rvalue; 
+} 
+ 
+struct closure_frame 
+{ 
+  char vfp_space[8*8] __attribute__((aligned(8))); 
+  char result[8*4]; 
+  char argp[]; 
+}; 
+ 
+int FFI_HIDDEN 
+ffi_closure_inner_SYSV (ffi_cif *cif, 
+		        void (*fun) (ffi_cif *, void *, void **, void *), 
+		        void *user_data, 
+		        struct closure_frame *frame) 
+{ 
+  void **avalue = (void **) alloca (cif->nargs * sizeof (void *)); 
+  void *rvalue = ffi_prep_incoming_args_SYSV (cif, frame->result, 
+					      frame->argp, avalue); 
+  fun (cif, rvalue, avalue, user_data); 
+  return cif->flags; 
+} 
+ 
+int FFI_HIDDEN 
+ffi_closure_inner_VFP (ffi_cif *cif, 
+		       void (*fun) (ffi_cif *, void *, void **, void *), 
+		       void *user_data, 
+		       struct closure_frame *frame) 
+{ 
+  void **avalue = (void **) alloca (cif->nargs * sizeof (void *)); 
+  void *rvalue = ffi_prep_incoming_args_VFP (cif, frame->result, frame->argp, 
+					     frame->vfp_space, avalue); 
+  fun (cif, rvalue, avalue, user_data); 
+  return cif->flags; 
+} 
+ 
+void ffi_closure_SYSV (void) FFI_HIDDEN; 
+void ffi_closure_VFP (void) FFI_HIDDEN; 
+void ffi_go_closure_SYSV (void) FFI_HIDDEN; 
+void ffi_go_closure_VFP (void) FFI_HIDDEN; 
+ 
+/* the cif must already be prep'ed */ 
+ 
+ffi_status 
+ffi_prep_closure_loc (ffi_closure * closure, 
+		      ffi_cif * cif, 
+		      void (*fun) (ffi_cif *, void *, void **, void *), 
+		      void *user_data, void *codeloc) 
+{ 
+  void (*closure_func) (void) = ffi_closure_SYSV; 
+ 
+  if (cif->abi == FFI_VFP) 
+    { 
+      /* We only need take the vfp path if there are vfp arguments.  */ 
+      if (cif->vfp_used) 
+	closure_func = ffi_closure_VFP; 
+    } 
+  else if (cif->abi != FFI_SYSV) 
+    return FFI_BAD_ABI; 
+ 
+#if FFI_EXEC_TRAMPOLINE_TABLE 
+  void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE); 
+  config[0] = closure; 
+  config[1] = closure_func; 
+#else 
+ 
+#ifndef _M_ARM 
+  memcpy(closure->tramp, ffi_arm_trampoline, 8); 
+#else 
+  // cast away function type so MSVC doesn't set the lower bit of the function pointer 
+  memcpy(closure->tramp, (void*)((uintptr_t)ffi_arm_trampoline & 0xFFFFFFFE), FFI_TRAMPOLINE_CLOSURE_OFFSET); 
+#endif 
+ 
+#if defined (__QNX__) 
+  msync(closure->tramp, 8, 0x1000000);	/* clear data map */ 
+  msync(codeloc, 8, 0x1000000);	/* clear insn map */ 
+#elif defined(_MSC_VER) 
+  FlushInstructionCache(GetCurrentProcess(), closure->tramp, FFI_TRAMPOLINE_SIZE); 
+#else 
+  __clear_cache(closure->tramp, closure->tramp + 8);	/* clear data map */ 
+  __clear_cache(codeloc, codeloc + 8);			/* clear insn map */ 
+#endif 
+#ifdef _M_ARM 
+  *(void(**)(void))(closure->tramp + FFI_TRAMPOLINE_CLOSURE_FUNCTION) = closure_func; 
+#else 
+  *(void (**)(void))(closure->tramp + 8) = closure_func; 
+#endif 
+#endif 
+ 
+  closure->cif = cif; 
+  closure->fun = fun; 
+  closure->user_data = user_data; 
+ 
+  return FFI_OK; 
+} 
+ 
+ffi_status 
+ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif, 
+		     void (*fun) (ffi_cif *, void *, void **, void *)) 
+{ 
+  void (*closure_func) (void) = ffi_go_closure_SYSV; 
+ 
+  if (cif->abi == FFI_VFP) 
+    { 
+      /* We only need take the vfp path if there are vfp arguments.  */ 
+      if (cif->vfp_used) 
+	closure_func = ffi_go_closure_VFP; 
+    } 
+  else if (cif->abi != FFI_SYSV) 
+    return FFI_BAD_ABI; 
+ 
+  closure->tramp = closure_func; 
+  closure->cif = cif; 
+  closure->fun = fun; 
+ 
+  return FFI_OK; 
+} 
+ 
+/* Below are routines for VFP hard-float support. */ 
+ 
+/* A subroutine of vfp_type_p.  Given a structure type, return the type code 
+   of the first non-structure element.  Recurse for structure elements. 
+   Return -1 if the structure is in fact empty, i.e. no nested elements.  */ 
+ 
+static int 
+is_hfa0 (const ffi_type *ty) 
+{ 
+  ffi_type **elements = ty->elements; 
+  int i, ret = -1; 
+ 
+  if (elements != NULL) 
+    for (i = 0; elements[i]; ++i) 
+      { 
+        ret = elements[i]->type; 
+        if (ret == FFI_TYPE_STRUCT || ret == FFI_TYPE_COMPLEX) 
+          { 
+            ret = is_hfa0 (elements[i]); 
+            if (ret < 0) 
+              continue; 
+          } 
+        break; 
+      } 
+ 
+  return ret; 
+} 
+ 
+/* A subroutine of vfp_type_p.  Given a structure type, return true if all 
+   of the non-structure elements are the same as CANDIDATE.  */ 
+ 
+static int 
+is_hfa1 (const ffi_type *ty, int candidate) 
+{ 
+  ffi_type **elements = ty->elements; 
+  int i; 
+ 
+  if (elements != NULL) 
+    for (i = 0; elements[i]; ++i) 
+      { 
+        int t = elements[i]->type; 
+        if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX) 
+          { 
+            if (!is_hfa1 (elements[i], candidate)) 
+              return 0; 
+          } 
+        else if (t != candidate) 
+          return 0; 
+      } 
+ 
+  return 1; 
+} 
+ 
+/* Determine if TY is an homogenous floating point aggregate (HFA). 
+   That is, a structure consisting of 1 to 4 members of all the same type, 
+   where that type is a floating point scalar. 
+ 
+   Returns non-zero iff TY is an HFA.  The result is an encoded value where 
+   bits 0-7 contain the type code, and bits 8-10 contain the element count.  */ 
+ 
+static int 
+vfp_type_p (const ffi_type *ty) 
+{ 
+  ffi_type **elements; 
+  int candidate, i; 
+  size_t size, ele_count; 
+ 
+  /* Quickest tests first.  */ 
+  candidate = ty->type; 
+  switch (ty->type) 
+    { 
+    default: 
+      return 0; 
+    case FFI_TYPE_FLOAT: 
+    case FFI_TYPE_DOUBLE: 
+      ele_count = 1; 
+      goto done; 
+    case FFI_TYPE_COMPLEX: 
+      candidate = ty->elements[0]->type; 
+      if (candidate != FFI_TYPE_FLOAT && candidate != FFI_TYPE_DOUBLE) 
+	return 0; 
+      ele_count = 2; 
+      goto done; 
+    case FFI_TYPE_STRUCT: 
+      break; 
+    } 
+ 
+  /* No HFA types are smaller than 4 bytes, or larger than 32 bytes.  */ 
+  size = ty->size; 
+  if (size < 4 || size > 32) 
+    return 0; 
+ 
+  /* Find the type of the first non-structure member.  */ 
+  elements = ty->elements; 
+  candidate = elements[0]->type; 
+  if (candidate == FFI_TYPE_STRUCT || candidate == FFI_TYPE_COMPLEX) 
+    { 
+      for (i = 0; ; ++i) 
+        { 
+          candidate = is_hfa0 (elements[i]); 
+          if (candidate >= 0) 
+            break; 
+        } 
+    } 
+ 
+  /* If the first member is not a floating point type, it's not an HFA. 
+     Also quickly re-check the size of the structure.  */ 
+  switch (candidate) 
+    { 
+    case FFI_TYPE_FLOAT: 
+      ele_count = size / sizeof(float); 
+      if (size != ele_count * sizeof(float)) 
+        return 0; 
+      break; 
+    case FFI_TYPE_DOUBLE: 
+      ele_count = size / sizeof(double); 
+      if (size != ele_count * sizeof(double)) 
+        return 0; 
+      break; 
+    default: 
+      return 0; 
+    } 
+  if (ele_count > 4) 
+    return 0; 
+ 
+  /* Finally, make sure that all scalar elements are the same type.  */ 
+  for (i = 0; elements[i]; ++i) 
+    { 
+      int t = elements[i]->type; 
+      if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX) 
+        { 
+          if (!is_hfa1 (elements[i], candidate)) 
+            return 0; 
+        } 
+      else if (t != candidate) 
+        return 0; 
+    } 
+ 
+  /* All tests succeeded.  Encode the result.  */ 
+ done: 
+  return (ele_count << 8) | candidate; 
+} 
+ 
+static int 
+place_vfp_arg (ffi_cif *cif, int h) 
+{ 
+  unsigned short reg = cif->vfp_reg_free; 
+  int align = 1, nregs = h >> 8; 
+ 
+  if ((h & 0xff) == FFI_TYPE_DOUBLE) 
+    align = 2, nregs *= 2; 
+ 
+  /* Align register number. */ 
+  if ((reg & 1) && align == 2) 
+    reg++; 
+ 
+  while (reg + nregs <= 16) 
+    { 
+      int s, new_used = 0; 
+      for (s = reg; s < reg + nregs; s++) 
+	{ 
+	  new_used |= (1 << s); 
+	  if (cif->vfp_used & (1 << s)) 
+	    { 
+	      reg += align; 
+	      goto next_reg; 
+	    } 
+	} 
+      /* Found regs to allocate. */ 
+      cif->vfp_used |= new_used; 
+      cif->vfp_args[cif->vfp_nargs++] = (signed char)reg; 
+ 
+      /* Update vfp_reg_free. */ 
+      if (cif->vfp_used & (1 << cif->vfp_reg_free)) 
+	{ 
+	  reg += nregs; 
+	  while (cif->vfp_used & (1 << reg)) 
+	    reg += 1; 
+	  cif->vfp_reg_free = reg; 
+	} 
+      return 0; 
+    next_reg:; 
+    } 
+  // done, mark all regs as used 
+  cif->vfp_reg_free = 16; 
+  cif->vfp_used = 0xFFFF; 
+  return 1; 
+} 
+ 
+static void 
+layout_vfp_args (ffi_cif * cif) 
+{ 
+  unsigned int i; 
+  /* Init VFP fields */ 
+  cif->vfp_used = 0; 
+  cif->vfp_nargs = 0; 
+  cif->vfp_reg_free = 0; 
+  memset (cif->vfp_args, -1, 16);	/* Init to -1. */ 
+ 
+  for (i = 0; i < cif->nargs; i++) 
+    { 
+      int h = vfp_type_p (cif->arg_types[i]); 
+      if (h && place_vfp_arg (cif, h) == 1) 
+	break; 
+    } 
+} 
+ 
+#endif /* __arm__ or _M_ARM */