ffi 1.17.1 → 1.17.3

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

@@ -29,6 +29,8 @@
 
 #include <ffi.h>
 #include <ffi_common.h>
+#include "internal.h"
+#include <tramp.h>
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -424,34 +426,44 @@ extern void ffi_closure_asm(void) FFI_HIDDEN;
 
 ffi_status ffi_prep_closure_loc(ffi_closure *closure, ffi_cif *cif, void (*fun)(ffi_cif*,void*,void**,void*), void *user_data, void *codeloc)
 {
-    uint32_t *tramp = (uint32_t *) &closure->tramp[0];
-    uint64_t fn = (uint64_t) (uintptr_t) ffi_closure_asm;
-
     if (cif->abi <= FFI_FIRST_ABI || cif->abi >= FFI_LAST_ABI)
         return FFI_BAD_ABI;
 
-    /* we will call ffi_closure_inner with codeloc, not closure, but as long
-       as the memory is readable it should work */
+#ifdef FFI_EXEC_STATIC_TRAMP
+  if (ffi_tramp_is_present (closure))
+    {
+      /* Initialize the static trampoline's parameters. */
+      void (*dest)(void) = ffi_closure_asm;
+      ffi_tramp_set_parms (closure->ftramp, dest, closure);
+    }
+  else
+#endif
+    {
+      uint32_t *tramp = (uint32_t *) &closure->tramp[0];
+      uint64_t fn = (uint64_t) (uintptr_t) ffi_closure_asm;
+
+      /* we will call ffi_closure_inner with codeloc, not closure, but as long
+	 as the memory is readable it should work */
 
-    tramp[0] = 0x00000317; /* auipc t1, 0 (i.e. t0 <- codeloc) */
+      tramp[0] = 0x00000317; /* auipc t1, 0 (i.e. t0 <- codeloc) */
 #if __SIZEOF_POINTER__ == 8
-    tramp[1] = 0x01033383; /* ld t2, 16(t1) */
+      tramp[1] = 0x01033383; /* ld t2, 16(t1) */
 #else
-    tramp[1] = 0x01032383; /* lw t2, 16(t1) */
+      tramp[1] = 0x01032383; /* lw t2, 16(t1) */
 #endif
-    tramp[2] = 0x00038067; /* jr t2 */
-    tramp[3] = 0x00000013; /* nop */
-    tramp[4] = fn;
-    tramp[5] = fn >> 32;
+      tramp[2] = 0x00038067; /* jr t2 */
+      tramp[3] = 0x00000013; /* nop */
+      tramp[4] = fn;
+      tramp[5] = fn >> 32;
+#if !defined(__FreeBSD__)
+    __builtin___clear_cache(codeloc, codeloc + FFI_TRAMPOLINE_SIZE);
+#endif
+    }
 
     closure->cif = cif;
     closure->fun = fun;
     closure->user_data = user_data;
 
-#if !defined(__FreeBSD__)
-    __builtin___clear_cache(codeloc, codeloc + FFI_TRAMPOLINE_SIZE);
-#endif
-
     return FFI_OK;
 }
 
@@ -512,3 +524,14 @@ ffi_closure_inner (ffi_cif *cif,
         marshal(&cb, cif->rtype, 0, rvalue);
     }
 }
+
+#ifdef FFI_EXEC_STATIC_TRAMP
+void *
+ffi_tramp_arch (size_t *tramp_size, size_t *map_size)
+{
+  extern void *trampoline_code_table;
+  *tramp_size = RISCV_TRAMP_SIZE;
+  *map_size = RISCV_TRAMP_MAP_SIZE;
+  return &trampoline_code_table;
+}
+#endif

data/ext/ffi_c/libffi/src/riscv/internal.h

@@ -0,0 +1,7 @@
+#ifdef FFI_EXEC_STATIC_TRAMP
+/* For the trampoline table mapping, a mapping size of 4K (base page size)
+   is chosen.  */
+#define RISCV_TRAMP_MAP_SHIFT	12
+#define RISCV_TRAMP_MAP_SIZE	(1 << RISCV_TRAMP_MAP_SHIFT)
+#define RISCV_TRAMP_SIZE	16
+#endif /* FFI_EXEC_STATIC_TRAMP */

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

@@ -29,6 +29,7 @@
 #define LIBFFI_ASM
 #include <fficonfig.h>
 #include <ffi.h>
+#include "internal.h"
 
 /* Define aliases so that we can handle all ABIs uniformly */
 
@@ -291,3 +292,26 @@ ffi_go_closure_asm:
     ret
     .cfi_endproc
     .size ffi_go_closure_asm, .-ffi_go_closure_asm
+
+#ifdef FFI_EXEC_STATIC_TRAMP
+/*
+  trampoline_code_table.
+*/
+    .globl trampoline_code_table
+    .hidden trampoline_code_table
+    .type trampoline_code_table, @function
+    .align RISCV_TRAMP_MAP_SHIFT
+trampoline_code_table:
+    .option push
+    # Do not allow the jr insn to be encoded as c.jr for alignment purposes
+    .option norvc
+    .rept   RISCV_TRAMP_MAP_SIZE / RISCV_TRAMP_SIZE
+    auipc   t2, RISCV_TRAMP_MAP_SIZE >> 12
+    LARG    t1, 0(t2)
+    LARG    t2, PTRS(t2)
+    jr      t2
+    .endr
+    .option pop
+    .size   trampoline_code_table,.-trampoline_code_table
+    .align RISCV_TRAMP_MAP_SHIFT
+#endif /* FFI_EXEC_STATIC_TRAMP */

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

@@ -32,6 +32,7 @@
 #include <ffi_common.h>
 #include <stdint.h>
 #include "internal.h"
+#include <tramp.h>
 
 /*====================== End of Includes =============================*/
 
@@ -720,16 +721,30 @@ ffi_prep_closure_loc (ffi_closure *closure,
 #endif
     0x07f1			/* br %r1 */
   };
-
+  void (*dest)(void);
   unsigned long *tramp = (unsigned long *)&closure->tramp;
 
   if (cif->abi != FFI_SYSV)
     return FFI_BAD_ABI;
 
+
+#if defined(FFI_EXEC_STATIC_TRAMP)
+  if (ffi_tramp_is_present(closure))
+    {
+      /* Initialize the static trampoline's parameters. */
+      dest = ffi_closure_SYSV;
+      ffi_tramp_set_parms (closure->ftramp, dest, closure);
+      goto out;
+    }
+#endif
+
   memcpy (tramp, template, sizeof(template));
   tramp[2] = (unsigned long)codeloc;
   tramp[3] = (unsigned long)&ffi_closure_SYSV;
 
+#if defined(FFI_EXEC_STATIC_TRAMP)
+out:
+#endif
   closure->cif = cif;
   closure->fun = fun;
   closure->user_data = user_data;
@@ -754,3 +769,15 @@ ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif,
 
   return FFI_OK;
 }
+
+#if defined(FFI_EXEC_STATIC_TRAMP)
+void *
+ffi_tramp_arch (size_t *tramp_size, size_t *map_size)
+{
+  extern void *trampoline_code_table;
+
+  *tramp_size = FFI390_TRAMP_SIZE;
+  *map_size = FFI390_TRAMP_MAP_SIZE;
+  return &trampoline_code_table;
+}
+#endif

data/ext/ffi_c/libffi/src/s390/internal.h

@@ -9,3 +9,14 @@
 #define FFI390_RET_IN_MEM	8
 
 #define FFI390_RET_STRUCT	(FFI390_RET_VOID | FFI390_RET_IN_MEM)
+
+
+#if defined(FFI_EXEC_STATIC_TRAMP)
+/*
+ * For the trampoline code table mapping, a mapping size of 4K is chosen.
+ */
+#define FFI390_TRAMP_MAP_SHIFT	12
+#define FFI390_TRAMP_MAP_SIZE	(1 << FFI390_TRAMP_MAP_SHIFT)
+#define FFI390_TRAMP_SIZE	16
+
+#endif

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

@@ -28,6 +28,7 @@
 #define LIBFFI_ASM
 #include <fficonfig.h>
 #include <ffi.h>
+#include "internal.h"
 
 	.text
 
@@ -318,6 +319,43 @@ ffi_closure_SYSV:
 	br	%r14
 	.cfi_endproc
 	.size	 ffi_closure_SYSV,.-ffi_closure_SYSV
+
+
+#if defined(FFI_EXEC_STATIC_TRAMP)
+/*
+ * Below is the definition of the trampoline code table. Each element in
+ * the code table is a trampoline.
+ */
+/*
+ * The trampoline uses the volatile register r0 and r1. As the registers are
+ * marked volatile in the ABI, the original values are not saved.
+ *
+ * The trampoline has two parameters - target code to jump to and data for
+ * the target code. The trampoline extracts the parameters from its parameter
+ * block (see tramp_table_map()). The trampoline saves the data address in r0.
+ * Finally, it jumps to the target code.
+ */
+
+	.align	FFI390_TRAMP_MAP_SIZE
+trampoline_code_table:
+	.rept	FFI390_TRAMP_MAP_SIZE / FFI390_TRAMP_SIZE
+	basr %r1,0              # load next instruction address to r1
+	lmg %r0,%r1,4094(%r1)   # load parameter block
+							# 		r0 -> data
+							# 		r1 -> code
+	br %r1                  # jump to r1/code
+	.balign	8
+	.endr
+
+	.globl trampoline_code_table
+	FFI_HIDDEN(trampoline_code_table)
+#ifdef __ELF__
+	.type	trampoline_code_table, @function
+	.size	trampoline_code_table,.- trampoline_code_table
+#endif
+	.align	FFI390_TRAMP_MAP_SIZE
+#endif /* FFI_EXEC_STATIC_TRAMP */
+
 #endif /* !s390x */
 
 #if defined __ELF__ && defined __linux__

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

@@ -286,6 +286,8 @@ ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
 	      void **avalue, void *closure)
 {
   size_t bytes = cif->bytes;
+  size_t i, nargs = cif->nargs;
+  ffi_type **arg_types = cif->arg_types;
 
   FFI_ASSERT (cif->abi == FFI_V8);
 
@@ -295,6 +297,20 @@ ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
       && (cif->flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
     bytes += FFI_ALIGN (cif->rtype->size, 8);
 
+  /* If we have any 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)
+        {
+          char *argcopy = alloca (size);
+          memcpy (argcopy, avalue[i], size);
+          avalue[i] = argcopy;
+        }
+    }
+
   ffi_call_v8(cif, fn, rvalue, avalue, -bytes, closure);
 }
 

data/ext/ffi_c/libffi/src/tramp.c

@@ -209,6 +209,11 @@ ffi_tramp_get_libffi (void)
   unsigned long start, end, offset, inode;
   uintptr_t addr = (uintptr_t) tramp_globals.text;
   int nfields, found;
+  int open_flags = O_RDONLY;
+
+#ifdef O_CLOEXEC
+  open_flags |= O_CLOEXEC;
+#endif
 
   snprintf (file, PATH_MAX, "/proc/%d/maps", getpid());
   fp = fopen (file, "r");
@@ -236,7 +241,7 @@ ffi_tramp_get_libffi (void)
   if (!found)
     return 0;
 
-  tramp_globals.fd = open (file, O_RDONLY);
+  tramp_globals.fd = open (file, open_flags);
   if (tramp_globals.fd == -1)
     return 0;
 

data/ext/ffi_c/libffi/src/types.c

@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------
-   types.c - Copyright (c) 1996, 1998, 2024  Red Hat, Inc.
+   types.c - Copyright (c) 1996, 1998, 2024, 2025  Red Hat, Inc.
 
    Predefined ffi_types needed by libffi.
 
@@ -31,6 +31,28 @@
 #include <ffi.h>
 #include <ffi_common.h>
 
+/* Return a version string. */
+const char *ffi_get_version (void)
+{
+  return FFI_VERSION_STRING;
+}
+
+/* Return the version as an unsigned long value: (x * 10000 + y * 100 + z) */
+unsigned long ffi_get_version_number (void)
+{
+  return FFI_VERSION_NUMBER;
+}
+
+unsigned int ffi_get_default_abi (void)
+{
+  return FFI_DEFAULT_ABI;
+}
+
+size_t ffi_get_closure_size (void)
+{
+  return sizeof(ffi_closure);
+}
+
 /* Type definitions */
 
 #define FFI_TYPEDEF(name, type, id, maybe_const)\