cybrid_api_id_ruby 0.117.27 → 0.117.29

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

@@ -1,310 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (C) 2012, 2013, 2018, 2021, 2022  Anthony Green
-
-   Moxie 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.
-   ----------------------------------------------------------------------- */
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-#include <stdlib.h>
-
-/* 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, extended_cif *ecif)
-{
-  register unsigned int i;
-  register void **p_argv;
-  register char *argp;
-  register ffi_type **p_arg;
-  register int count = 0;
-
-  p_argv = ecif->avalue;
-  argp = stack;
-
-  if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
-    {
-      *(void **) argp = ecif->rvalue;
-      argp += 4;
-    }
-
-  for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
-       (i != 0);
-       i--, p_arg++)
-    {
-      size_t z;
-
-      z = (*p_arg)->size;
-
-      if ((*p_arg)->type == FFI_TYPE_STRUCT)
-	{
-	  z = sizeof(void*);
-	  *(void **) argp = *p_argv;
-	}
-      else if (z < sizeof(int))
-	{
-	  z = sizeof(int);
-	  switch ((*p_arg)->type)
-	    {
-	    case FFI_TYPE_SINT8:
-	      *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
-	      break;
-
-	    case FFI_TYPE_UINT8:
-	      *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
-	      break;
-
-	    case FFI_TYPE_SINT16:
-	      *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
-	      break;
-
-	    case FFI_TYPE_UINT16:
-	      *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
-	      break;
-
-	    default:
-	      FFI_ASSERT(0);
-	    }
-	}
-      else if (z == sizeof(int))
-	{
-	  *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
-	}
-      else
-	{
-	  memcpy(argp, *p_argv, z);
-	}
-      p_argv++;
-      argp += z;
-      count += z;
-    }
-
-  return (stack + ((count > 24) ? 24 : FFI_ALIGN_DOWN(count, 8)));
-}
-
-/* Perform machine dependent cif processing */
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  if (cif->rtype->type == FFI_TYPE_STRUCT)
-    cif->flags = -1;
-  else
-    cif->flags = cif->rtype->size;
-
-  cif->bytes = FFI_ALIGN (cif->bytes, 8);
-
-  return FFI_OK;
-}
-
-extern void ffi_call_EABI(void *(*)(char *, extended_cif *),
-			  extended_cif *,
-			  unsigned, unsigned,
-			  unsigned *,
-			  void (*fn)(void));
-
-void ffi_call(ffi_cif *cif,
-	      void (*fn)(void),
-	      void *rvalue,
-	      void **avalue)
-{
-  extended_cif ecif;
-  ffi_type **arg_types = cif->arg_types;
-  int i, nargs = cif->nargs;
-
-  ecif.cif = cif;
-  ecif.avalue = avalue;
-
-  /* If the return value is a struct and we don't have a return	*/
-  /* value address then we need to make one		        */
-
-  if ((rvalue == NULL) &&
-      (cif->rtype->type == FFI_TYPE_STRUCT))
-    {
-      ecif.rvalue = alloca(cif->rtype->size);
-    }
-  else
-    ecif.rvalue = rvalue;
-
-  /* If we have any large structure arguments, make a copy so we are passing
-     by value.  */
-  for (i = 0; i < nargs; i++)
-    {
-      ffi_type *at = arg_types[i];
-      int size = at->size;
-      if (at->type == FFI_TYPE_STRUCT) /*  && size > 4) All struct args?? */
-        {
-          char *argcopy = alloca (size);
-          memcpy (argcopy, avalue[i], size);
-          avalue[i] = argcopy;
-        }
-    }
-
-  switch (cif->abi)
-    {
-    case FFI_EABI:
-      ffi_call_EABI(ffi_prep_args, &ecif, cif->bytes,
-		    cif->flags, ecif.rvalue, fn);
-      break;
-    default:
-      FFI_ASSERT(0);
-      break;
-    }
-}
-
-void ffi_closure_eabi (unsigned arg1, unsigned arg2, unsigned arg3,
-		       unsigned arg4, unsigned arg5, unsigned arg6)
-{
-  /* This function is called by a trampoline.  The trampoline stows a
-     pointer to the ffi_closure object in $r12.  We must save this
-     pointer in a place that will persist while we do our work.  */
-  register ffi_closure *creg __asm__ ("$r12");
-  ffi_closure *closure = creg;
-
-  /* Arguments that don't fit in registers are found on the stack
-     at a fixed offset above the current frame pointer.  */
-  register char *frame_pointer __asm__ ("$fp");
-
-  /* Pointer to a struct return value.  */
-  void *struct_rvalue = (void *) arg1;
-
-  /* 6 words reserved for register args + 3 words from jsr */
-  char *stack_args = frame_pointer + 9*4;
-
-  /* Lay the register arguments down in a continuous chunk of memory.  */
-  unsigned register_args[6] =
-    { arg1, arg2, arg3, arg4, arg5, arg6 };
-  char *register_args_ptr = (char *) register_args;
-
-  ffi_cif *cif = closure->cif;
-  ffi_type **arg_types = cif->arg_types;
-  void **avalue = alloca (cif->nargs * sizeof(void *));
-  char *ptr = (char *) register_args;
-  int i;
-
-  /* preserve struct type return pointer passing */
-  if ((cif->rtype != NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) {
-    ptr += 4;
-    register_args_ptr = (char *)&register_args[1];
-  }
-
-  /* Find the address of each argument.  */
-  for (i = 0; i < cif->nargs; i++)
-    {
-      switch (arg_types[i]->type)
-	{
-	case FFI_TYPE_SINT8:
-	case FFI_TYPE_UINT8:
-	  avalue[i] = ptr + 3;
-	  break;
-	case FFI_TYPE_SINT16:
-	case FFI_TYPE_UINT16:
-	  avalue[i] = ptr + 2;
-	  break;
-	case FFI_TYPE_SINT32:
-	case FFI_TYPE_UINT32:
-	case FFI_TYPE_FLOAT:
-	case FFI_TYPE_POINTER:
-	  avalue[i] = ptr;
-	  break;
-	case FFI_TYPE_STRUCT:
-          {
-            if (arg_types[i]->size > 4)
-              {
-                void *copy = alloca(arg_types[i]->size);
-                memcpy(copy, *(void**)ptr, arg_types[i]->size);
-                avalue[i] = copy;
-              }
-            else
-              avalue[i] = *(void**)ptr;
-          }
-	  break;
-	default:
-	  /* This is an 8-byte value.  */
-	  if (ptr == (char *) &register_args[5])
-	    {
-	      /* The value is split across two locations */
-	      unsigned *ip = alloca(8);
-	      avalue[i] = ip;
-	      ip[0] = *(unsigned *) ptr;
-	      ip[1] = *(unsigned *) stack_args;
-	    }
-	  else
-	    {
-	      avalue[i] = ptr;
-	    }
-	  ptr += 4;
-	  break;
-	}
-      ptr += 4;
-
-      /* If we've handled more arguments than fit in registers,
-	 start looking at the those passed on the stack.  */
-      if (ptr == (char *) &register_args[6])
-	ptr = stack_args;
-      else if (ptr == (char *) &register_args[7])
-	ptr = stack_args + 4;
-    }
-
-  /* Invoke the closure.  */
-  if (cif->rtype && (cif->rtype->type == FFI_TYPE_STRUCT))
-    {
-      (closure->fun) (cif, struct_rvalue, avalue, closure->user_data);
-    }
-  else
-    {
-      /* Allocate space for the return value and call the function.  */
-      long long rvalue;
-      (closure->fun) (cif, &rvalue, avalue, closure->user_data);
-      asm ("mov $r12, %0\n ld.l $r0, ($r12)\n ldo.l $r1, 4($r12)" : : "r" (&rvalue));
-    }
-}
-
-ffi_status
-ffi_prep_closure_loc (ffi_closure* closure,
-		      ffi_cif* cif,
-		      void (*fun)(ffi_cif*, void*, void**, void*),
-		      void *user_data,
-		      void *codeloc)
-{
-  unsigned short *tramp = (unsigned short *) &closure->tramp[0];
-  unsigned long fn = (long) ffi_closure_eabi;
-  unsigned long cls = (long) codeloc;
-
-  if (cif->abi != FFI_EABI)
-    return FFI_BAD_ABI;
-
-  fn = (unsigned long) ffi_closure_eabi;
-
-  tramp[0] = 0x01e0; /* ldi.l $r12, .... */
-  tramp[1] = cls >> 16;
-  tramp[2] = cls & 0xffff;
-  tramp[3] = 0x1a00; /* jmpa .... */
-  tramp[4] = fn >> 16;
-  tramp[5] = fn & 0xffff;
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-  return FFI_OK;
-}

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

@@ -1,52 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 2012, 2013  Anthony Green
-   Target configuration macros for Moxie
-
-   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.
-
-   ----------------------------------------------------------------------- */
-
-#ifndef LIBFFI_TARGET_H
-#define LIBFFI_TARGET_H
-
-/* ---- System specific configurations ----------------------------------- */
-
-#ifndef LIBFFI_ASM
-typedef unsigned long          ffi_arg;
-typedef signed long            ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_EABI,
-  FFI_DEFAULT_ABI = FFI_EABI,
-  FFI_LAST_ABI = FFI_DEFAULT_ABI + 1
-} ffi_abi;
-#endif
-
-/* ---- Definitions for closures ----------------------------------------- */
-
-#define FFI_CLOSURES 1
-#define FFI_NATIVE_RAW_API 0
-
-/* Trampolines are 12-bytes long.  See ffi_prep_closure_loc.  */
-#define FFI_TRAMPOLINE_SIZE (12)
-
-#endif

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

@@ -1,304 +0,0 @@
-/* libffi support for Altera Nios II.
-
-   Copyright (c) 2013 Mentor Graphics.
-
-   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.  */
-
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-#include <stdlib.h>
-
-/* The Nios II Processor Reference Handbook defines the procedure call
-   ABI as follows.
-
-   Arguments are passed as if a structure containing the types of
-   the arguments were constructed.  The first 16 bytes are passed in r4
-   through r7, the remainder on the stack.  The first 16 bytes of a function
-   taking variable arguments are passed in r4-r7 in the same way.
-
-   Return values of types up to 8 bytes are returned in r2 and r3.  For
-   return values greater than 8 bytes, the caller must allocate memory for
-   the result and pass the address as if it were argument 0.  
-
-   While this isn't specified explicitly in the ABI documentation, GCC
-   promotes integral arguments smaller than int size to 32 bits.
-
-   Also of note, the ABI specifies that all structure objects are
-   aligned to 32 bits even if all their fields have a smaller natural
-   alignment.  See FFI_AGGREGATE_ALIGNMENT.  */
-
-
-/* Declare the assembly language hooks.  */
-
-extern UINT64 ffi_call_sysv (void (*) (char *, extended_cif *),
-			     extended_cif *,
-			     unsigned, 
-			     void (*fn) (void));
-extern void ffi_closure_sysv (void);
-
-/* Perform machine-dependent cif processing.  */
-
-ffi_status ffi_prep_cif_machdep (ffi_cif *cif)
-{
-  /* We always want at least 16 bytes in the parameter block since it
-     simplifies the low-level call function.  Also round the parameter
-     block size up to a multiple of 4 bytes to preserve
-     32-bit alignment of the stack pointer.  */
-  if (cif->bytes < 16)
-    cif->bytes = 16;
-  else
-    cif->bytes = (cif->bytes + 3) & ~3;
-
-  return FFI_OK;
-}
-
-
-/* ffi_prep_args is called by the assembly routine to transfer arguments
-   to the stack using the pointers in the ecif array.
-   Note that the stack buffer is big enough to fit all the arguments,
-   but the first 16 bytes will be copied to registers for the actual
-   call.  */
-
-void ffi_prep_args (char *stack, extended_cif *ecif)
-{
-  char *argp = stack;
-  unsigned int i;
-
-  /* The implicit return value pointer is passed as if it were a hidden
-     first argument.  */
-  if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
-      && ecif->cif->rtype->size > 8)
-    {
-      (*(void **) argp) = ecif->rvalue;
-      argp += 4;
-    }
-
-  for (i = 0; i < ecif->cif->nargs; i++)
-    {
-      void *avalue = ecif->avalue[i];
-      ffi_type *atype = ecif->cif->arg_types[i];
-      size_t size = atype->size;
-      size_t alignment = atype->alignment;
-
-      /* Align argp as appropriate for the argument type.  */
-      if ((alignment - 1) & (unsigned) argp)
-	argp = (char *) FFI_ALIGN (argp, alignment);
-
-      /* Copy the argument, promoting integral types smaller than a
-	 word to word size.  */
-      if (size < sizeof (int))
-	{
-	  size = sizeof (int);
-	  switch (atype->type)
-	    {
-	    case FFI_TYPE_SINT8:
-	      *(signed int *) argp = (signed int) *(SINT8 *) avalue;
-	      break;
-		  
-	    case FFI_TYPE_UINT8:
-	      *(unsigned int *) argp = (unsigned int) *(UINT8 *) avalue;
-	      break;
-		  
-	    case FFI_TYPE_SINT16:
-	      *(signed int *) argp = (signed int) *(SINT16 *) avalue;
-	      break;
-		  
-	    case FFI_TYPE_UINT16:
-	      *(unsigned int *) argp = (unsigned int) *(UINT16 *) avalue;
-	      break;
-
-	    case FFI_TYPE_STRUCT:
-	      memcpy (argp, avalue, atype->size);
-	      break;
-
-	    default:
-	      FFI_ASSERT(0);
-	    }
-	}
-      else if (size == sizeof (int))
-	*(unsigned int *) argp = (unsigned int) *(UINT32 *) avalue;
-      else
-	memcpy (argp, avalue, size);
-      argp += size;
-    }
-}
-
-
-/* Call FN using the prepared CIF.  RVALUE points to space allocated by
-   the caller for the return value, and AVALUE is an array of argument
-   pointers.  */
-
-void ffi_call (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue)
-{
-
-  extended_cif ecif;
-  UINT64 result;
-
-  /* If bigret is true, this is the case where a return value of larger
-     than 8 bytes is handled by being passed by reference as an implicit
-     argument.  */
-  int bigret = (cif->rtype->type == FFI_TYPE_STRUCT
-		&& cif->rtype->size > 8);
-
-  ecif.cif = cif;
-  ecif.avalue = avalue;
-
-  /* Allocate space for return value if this is the pass-by-reference case
-     and the caller did not provide a buffer.  */
-  if (rvalue == NULL && bigret)
-    ecif.rvalue = alloca (cif->rtype->size);
-  else
-    ecif.rvalue = rvalue;
-
-  result = ffi_call_sysv (ffi_prep_args, &ecif, cif->bytes, fn);
-
-  /* Now result contains the 64 bit contents returned from fn in
-     r2 and r3.  Copy the value of the appropriate size to the user-provided
-     rvalue buffer.  */
-  if (rvalue && !bigret)
-    switch (cif->rtype->size)
-      {
-      case 1:
-	*(UINT8 *)rvalue = (UINT8) result;
-	break;
-      case 2:
-	*(UINT16 *)rvalue = (UINT16) result;
-	break;
-      case 4:
-	*(UINT32 *)rvalue = (UINT32) result;
-	break;
-      case 8:
-	*(UINT64 *)rvalue = (UINT64) result;
-	break;
-      default:
-	memcpy (rvalue, (void *)&result, cif->rtype->size);
-	break;
-      }
-}
-
-/* This function is invoked from the closure trampoline to invoke
-   CLOSURE with argument block ARGS.  Parse ARGS according to
-   CLOSURE->cfi and invoke CLOSURE->fun.  */
-
-static UINT64
-ffi_closure_helper (unsigned char *args,
-		    ffi_closure *closure)
-{
-  ffi_cif *cif = closure->cif;
-  unsigned char *argp = args;
-  void **parsed_args = alloca (cif->nargs * sizeof (void *));
-  UINT64 result;
-  void *retptr;
-  unsigned int i;
-
-  /* First figure out what to do about the return type.  If this is the
-     big-structure-return case, the first arg is the hidden return buffer
-     allocated by the caller.  */
-  if (cif->rtype->type == FFI_TYPE_STRUCT
-      && cif->rtype->size > 8)
-    {
-      retptr = *((void **) argp);
-      argp += 4;
-    }
-  else
-    retptr = (void *) &result;
-
-  /* Fill in the array of argument pointers.  */
-  for (i = 0; i < cif->nargs; i++)
-    {
-      size_t size = cif->arg_types[i]->size;
-      size_t alignment = cif->arg_types[i]->alignment;
-
-      /* Align argp as appropriate for the argument type.  */
-      if ((alignment - 1) & (unsigned) argp)
-	argp = (char *) FFI_ALIGN (argp, alignment);
-
-      /* Arguments smaller than an int are promoted to int.  */
-      if (size < sizeof (int))
-	size = sizeof (int);
-
-      /* Store the pointer.  */
-      parsed_args[i] = argp;
-      argp += size;
-    }
-
-  /* Call the user-supplied function.  */
-  (closure->fun) (cif, retptr, parsed_args, closure->user_data);
-  return result;
-}
-
-
-/* Initialize CLOSURE with a trampoline to call FUN with
-   CIF and USER_DATA.  */
-ffi_status
-ffi_prep_closure_loc (ffi_closure* closure,
-		      ffi_cif* cif,
-		      void (*fun) (ffi_cif*, void*, void**, void*),
-		      void *user_data,
-		      void *codeloc)
-{
-  unsigned int *tramp = (unsigned int *) &closure->tramp[0];
-  int i;
-
-  if (cif->abi != FFI_SYSV)
-    return FFI_BAD_ABI;
-
-  /* The trampoline looks like:
-       movhi r8, %hi(ffi_closure_sysv)
-       ori r8, r8, %lo(ffi_closure_sysv)
-       movhi r9, %hi(ffi_closure_helper)
-       ori r0, r9, %lo(ffi_closure_helper)
-       movhi r10, %hi(closure)
-       ori r10, r10, %lo(closure)
-       jmp r8
-     and then ffi_closure_sysv retrieves the closure pointer out of r10
-     in addition to the arguments passed in the normal way for the call,
-     and invokes ffi_closure_helper.  We encode the pointer to
-     ffi_closure_helper in the trampoline because making a PIC call
-     to it in ffi_closure_sysv would be messy (it would have to indirect
-     through the GOT).  */
-
-#define HI(x) ((((unsigned int) (x)) >> 16) & 0xffff)
-#define LO(x) (((unsigned int) (x)) & 0xffff)
-  tramp[0] = (0 << 27) | (8 << 22) | (HI (ffi_closure_sysv) << 6) | 0x34;
-  tramp[1] = (8 << 27) | (8 << 22) | (LO (ffi_closure_sysv) << 6) | 0x14;
-  tramp[2] = (0 << 27) | (9 << 22) | (HI (ffi_closure_helper) << 6) | 0x34;
-  tramp[3] = (9 << 27) | (9 << 22) | (LO (ffi_closure_helper) << 6) | 0x14;
-  tramp[4] = (0 << 27) | (10 << 22) | (HI (closure) << 6) | 0x34;
-  tramp[5] = (10 << 27) | (10 << 22) | (LO (closure) << 6) | 0x14;
-  tramp[6] = (8 << 27) | (0x0d << 11) | 0x3a;
-#undef HI
-#undef LO
-
-  /* Flush the caches.
-     See Example 9-4 in the Nios II Software Developer's Handbook.  */
-  for (i = 0; i < 7; i++)
-    asm volatile ("flushd 0(%0); flushi %0" :: "r"(tramp + i) : "memory");
-  asm volatile ("flushp" ::: "memory");
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-  return FFI_OK;
-}
-