ffi 1.16.2 → 1.17.0.rc1

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

@@ -64,6 +64,13 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
 #define PTR_SIZE	8
 #endif
 
+#define BTI_C hint #34
+#define BTI_J hint #36
+/*
+ * The ELF Notes section needs to indicate if BTI is supported, as the first ELF loaded that doesn't
+ * declare this support disables it for memory region containing the loaded library.
+ */
+# define GNU_PROPERTY_AARCH64_BTI (1 << 0)         /* Has Branch Target Identification */
 	.text
 	.align 4
 
@@ -84,6 +91,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
 
 	cfi_startproc
 CNAME(ffi_call_SYSV):
+	BTI_C
 	/* Sign the lr with x1 since that is where it will be stored */
 	SIGN_LR_WITH_REG(x1)
 
@@ -144,78 +152,142 @@ CNAME(ffi_call_SYSV):
 	/* Save the return value as directed.  */
 	adr	x5, 0f
 	and	w4, w4, #AARCH64_RET_MASK
-	add	x5, x5, x4, lsl #3
+	add	x5, x5, x4, lsl #4
 	br	x5
 
-	/* Note that each table entry is 2 insns, and thus 8 bytes.
+	/* Note that each table entry is 4 insns, and thus 16 bytes.
 	   For integer data, note that we're storing into ffi_arg
 	   and therefore we want to extend to 64 bits; these types
 	   have two consecutive entries allocated for them.  */
 	.align	4
-0:	b 99f				/* VOID */
+0:	BTI_J				/* VOID */
+	b 99f
+	nop 
 	nop
-1:	str	x0, [x3]		/* INT64 */
+1:	BTI_J				/* INT64 */
+	str	x0, [x3]
 	b 99f
-2:	stp	x0, x1, [x3]		/* INT128 */
+	nop
+2:	BTI_J				/* INT128 */
+	stp	x0, x1, [x3]
 	b 99f
+	nop
 3:	brk	#1000			/* UNUSED */
 	b 99f
+	nop
+	nop
 4:	brk	#1000			/* UNUSED */
 	b 99f
+	nop
+	nop
 5:	brk	#1000			/* UNUSED */
 	b 99f
+	nop
+	nop
 6:	brk	#1000			/* UNUSED */
 	b 99f
+	nop
+	nop
 7:	brk	#1000			/* UNUSED */
 	b 99f
-8:	st4	{ v0.s, v1.s, v2.s, v3.s }[0], [x3]	/* S4 */
+	nop
+	nop
+8:	BTI_J				/* S4 */
+	st4	{ v0.s, v1.s, v2.s, v3.s }[0], [x3]
 	b 99f
-9:	st3	{ v0.s, v1.s, v2.s }[0], [x3]	/* S3 */
+	nop
+9:	BTI_J				/* S3 */
+	st3	{ v0.s, v1.s, v2.s }[0], [x3]
 	b 99f
-10:	stp	s0, s1, [x3]		/* S2 */
+	nop
+10:	BTI_J				/* S2 */
+	stp	s0, s1, [x3]
 	b 99f
-11:	str	s0, [x3]		/* S1 */
+	nop
+11:	BTI_J
+	str	s0, [x3]		/* S1 */
 	b 99f
-12:	st4	{ v0.d, v1.d, v2.d, v3.d }[0], [x3]	/* D4 */
+	nop
+12:	BTI_J				/* D4 */
+	st4	{ v0.d, v1.d, v2.d, v3.d }[0], [x3]
 	b 99f
-13:	st3	{ v0.d, v1.d, v2.d }[0], [x3]	/* D3 */
+	nop
+13:	BTI_J				/* D3 */
+	st3	{ v0.d, v1.d, v2.d }[0], [x3]
 	b 99f
-14:	stp	d0, d1, [x3]		/* D2 */
+	nop
+14:	BTI_J				/* D2 */
+	stp	d0, d1, [x3]
 	b 99f
-15:	str	d0, [x3]		/* D1 */
+	nop
+15:	BTI_J				/* D1 */
+	str	d0, [x3]
 	b 99f
-16:	str	q3, [x3, #48]		/* Q4 */
 	nop
-17:	str	q2, [x3, #32]		/* Q3 */
+16:	BTI_J				/* Q4 */
+	str	q3, [x3, #48]
 	nop
-18:	stp	q0, q1, [x3]		/* Q2 */
+	nop
+17:	BTI_J				/* Q3 */
+	str	q2, [x3, #32]
+	nop
+	nop
+18:	BTI_J				/* Q2 */
+	stp	q0, q1, [x3]
 	b 99f
-19:	str	q0, [x3]		/* Q1 */
+	nop
+19:	BTI_J				/* Q1 */
+	str	q0, [x3]
 	b 99f
-20:	uxtb	w0, w0			/* UINT8 */
+	nop
+20:	BTI_J				/* UINT8 */
+	uxtb	w0, w0
 	str	x0, [x3]
+	nop
 21:	b 99f				/* reserved */
 	nop
-22:	uxth	w0, w0			/* UINT16 */
+	nop
+	nop
+22:	BTI_J				/* UINT16 */
+	uxth	w0, w0
 	str	x0, [x3]
+	nop
 23:	b 99f				/* reserved */
 	nop
-24:	mov	w0, w0			/* UINT32 */
+	nop
+	nop
+24:	BTI_J				/* UINT32 */
+	mov	w0, w0
 	str	x0, [x3]
+	nop
 25:	b 99f				/* reserved */
 	nop
-26:	sxtb	x0, w0			/* SINT8 */
+	nop
+	nop
+26:	BTI_J				/* SINT8 */
+	sxtb	x0, w0
 	str	x0, [x3]
+	nop
 27:	b 99f				/* reserved */
 	nop
-28:	sxth	x0, w0			/* SINT16 */
+	nop
+	nop
+28:	BTI_J				/* SINT16 */
+	sxth	x0, w0
 	str	x0, [x3]
+	nop
 29:	b 99f				/* reserved */
 	nop
-30:	sxtw	x0, w0			/* SINT32 */
+	nop
+	nop
+30:	BTI_J				/* SINT32 */
+	sxtw	x0, w0
 	str	x0, [x3]
+	nop
 31:	b 99f				/* reserved */
 	nop
+	nop
+	nop
 
 	/* Return now that result has been populated. */
 99:
@@ -252,6 +324,7 @@ CNAME(ffi_call_SYSV):
 	.align 4
 CNAME(ffi_closure_SYSV_V):
 	cfi_startproc
+	BTI_C
 	SIGN_LR
 	stp     x29, x30, [sp, #-ffi_closure_SYSV_FS]!
 	cfi_adjust_cfa_offset (ffi_closure_SYSV_FS)
@@ -276,6 +349,7 @@ CNAME(ffi_closure_SYSV_V):
 	.align	4
 	cfi_startproc
 CNAME(ffi_closure_SYSV):
+	BTI_C
 	SIGN_LR
 	stp     x29, x30, [sp, #-ffi_closure_SYSV_FS]!
 	cfi_adjust_cfa_offset (ffi_closure_SYSV_FS)
@@ -305,73 +379,135 @@ L(do_closure):
 	/* Load the return value as directed.  */
 	adr	x1, 0f
 	and	w0, w0, #AARCH64_RET_MASK
-	add	x1, x1, x0, lsl #3
+	add	x1, x1, x0, lsl #4
 	add	x3, sp, #16+CALL_CONTEXT_SIZE
 	br	x1
 
-	/* Note that each table entry is 2 insns, and thus 8 bytes.  */
+	/* Note that each table entry is 4 insns, and thus 16 bytes.  */
 	.align	4
-0:	b	99f			/* VOID */
+0:	BTI_J				/* VOID */
+	b	99f
+	nop
 	nop
-1:	ldr	x0, [x3]		/* INT64 */
+1:	BTI_J				/* INT64 */
+	ldr	x0, [x3]
 	b	99f
-2:	ldp	x0, x1, [x3]		/* INT128 */
+	nop
+2:	BTI_J				/* INT128 */
+	ldp	x0, x1, [x3]
 	b	99f
+	nop
 3:	brk	#1000			/* UNUSED */
 	nop
+	nop
+	nop
 4:	brk	#1000			/* UNUSED */
 	nop
+	nop
+	nop
 5:	brk	#1000			/* UNUSED */
 	nop
+	nop
+	nop
 6:	brk	#1000			/* UNUSED */
 	nop
+	nop
+	nop
 7:	brk	#1000			/* UNUSED */
 	nop
-8:	ldr	s3, [x3, #12]		/* S4 */
 	nop
-9:	ldr	s2, [x3, #8]		/* S3 */
 	nop
-10:	ldp	s0, s1, [x3]		/* S2 */
+8:	BTI_J				/* S4 */
+	ldr	s3, [x3, #12]
+	nop
+	nop
+9:	BTI_J				/* S3 */
+	ldr	s2, [x3, #8]
+	nop
+	nop
+10:	BTI_J				/* S2 */
+	ldp	s0, s1, [x3]
 	b	99f
-11:	ldr	s0, [x3]		/* S1 */
+	nop
+11:	BTI_J				/* S1 */
+	ldr	s0, [x3]
 	b	99f
-12:	ldr	d3, [x3, #24]		/* D4 */
 	nop
-13:	ldr	d2, [x3, #16]		/* D3 */
+12:	BTI_J				/* D4 */
+	ldr	d3, [x3, #24]
+	nop
+	nop
+13:	BTI_J				/* D3 */
+	ldr	d2, [x3, #16]
 	nop
-14:	ldp	d0, d1, [x3]		/* D2 */
+	nop
+14:	BTI_J				/* D2 */
+	ldp	d0, d1, [x3]
 	b	99f
-15:	ldr	d0, [x3]		/* D1 */
+	nop
+15:	BTI_J				/* D1 */
+	ldr	d0, [x3]
 	b	99f
-16:	ldr	q3, [x3, #48]		/* Q4 */
 	nop
-17:	ldr	q2, [x3, #32]		/* Q3 */
+16:	BTI_J				/* Q4 */
+	ldr	q3, [x3, #48]
 	nop
-18:	ldp	q0, q1, [x3]		/* Q2 */
+	nop
+17:	BTI_J				/* Q3 */
+	ldr	q2, [x3, #32]
+	nop
+	nop
+18:	BTI_J				/* Q2 */
+	ldp	q0, q1, [x3]
 	b	99f
-19:	ldr	q0, [x3]		/* Q1 */
+	nop
+19:	BTI_J				/* Q1 */
+	ldr	q0, [x3]
 	b	99f
-20:	ldrb	w0, [x3, #BE(7)]	/* UINT8 */
+	nop
+20:	BTI_J				/* UINT8 */
+	ldrb	w0, [x3, #BE(7)]
 	b	99f
+	nop
 21:	brk	#1000			/* reserved */
 	nop
-22:	ldrh	w0, [x3, #BE(6)]	/* UINT16 */
+	nop
+	nop
+22:	BTI_J				/* UINT16 */
+	ldrh	w0, [x3, #BE(6)]
 	b	99f
+	nop
 23:	brk	#1000			/* reserved */
 	nop
-24:	ldr	w0, [x3, #BE(4)]	/* UINT32 */
+	nop
+	nop
+24:	BTI_J				/* UINT32 */
+	ldr	w0, [x3, #BE(4)]
 	b	99f
+	nop
 25:	brk	#1000			/* reserved */
 	nop
-26:	ldrsb	x0, [x3, #BE(7)]	/* SINT8 */
+	nop
+	nop
+26:	BTI_J				/* SINT8 */
+	ldrsb	x0, [x3, #BE(7)]
 	b	99f
+	nop
 27:	brk	#1000			/* reserved */
 	nop
-28:	ldrsh	x0, [x3, #BE(6)]	/* SINT16 */
+	nop
+	nop
+28:	BTI_J				/* SINT16 */
+	ldrsh	x0, [x3, #BE(6)]
 	b	99f
+	nop
 29:	brk	#1000			/* reserved */
 	nop
-30:	ldrsw	x0, [x3, #BE(4)]	/* SINT32 */
+	nop
+	nop
+30:	BTI_J				/* SINT32 */
+	ldrsw	x0, [x3, #BE(4)]
+	nop
 	nop
 31:					/* reserved */
 99:	ldp     x29, x30, [sp], #ffi_closure_SYSV_FS
@@ -391,6 +527,7 @@ L(do_closure):
 #if defined(FFI_EXEC_STATIC_TRAMP)
 	.align 4
 CNAME(ffi_closure_SYSV_V_alt):
+	BTI_C
 	/* See the comments above trampoline_code_table. */
 	ldr	x17, [sp, #8]			/* Load closure in x17 */
 	add	sp, sp, #16			/* Restore the stack */
@@ -405,6 +542,7 @@ CNAME(ffi_closure_SYSV_V_alt):
 
 	.align 4
 CNAME(ffi_closure_SYSV_alt):
+	BTI_C
 	/* See the comments above trampoline_code_table. */
 	ldr	x17, [sp, #8]			/* Load closure in x17 */
 	add	sp, sp, #16			/* Restore the stack */
@@ -485,6 +623,7 @@ CNAME(ffi_closure_trampoline_table_page):
 	.align 4
 CNAME(ffi_go_closure_SYSV_V):
 	cfi_startproc
+	BTI_C
 	stp     x29, x30, [sp, #-ffi_closure_SYSV_FS]!
 	cfi_adjust_cfa_offset (ffi_closure_SYSV_FS)
 	cfi_rel_offset (x29, 0)
@@ -508,6 +647,7 @@ CNAME(ffi_go_closure_SYSV_V):
 	.align	4
 	cfi_startproc
 CNAME(ffi_go_closure_SYSV):
+	BTI_C
 	stp     x29, x30, [sp, #-ffi_closure_SYSV_FS]!
 	cfi_adjust_cfa_offset (ffi_closure_SYSV_FS)
 	cfi_rel_offset (x29, 0)
@@ -539,5 +679,17 @@ CNAME(ffi_go_closure_SYSV):
 
 #if defined __ELF__ && defined __linux__
 	.section .note.GNU-stack,"",%progbits
+
+	.pushsection .note.gnu.property, "a";
+	.balign 8;
+	.long 4;
+	.long 0x10;
+	.long 0x5;
+	.asciz "GNU";
+	.long 0xc0000000; /* GNU_PROPERTY_AARCH64_FEATURE_1_AND */
+	.long 4;
+	.long GNU_PROPERTY_AARCH64_BTI;
+	.long 0;
+	.popsection;
 #endif
 

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

@@ -599,7 +599,7 @@ open_temp_exec_file_memfd (const char *name)
 
 /* Open a temporary file name, and immediately unlink it.  */
 static int
-open_temp_exec_file_name (char *name, int flags)
+open_temp_exec_file_name (char *name, int flags MAYBE_UNUSED)
 {
   int fd;
 
@@ -795,7 +795,7 @@ open_temp_exec_file (void)
    Failure to allocate the space will cause SIGBUS to be thrown when
    the mapping is subsequently written to.  */
 static int
-allocate_space (int fd, off_t offset, off_t len)
+allocate_space (int fd, off_t len)
 {
   static long page_size;
 
@@ -838,7 +838,7 @@ dlmmap_locked (void *start, size_t length, int prot, int flags, off_t offset)
 
   offset = execsize;
 
-  if (allocate_space (execfd, offset, length))
+  if (allocate_space (execfd, length))
     return MFAIL;
 
   flags &= ~(MAP_PRIVATE | MAP_ANONYMOUS);

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

@@ -38,7 +38,7 @@ void ffi_stop_here(void)
 
 /* This function should only be called via the FFI_ASSERT() macro */
 
-void ffi_assert(char *expr, char *file, int line)
+NORETURN void ffi_assert(const char *expr, const char *file, int line)
 {
   fprintf(stderr, "ASSERTION FAILURE: %s at %s:%d\n", expr, file, line);
   ffi_stop_here();
@@ -47,7 +47,7 @@ void ffi_assert(char *expr, char *file, int line)
 
 /* Perform a sanity check on an ffi_type structure */
 
-void ffi_type_test(ffi_type *a, char *file, int line)
+void ffi_type_test(ffi_type *a, const char *file, int line)
 {
   FFI_ASSERT_AT(a != NULL, file, line);
 

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

@@ -4452,7 +4452,7 @@ struct mallinfo dlmallinfo(void) {
 }
 #endif /* NO_MALLINFO */
 
-void dlmalloc_stats() {
+void dlmalloc_stats(void) {
   internal_malloc_stats(gm);
 }
 

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

@@ -28,6 +28,7 @@
 
 #include <ffi.h>
 #include <ffi_common.h>
+#include <tramp.h>
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -58,7 +59,9 @@
 */
 typedef struct call_context
 {
+#if !defined(__loongarch_soft_float)
   ABI_FLOAT fa[8];
+#endif
   size_t a[10];
 } call_context;
 

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

@@ -647,9 +647,9 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 
       case FFI_TYPE_POINTER:
 	if (cif->abi == FFI_N32_SOFT_FLOAT || cif->abi == FFI_N32)
-	  cif->flags += FFI_TYPE_UINT32 << (FFI_FLAG_BITS * 8);
+	  cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
 	else
-	  cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
+	  cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 8);
 	break;
 
       case FFI_TYPE_FLOAT:
@@ -661,7 +661,7 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 	/* else fall through */
       case FFI_TYPE_DOUBLE:
 	if (soft_float)
-	  cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
+	  cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 8);
 	else
 	  cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 8);
 	break;
@@ -715,8 +715,16 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 	    }
 	  break;
 	}
+      case FFI_TYPE_UINT32:
+	/* In the N32 or N64 ABI unsigned 32-bit integer should be
+	   *sign*-extended.  */
+	cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
+	break;
+      case FFI_TYPE_SINT64:
+	cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 8);
+	break;
       default:
-	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
+	cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 8);
 	break;
       }
   }

data/ext/ffi_c/libffi/src/mips/n32.S

@@ -236,19 +236,54 @@ callit:
 	# Shift the return type flag over
 	SRL	t6, 8*FFI_FLAG_BITS
 
-	beq	t6, FFI_TYPE_SINT32, retint
-	bne     t6, FFI_TYPE_INT, retuint32
-retint:
+	bne     t6, FFI_TYPE_UINT64, retsint32
+
+retuint64:
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
-	REG_S	v0, 0(t4)
+	sd	v0, 0(t4)
 	b	epilogue
 
-retuint32:
-	bne     t6, FFI_TYPE_UINT32, retfloat
+retsint32:
+	bne	t6, FFI_TYPE_SINT32, retuint16
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
-	sw	v0, 0(t4)
+	sll	v0, v0, 0
+	sd	v0, 0(t4)
+	b	epilogue
+
+retuint16:
+	bne	t6, FFI_TYPE_UINT16, retsint16
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	andi	v0, v0, 0xffff
+	sd	v0, 0(t4)
+	b	epilogue
+
+retsint16:
+	bne	t6, FFI_TYPE_SINT16, retuint8
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	dsll	v0, v0, 48
+	dsra	v0, v0, 48
+	sd	v0, 0(t4)
+	b	epilogue
+
+retuint8:
+	bne	t6, FFI_TYPE_UINT8, retsint8
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	andi	v0, v0, 0xff
+	sd	v0, 0(t4)
+	b	epilogue
+
+retsint8:
+	bne	t6, FFI_TYPE_SINT8, retfloat
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	sd	v0, 0(t4)
+	dsll	v0, v0, 56
+	dsra	v0, v0, 56
 	b	epilogue
 
 retfloat:
@@ -585,19 +620,35 @@ $do_closure:
 
 	jalr	t9
 
+cls_retuint64:
 	# Return flags are in v0
-	bne     v0, FFI_TYPE_SINT32, cls_retuint32
+	bne     v0, FFI_TYPE_UINT64, cls_retsint32
+	ld	v0, V0_OFF2($sp)
+	b	cls_epilogue
+
+cls_retsint32:
+	bne     v0, FFI_TYPE_SINT32, cls_retsint16
 	lw	v0, V0_OFF2($sp)
 	b	cls_epilogue
 
-cls_retuint32:
-	bne     v0, FFI_TYPE_UINT32, cls_retint
-	lwu	v0, V0_OFF2($sp)
+cls_retsint16:
+	bne     v0, FFI_TYPE_SINT16, cls_retuint16
+	lh	v0, V0_OFF2($sp)
 	b	cls_epilogue
 
-cls_retint:
-	bne     v0, FFI_TYPE_INT, cls_retfloat
-	REG_L	v0, V0_OFF2($sp)
+cls_retuint16:
+	bne     v0, FFI_TYPE_UINT16, cls_retsint8
+	lhu	v0, V0_OFF2($sp)
+	b	cls_epilogue
+
+cls_retsint8:
+	bne     v0, FFI_TYPE_SINT8, cls_retuint8
+	lb	v0, V0_OFF2($sp)
+	b	cls_epilogue
+
+cls_retuint8:
+	bne     v0, FFI_TYPE_UINT8, cls_retfloat
+	lbu	v0, V0_OFF2($sp)
 	b	cls_epilogue
 
 cls_retfloat: