ffi 1.9.18-x64-mingw32 → 1.9.21-x64-mingw32

data/ext/ffi_c/libffi/src/nios2/ffitarget.h

@@ -0,0 +1,52 @@
+/* libffi target includes 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.  */
+
+
+#ifndef LIBFFI_TARGET_H
+#define LIBFFI_TARGET_H
+
+#ifndef LIBFFI_H
+#error "Please do not include ffitarget.h directly into your source.  Use ffi.h instead."
+#endif
+
+#ifndef LIBFFI_ASM
+typedef unsigned long          ffi_arg;
+typedef signed long            ffi_sarg;
+
+typedef enum ffi_abi {
+  FFI_FIRST_ABI = 0,
+  FFI_SYSV,
+  FFI_LAST_ABI,
+  FFI_DEFAULT_ABI = FFI_SYSV
+} ffi_abi;
+#endif
+
+/* Structures have a 4-byte alignment even if all the fields have lesser
+   alignment requirements.  */
+#define FFI_AGGREGATE_ALIGNMENT 4
+
+#define FFI_CLOSURES 1
+#define FFI_TRAMPOLINE_SIZE 28   /* 7 instructions */
+#define FFI_NATIVE_RAW_API 0
+
+#endif

data/ext/ffi_c/libffi/src/nios2/sysv.S

@@ -0,0 +1,136 @@
+/* Low-level 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.  */
+
+/* This function is declared on the C side as 
+
+   extern UINT64 ffi_call_sysv (void (*arghook) (char *, extended_cif *),
+	  		        extended_cif *ecif,
+				unsigned nbytes, 
+				void (*fn) (void));
+	
+   On input, the arguments appear as
+	r4 = arghook
+	r5 = ecif
+	r6 = nbytes
+	r7 = fn
+*/
+
+	.section	.text
+	.align	2
+	.global	ffi_call_sysv
+	.type	ffi_call_sysv, @function
+
+ffi_call_sysv:
+	.cfi_startproc
+
+	/* Create the stack frame, saving r16 so we can use it locally.  */
+	addi	sp, sp, -12
+	.cfi_def_cfa_offset 12
+	stw	ra, 8(sp)
+	stw	fp, 4(sp)
+	stw	r16, 0(sp)
+	.cfi_offset 31, -4
+	.cfi_offset 28, -8
+	.cfi_offset 16, -12
+	mov	fp, sp
+	.cfi_def_cfa_register 28
+	mov	r16, r7
+
+	/* Adjust the stack pointer to create the argument buffer
+	   nbytes long.  */
+	sub	sp, sp, r6
+
+	/* Call the arghook function.  */
+	mov	r2, r4		/* fn */
+	mov	r4, sp		/* argbuffer */
+	callr	r2		/* r5 already contains ecif */
+
+	/* Pop off the first 16 bytes of the argument buffer on the stack,
+	   transferring the contents to the argument registers.  */
+	ldw	r4, 0(sp)
+	ldw	r5, 4(sp)
+	ldw	r6, 8(sp)
+	ldw	r7, 12(sp)
+	addi	sp, sp, 16
+
+	/* Call the user function, which leaves its result in r2 and r3.  */
+	callr	r16
+
+	/* Pop off the stack frame.  */
+	mov	sp, fp
+	ldw	ra, 8(sp)
+	ldw	fp, 4(sp)
+	ldw	r16, 0(sp)
+	addi	sp, sp, 12
+	ret
+	.cfi_endproc
+	.size	ffi_call_sysv, .-ffi_call_sysv
+
+
+/* Closure trampolines jump here after putting the C helper address
+   in r9 and the closure pointer in r10.  The user-supplied arguments
+   to the closure are in the normal places, in r4-r7 and on the
+   stack.  Push the register arguments on the stack too and then call the
+   C helper function to deal with them.  */
+   
+	.section	.text
+	.align	2
+	.global	ffi_closure_sysv
+	.type	ffi_closure_sysv, @function
+
+ffi_closure_sysv:
+	.cfi_startproc
+
+	/* Create the stack frame, pushing the register args on the stack
+	   just below the stack args.  This is the same trick illustrated
+	   in Figure 7-3 in the Nios II Processor Reference Handbook, used
+	   for variable arguments and structures passed by value.  */
+	addi	sp, sp, -20
+	.cfi_def_cfa_offset 20
+	stw	ra, 0(sp)
+	.cfi_offset 31, -20
+	stw	r4, 4(sp)
+	.cfi_offset 4, -16
+	stw	r5, 8(sp)
+	.cfi_offset 5, -12
+	stw	r6, 12(sp)
+	.cfi_offset 6, -8
+	stw	r7, 16(sp)
+	.cfi_offset 7, -4
+
+	/* Call the helper.
+	   r4 = pointer to arguments on stack
+	   r5 = closure pointer (loaded in r10 by the trampoline)
+	   r9 = address of helper function (loaded by trampoline) */
+	addi	r4, sp, 4
+	mov	r5, r10
+	callr	r9
+	
+	/* Pop the stack and return.  */
+	ldw	ra, 0(sp)
+	addi	sp, sp, 20
+	.cfi_def_cfa_offset -20
+	ret
+	.cfi_endproc
+	.size	ffi_closure_sysv, .-ffi_closure_sysv
+

data/ext/ffi_c/libffi/src/or1k/ffi.c

@@ -0,0 +1,328 @@
+/* -----------------------------------------------------------------------
+   ffi.c - Copyright (c) 2014 Sebastian Macke <sebastian@macke.de>
+
+   OpenRISC 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"
+
+/* 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)
+{
+  char *stacktemp = stack;
+  int i, s;
+  ffi_type **arg;
+  int count = 0;
+  int nfixedargs;
+  
+  nfixedargs = ecif->cif->nfixedargs;
+  arg = ecif->cif->arg_types;
+  void **argv = ecif->avalue;
+
+  if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
+    {
+      *(void **) stack = ecif->rvalue;
+      stack += 4;
+      count = 4;
+    } 
+  for(i=0; i<ecif->cif->nargs; i++)
+  {
+
+    /* variadic args are saved on stack */
+    if ((nfixedargs == 0) && (count < 24))
+      {
+        count = 24;
+        stack = stacktemp + 24;        
+      }
+    nfixedargs--;
+
+    s = 4;
+    switch((*arg)->type) 
+      {
+      case FFI_TYPE_STRUCT:
+        *(void **)stack = *argv;
+        break;
+
+      case FFI_TYPE_SINT8:
+        *(signed int *) stack = (signed int)*(SINT8 *)(* argv);
+        break;
+
+      case FFI_TYPE_UINT8:
+        *(unsigned int *) stack = (unsigned int)*(UINT8 *)(* argv);
+        break;
+
+      case FFI_TYPE_SINT16:
+        *(signed int *) stack = (signed int)*(SINT16 *)(* argv);
+        break;
+
+      case FFI_TYPE_UINT16:
+        *(unsigned int *) stack = (unsigned int)*(UINT16 *)(* argv);
+        break;
+
+      case FFI_TYPE_SINT32:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_FLOAT:
+      case FFI_TYPE_POINTER:
+        *(int *)stack = *(int*)(*argv);
+        break;
+
+      default: /* 8 byte types */
+        if (count == 20) /* never split arguments */
+          {
+            stack += 4;
+            count += 4;
+          }  
+        s = (*arg)->size;
+        memcpy(stack, *argv, s);
+        break;
+      }
+
+    stack += s;
+    count += s;
+    argv++;
+    arg++;
+  }
+  return stacktemp + ((count>24)?24:0);
+}
+
+extern void ffi_call_SYSV(unsigned,
+                          extended_cif *,
+                          void *(*)(int *, extended_cif *),
+                          unsigned *,
+                          void (*fn)(void),
+                          unsigned);
+
+
+void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
+{
+  int i;
+  int size;
+  ffi_type **arg;
+
+  /* Calculate size to allocate on stack */
+
+  for(i = 0, arg = cif->arg_types, size=0; i < cif->nargs; i++, arg++)
+    {
+      if ((*arg)->type == FFI_TYPE_STRUCT)
+        size += 4;
+      else
+      if ((*arg)->size <= 4)
+        size += 4;
+      else
+        size += 8;
+    }
+
+  /* for variadic functions more space is needed on the stack */
+  if (cif->nargs != cif->nfixedargs)
+    size += 24;
+
+  if (cif->rtype->type == FFI_TYPE_STRUCT)
+    size += 4;
+
+
+  extended_cif ecif;
+  ecif.cif = cif;
+  ecif.avalue = avalue;
+  ecif.rvalue = rvalue;
+
+  switch (cif->abi) 
+  {
+    case FFI_SYSV:
+      ffi_call_SYSV(size, &ecif, ffi_prep_args, rvalue, fn, cif->flags);
+      break;
+    default:
+      FFI_ASSERT(0);
+      break;
+  }
+}
+
+
+void ffi_closure_SYSV(unsigned long r3, unsigned long r4, unsigned long r5, 
+                      unsigned long r6, unsigned long r7, unsigned long r8)
+{
+  register int *sp __asm__ ("r17");
+  register int *r13 __asm__ ("r13");
+
+  ffi_closure* closure = (ffi_closure*) r13;
+  char *stack_args = sp;
+
+  /* Lay the register arguments down in a continuous chunk of memory.  */
+  unsigned register_args[6] =
+    { r3, r4, r5, r6, r7, r8 };
+
+  /* Pointer to a struct return value.  */
+  void *struct_rvalue = (void *) r3;
+
+  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 count = 0;
+  int nfixedargs = cif->nfixedargs;
+  int i;
+
+  /* preserve struct type return pointer passing */
+
+  if ((cif->rtype != NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) 
+  {
+    ptr += 4;
+    count = 4;
+  }
+
+  /* Find the address of each argument.  */
+  for (i = 0; i < cif->nargs; i++)
+    {
+
+      /* variadic args are saved on stack */
+      if ((nfixedargs == 0) && (count < 24))
+        {
+          ptr = stack_args;
+          count = 24;
+        }
+      nfixedargs--;
+
+      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:
+          avalue[i] = *(void**)ptr;
+          break;
+
+        default:
+          /* 8-byte values  */
+
+          /* arguments are never splitted */
+          if (ptr == &register_args[5])
+            ptr = stack_args;
+          avalue[i] = ptr;
+          ptr += 4;
+          count += 4;
+          break;
+        }
+      ptr += 4;
+      count += 4;
+
+      /* If we've handled more arguments than fit in registers,
+         start looking at the those passed on the stack.  */
+
+      if (count == 24)
+        ptr = stack_args;
+    }
+
+  if (cif->rtype && (cif->rtype->type == FFI_TYPE_STRUCT))
+    {
+      (closure->fun) (cif, struct_rvalue, avalue, closure->user_data);
+    } else
+    {
+      long long rvalue;
+      (closure->fun) (cif, &rvalue, avalue, closure->user_data);
+      if (cif->rtype)
+        asm ("l.ori r12, %0, 0x0\n l.lwz r11, 0(r12)\n l.lwz r12, 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;
+  unsigned long fn = (unsigned long) ffi_closure_SYSV;
+  unsigned long cls = (unsigned long) codeloc;
+
+  if (cif->abi != FFI_SYSV)
+    return FFI_BAD_ABI;
+
+  closure->cif = cif;
+  closure->user_data = user_data;
+  closure->fun = fun;
+
+  /* write pointers to temporary registers */
+  tramp[0] = (0x6 << 10) | (13 << 5); /* l.movhi r13, ... */
+  tramp[1] = cls >> 16;
+  tramp[2] = (0x2a << 10) | (13 << 5) | 13; /* l.ori r13, r13, ... */
+  tramp[3] = cls & 0xFFFF;
+
+  tramp[4] = (0x6 << 10) | (15 << 5); /* l.movhi r15, ... */
+  tramp[5] = fn >> 16;
+  tramp[6] = (0x2a << 10) | (15 << 5) | 15; /* l.ori r15, r15 ... */
+  tramp[7] = fn & 0xFFFF;
+
+  tramp[8] = (0x11 << 10); /* l.jr r15 */
+  tramp[9] = 15 << 11;
+
+  tramp[10] = (0x2a << 10) | (17 << 5) | 1; /* l.ori r17, r1, ... */
+  tramp[11] = 0x0;
+
+  return FFI_OK;
+}
+
+
+ffi_status ffi_prep_cif_machdep (ffi_cif *cif)
+{
+  cif->flags = 0;
+	
+  /* structures are returned as pointers */
+  if (cif->rtype->type == FFI_TYPE_STRUCT)
+    cif->flags = FFI_TYPE_STRUCT;
+  else 
+  if (cif->rtype->size > 4)
+    cif->flags = FFI_TYPE_UINT64;
+
+  cif->nfixedargs = cif->nargs;
+
+  return FFI_OK;
+}
+
+
+ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif,
+         unsigned int nfixedargs, unsigned int ntotalargs)
+{
+  ffi_status status;
+
+  status = ffi_prep_cif_machdep (cif);
+  cif->nfixedargs = nfixedargs;
+  return status;
+}