ffi 1.17.2 → 1.17.3

data/ext/ffi_c/libffi/src/{wasm32 → wasm}/ffi.c

@@ -59,16 +59,29 @@ EM_JS_DEPS(libffi, "$getWasmTableEntry,$setWasmTableEntry,$getEmptyTableSlot,$co
     offsetof(struct, field) == offset,                                             \
     "Memory layout of '" #struct "' has changed: '" #field "' is in an unexpected location");
 
+#if __SIZEOF_POINTER__ == 4
+
+#define FFI_EMSCRIPTEN_ABI FFI_WASM32_EMSCRIPTEN
+#define PTR_SIG 'i'
+
+#define DEC_PTR(p) p
+#define ENC_PTR(p) p
+
+#define DEREF_PTR(addr, offset) DEREF_U32(addr, offset)
+#define DEREF_PTR_NUMBER(addr, offset) DEREF_PTR(addr, offset)
+
 CHECK_FIELD_OFFSET(ffi_cif, abi, 4*0);
 CHECK_FIELD_OFFSET(ffi_cif, nargs, 4*1);
 CHECK_FIELD_OFFSET(ffi_cif, arg_types, 4*2);
 CHECK_FIELD_OFFSET(ffi_cif, rtype, 4*3);
+CHECK_FIELD_OFFSET(ffi_cif, flags, 4*5);
 CHECK_FIELD_OFFSET(ffi_cif, nfixedargs, 4*6);
 
 #define CIF__ABI(addr) DEREF_U32(addr, 0)
 #define CIF__NARGS(addr) DEREF_U32(addr, 1)
 #define CIF__ARGTYPES(addr) DEREF_U32(addr, 2)
 #define CIF__RTYPE(addr) DEREF_U32(addr, 3)
+#define CIF__FLAGS(addr) DEREF_U32(addr, 5)
 #define CIF__NFIXEDARGS(addr) DEREF_U32(addr, 6)
 
 CHECK_FIELD_OFFSET(ffi_type, size, 0);
@@ -81,6 +94,49 @@ CHECK_FIELD_OFFSET(ffi_type, elements, 8);
 #define FFI_TYPE__TYPEID(addr) DEREF_U16(addr + 6, 0)
 #define FFI_TYPE__ELEMENTS(addr) DEREF_U32(addr + 8, 0)
 
+#elif __SIZEOF_POINTER__ == 8
+
+#define FFI_EMSCRIPTEN_ABI FFI_WASM64_EMSCRIPTEN
+#define PTR_SIG 'j'
+
+// DEC_PTR casts a pointer value (comming from Wasm) represented as BigInt (i64) to Number (i53).
+// This should be used for a pointer that is expected to be within the i53 range. If the pointer
+// value is outside the Number's range, the value will become NaN.
+#define DEC_PTR(p) bigintToI53Checked(p)
+// ENC_PTR casts a pointer value represented as Number to BigInt (i64)
+#define ENC_PTR(p) BigInt(p)
+
+#define DEREF_PTR(addr, offset) DEREF_U64(addr, offset)
+#define DEREF_PTR_NUMBER(addr, offset) DEC_PTR(DEREF_PTR(addr, offset))
+
+CHECK_FIELD_OFFSET(ffi_cif, abi, 0);
+CHECK_FIELD_OFFSET(ffi_cif, nargs, 4);
+CHECK_FIELD_OFFSET(ffi_cif, arg_types, 8);
+CHECK_FIELD_OFFSET(ffi_cif, rtype, 16);
+CHECK_FIELD_OFFSET(ffi_cif, flags, 28);
+CHECK_FIELD_OFFSET(ffi_cif, nfixedargs, 32);
+
+#define CIF__ABI(addr) DEREF_U32(addr, 0)
+#define CIF__NARGS(addr) DEREF_U32(addr + 4,  0)
+#define CIF__ARGTYPES(addr) DEREF_U64(addr + 8,  0)
+#define CIF__RTYPE(addr) DEREF_U64(addr + 16, 0)
+#define CIF__FLAGS(addr) DEREF_U32(addr + 28, 0)
+#define CIF__NFIXEDARGS(addr) DEREF_U32(addr + 32, 0)
+
+CHECK_FIELD_OFFSET(ffi_type, size, 0);
+CHECK_FIELD_OFFSET(ffi_type, alignment, 8);
+CHECK_FIELD_OFFSET(ffi_type, type, 10);
+CHECK_FIELD_OFFSET(ffi_type, elements, 16);
+
+#define FFI_TYPE__SIZE(addr) DEREF_U64(addr, 0)
+#define FFI_TYPE__ALIGN(addr) DEREF_U16(addr + 8, 0)
+#define FFI_TYPE__TYPEID(addr) DEREF_U16(addr + 10, 0)
+#define FFI_TYPE__ELEMENTS(addr) DEREF_U64(addr + 16, 0)
+
+#else
+#error "Unknown pointer size"
+#endif
+
 #define ALIGN_ADDRESS(addr, align) (addr &= (~((align) - 1)))
 #define STACK_ALLOC(stack, size, align) ((stack -= (size)), ALIGN_ADDRESS(stack, align))
 
@@ -100,7 +156,7 @@ _Static_assert(FFI_BAD_TYPEDEF_MACRO == FFI_BAD_TYPEDEF, "FFI_BAD_TYPEDEF must b
 ffi_status FFI_HIDDEN
 ffi_prep_cif_machdep(ffi_cif *cif)
 {
-  if (cif->abi != FFI_WASM32_EMSCRIPTEN)
+  if (cif->abi != FFI_EMSCRIPTEN_ABI)
     return FFI_BAD_ABI;
   // This is called after ffi_prep_cif_machdep_var so we need to avoid
   // overwriting cif->nfixedargs.
@@ -144,6 +200,7 @@ ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned nfixedargs, unsigned ntotalargs)
 EM_JS_MACROS(
 void,
 unbox_small_structs, (ffi_type type_ptr), {
+  type_ptr = DEC_PTR(type_ptr);
   var type_id = FFI_TYPE__TYPEID(type_ptr);
   while (type_id === FFI_TYPE_STRUCT) {
     // Don't unbox single element structs if they are bigger than 16 bytes. This
@@ -156,15 +213,15 @@ unbox_small_structs, (ffi_type type_ptr), {
     //
     // See the Python comment here:
     // https://github.com/python/cpython/blob/a16a9f978f42b8a09297c1efbf33877f6388c403/Modules/_ctypes/stgdict.c#L718-L779
-    if (FFI_TYPE__SIZE(type_ptr) > 16) {
+    if (DEC_PTR(FFI_TYPE__SIZE(type_ptr)) > 16) {
       break;
     }
-    var elements = FFI_TYPE__ELEMENTS(type_ptr);
-    var first_element = DEREF_U32(elements, 0);
+    var elements = DEC_PTR(FFI_TYPE__ELEMENTS(type_ptr));
+    var first_element = DEREF_PTR_NUMBER(elements, 0);
     if (first_element === 0) {
       type_id = FFI_TYPE_VOID;
       break;
-    } else if (DEREF_U32(elements, 1) === 0) {
+    } else if (DEREF_PTR_NUMBER(elements, 1) === 0) {
       type_ptr = first_element;
       type_id = FFI_TYPE__TYPEID(first_element);
     } else {
@@ -178,10 +235,15 @@ EM_JS_MACROS(
 void,
 ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
 {
+  cif = DEC_PTR(cif);
+  fn = DEC_PTR(fn);
+  rvalue = DEC_PTR(rvalue);
+  avalue = DEC_PTR(avalue);
   var abi = CIF__ABI(cif);
   var nargs = CIF__NARGS(cif);
   var nfixedargs = CIF__NFIXEDARGS(cif);
-  var arg_types_ptr = CIF__ARGTYPES(cif);
+  var arg_types_ptr = DEC_PTR(CIF__ARGTYPES(cif));
+  var flags = CIF__FLAGS(cif);
   var rtype_unboxed = unbox_small_structs(CIF__RTYPE(cif));
   var rtype_ptr = rtype_unboxed[0];
   var rtype_id = rtype_unboxed[1];
@@ -205,7 +267,7 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
   // just use this. We also mark a flag that we don't need to convert the return
   // value of the dynamic call back to C.
   if (rtype_id === FFI_TYPE_LONGDOUBLE || rtype_id === FFI_TYPE_STRUCT) {
-    args.push(rvalue);
+    args.push(ENC_PTR(rvalue));
     ret_by_arg = true;
   }
 
@@ -214,8 +276,8 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
   // Javascript to C automatically, here we manually do the inverse conversion
   // from C to Javascript.
   for (var i = 0; i < nfixedargs; i++) {
-    var arg_ptr = DEREF_U32(avalue, i);
-    var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
+    var arg_ptr = DEREF_PTR_NUMBER(avalue, i);
+    var arg_unboxed = unbox_small_structs(DEREF_PTR(arg_types_ptr, i));
     var arg_type_ptr = arg_unboxed[0];
     var arg_type_id = arg_unboxed[1];
 
@@ -226,7 +288,6 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
     case FFI_TYPE_INT:
     case FFI_TYPE_SINT32:
     case FFI_TYPE_UINT32:
-    case FFI_TYPE_POINTER:
       args.push(DEREF_U32(arg_ptr, 0));
       break;
     case FFI_TYPE_FLOAT:
@@ -260,11 +321,14 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
       // Nontrivial structs are passed by pointer.
       // Have to copy the struct onto the stack though because C ABI says it's
       // call by value.
-      var size = FFI_TYPE__SIZE(arg_type_ptr);
+      var size = DEC_PTR(FFI_TYPE__SIZE(arg_type_ptr));
       var align = FFI_TYPE__ALIGN(arg_type_ptr);
       STACK_ALLOC(cur_stack_ptr, size, align);
       HEAP8.subarray(cur_stack_ptr, cur_stack_ptr+size).set(HEAP8.subarray(arg_ptr, arg_ptr + size));
-      args.push(cur_stack_ptr);
+      args.push(ENC_PTR(cur_stack_ptr));
+      break;
+    case FFI_TYPE_POINTER:
+      args.push(DEREF_PTR(arg_ptr, 0));
       break;
     case FFI_TYPE_COMPLEX:
       throw new Error('complex marshalling nyi');
@@ -282,11 +346,11 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
   // We don't have any way of knowing how many args were actually passed, so we
   // just always copy extra nonsense past the end. The ownwards call will know
   // not to look at it.
-  if (nfixedargs != nargs) {
+  if (flags & VARARGS_FLAG) {
     var struct_arg_info = [];
     for (var i = nargs - 1;  i >= nfixedargs; i--) {
-      var arg_ptr = DEREF_U32(avalue, i);
-      var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
+      var arg_ptr = DEREF_PTR_NUMBER(avalue, i);
+      var arg_unboxed = unbox_small_structs(DEREF_PTR(arg_types_ptr, i));
       var arg_type_ptr = arg_unboxed[0];
       var arg_type_id = arg_unboxed[1];
       switch (arg_type_id) {
@@ -303,7 +367,6 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
       case FFI_TYPE_INT:
       case FFI_TYPE_UINT32:
       case FFI_TYPE_SINT32:
-      case FFI_TYPE_POINTER:
       case FFI_TYPE_FLOAT:
         STACK_ALLOC(cur_stack_ptr, 4, 4);
         DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
@@ -326,8 +389,12 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
         // Again, struct must be passed by pointer.
         // But ABI is by value, so have to copy struct onto stack.
         // Currently arguments are going onto stack so we can't put it there now. Come back for this.
-        STACK_ALLOC(cur_stack_ptr, 4, 4);
-        struct_arg_info.push([cur_stack_ptr, arg_ptr, FFI_TYPE__SIZE(arg_type_ptr), FFI_TYPE__ALIGN(arg_type_ptr)]);
+        STACK_ALLOC(cur_stack_ptr, __SIZEOF_POINTER__, __SIZEOF_POINTER__);
+        struct_arg_info.push([cur_stack_ptr, arg_ptr, DEC_PTR(FFI_TYPE__SIZE(arg_type_ptr)), FFI_TYPE__ALIGN(arg_type_ptr)]);
+        break;
+      case FFI_TYPE_POINTER:
+        STACK_ALLOC(cur_stack_ptr, __SIZEOF_POINTER__, __SIZEOF_POINTER__);
+        DEREF_PTR(cur_stack_ptr, 0) = DEREF_PTR(arg_ptr, 0);
         break;
       case FFI_TYPE_COMPLEX:
         throw new Error('complex arg marshalling nyi');
@@ -336,7 +403,7 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
       }
     }
     // extra normal argument which is the pointer to the varargs.
-    args.push(cur_stack_ptr);
+    args.push(ENC_PTR(cur_stack_ptr));
     // Now allocate variable struct args on stack too.
     for (var i = 0; i < struct_arg_info.length; i++) {
       var struct_info = struct_arg_info[i];
@@ -346,7 +413,7 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
       var align = struct_info[3];
       STACK_ALLOC(cur_stack_ptr, size, align);
       HEAP8.subarray(cur_stack_ptr, cur_stack_ptr+size).set(HEAP8.subarray(arg_ptr, arg_ptr + size));
-      DEREF_U32(arg_target, 0) = cur_stack_ptr;
+      DEREF_PTR(arg_target, 0) = ENC_PTR(cur_stack_ptr);
     }
   }
   stackRestore(cur_stack_ptr);
@@ -371,7 +438,6 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
   case FFI_TYPE_INT:
   case FFI_TYPE_UINT32:
   case FFI_TYPE_SINT32:
-  case FFI_TYPE_POINTER:
     DEREF_U32(rvalue, 0) = result;
     break;
   case FFI_TYPE_FLOAT:
@@ -392,6 +458,9 @@ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
   case FFI_TYPE_SINT64:
     DEREF_U64(rvalue, 0) = result;
     break;
+  case FFI_TYPE_POINTER:
+    DEREF_PTR(rvalue, 0) = result;
+    break;
   case FFI_TYPE_COMPLEX:
     throw new Error('complex ret marshalling nyi');
   default:
@@ -403,6 +472,8 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) {
   ffi_call_js(cif, fn, rvalue, avalue);
 }
 
+#if __SIZEOF_POINTER__ == 4
+
 CHECK_FIELD_OFFSET(ffi_closure, ftramp, 4*0);
 CHECK_FIELD_OFFSET(ffi_closure, cif, 4*1);
 CHECK_FIELD_OFFSET(ffi_closure, fun, 4*2);
@@ -413,12 +484,30 @@ CHECK_FIELD_OFFSET(ffi_closure, user_data, 4*3);
 #define CLOSURE__fun(addr) DEREF_U32(addr, 2)
 #define CLOSURE__user_data(addr) DEREF_U32(addr, 3)
 
+#elif __SIZEOF_POINTER__ == 8
+
+CHECK_FIELD_OFFSET(ffi_closure, ftramp, 0);
+CHECK_FIELD_OFFSET(ffi_closure, cif, 8);
+CHECK_FIELD_OFFSET(ffi_closure, fun, 16);
+CHECK_FIELD_OFFSET(ffi_closure, user_data, 24);
+
+#define CLOSURE__wrapper(addr) DEREF_U64(addr, 0)
+#define CLOSURE__cif(addr) DEREF_U64(addr, 1)
+#define CLOSURE__fun(addr) DEREF_U64(addr, 2)
+#define CLOSURE__user_data(addr) DEREF_U64(addr, 3)
+
+#else
+#error "Unknown pointer size"
+#endif
+
 EM_JS_MACROS(void *, ffi_closure_alloc_js, (size_t size, void **code), {
+  size = DEC_PTR(size);
+  code = DEC_PTR(code);
   var closure = _malloc(size);
   var index = getEmptyTableSlot();
-  DEREF_U32(code, 0) = index;
-  CLOSURE__wrapper(closure) = index;
-  return closure;
+  DEREF_PTR(code, 0) = ENC_PTR(index);
+  CLOSURE__wrapper(closure) = ENC_PTR(index);
+  return ENC_PTR(closure);
 })
 
 void * __attribute__ ((visibility ("default")))
@@ -427,7 +516,8 @@ ffi_closure_alloc(size_t size, void **code) {
 }
 
 EM_JS_MACROS(void, ffi_closure_free_js, (void *closure), {
-  var index = CLOSURE__wrapper(closure);
+  closure = DEC_PTR(closure);
+  var index = DEC_PTR(CLOSURE__wrapper(closure));
   freeTableIndexes.push(index);
   _free(closure);
 })
@@ -442,10 +532,15 @@ ffi_status,
 ffi_prep_closure_loc_js,
 (ffi_closure *closure, ffi_cif *cif, void *fun, void *user_data, void *codeloc),
 {
+  closure = DEC_PTR(closure);
+  cif = DEC_PTR(cif);
+  fun = DEC_PTR(fun);
+  user_data = DEC_PTR(user_data);
+  codeloc = DEC_PTR(codeloc);
   var abi = CIF__ABI(cif);
   var nargs = CIF__NARGS(cif);
   var nfixedargs = CIF__NFIXEDARGS(cif);
-  var arg_types_ptr = CIF__ARGTYPES(cif);
+  var arg_types_ptr = DEC_PTR(CIF__ARGTYPES(cif));
   var rtype_unboxed = unbox_small_structs(CIF__RTYPE(cif));
   var rtype_ptr = rtype_unboxed[0];
   var rtype_id = rtype_unboxed[1];
@@ -461,7 +556,7 @@ ffi_prep_closure_loc_js,
   case FFI_TYPE_STRUCT:
   case FFI_TYPE_LONGDOUBLE:
     // Return via a first pointer argument.
-    sig = 'vi';
+    sig = 'v' + PTR_SIG;
     ret_by_arg = true;
     break;
   case FFI_TYPE_INT:
@@ -471,7 +566,6 @@ ffi_prep_closure_loc_js,
   case FFI_TYPE_SINT16:
   case FFI_TYPE_UINT32:
   case FFI_TYPE_SINT32:
-  case FFI_TYPE_POINTER:
     sig = 'i';
     break;
   case FFI_TYPE_FLOAT:
@@ -484,6 +578,9 @@ ffi_prep_closure_loc_js,
   case FFI_TYPE_SINT64:
     sig = 'j';
     break;
+  case FFI_TYPE_POINTER:
+    sig = PTR_SIG;
+    break;
   case FFI_TYPE_COMPLEX:
     throw new Error('complex ret marshalling nyi');
   default:
@@ -492,11 +589,11 @@ ffi_prep_closure_loc_js,
   var unboxed_arg_type_id_list = [];
   var unboxed_arg_type_info_list = [];
   for (var i = 0; i < nargs; i++) {
-    var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
+    var arg_unboxed = unbox_small_structs(DEREF_PTR(arg_types_ptr, i));
     var arg_type_ptr = arg_unboxed[0];
     var arg_type_id = arg_unboxed[1];
     unboxed_arg_type_id_list.push(arg_type_id);
-    unboxed_arg_type_info_list.push([FFI_TYPE__SIZE(arg_type_ptr), FFI_TYPE__ALIGN(arg_type_ptr)]);
+    unboxed_arg_type_info_list.push([DEC_PTR(FFI_TYPE__SIZE(arg_type_ptr)), FFI_TYPE__ALIGN(arg_type_ptr)]);
   }
   for (var i = 0; i < nfixedargs; i++) {
     switch (unboxed_arg_type_id_list[i]) {
@@ -507,8 +604,6 @@ ffi_prep_closure_loc_js,
     case FFI_TYPE_SINT16:
     case FFI_TYPE_UINT32:
     case FFI_TYPE_SINT32:
-    case FFI_TYPE_POINTER:
-    case FFI_TYPE_STRUCT:
       sig += 'i';
       break;
     case FFI_TYPE_FLOAT:
@@ -524,6 +619,10 @@ ffi_prep_closure_loc_js,
     case FFI_TYPE_SINT64:
       sig += 'j';
       break;
+    case FFI_TYPE_STRUCT:
+    case FFI_TYPE_POINTER:
+      sig += PTR_SIG;
+      break;
     case FFI_TYPE_COMPLEX:
       throw new Error('complex marshalling nyi');
     default:
@@ -532,7 +631,7 @@ ffi_prep_closure_loc_js,
   }
   if (nfixedargs < nargs) {
     // extra pointer to varargs stack
-    sig += 'i';
+    sig += PTR_SIG;
   }
   LOG_DEBUG("CREATE_CLOSURE", "sig:", sig);
   function trampoline() {
@@ -551,7 +650,7 @@ ffi_prep_closure_loc_js,
       STACK_ALLOC(cur_ptr, 8, 8);
       ret_ptr = cur_ptr;
     }
-    cur_ptr -= 4 * nargs;
+    cur_ptr -= __SIZEOF_POINTER__ * nargs;
     var args_ptr = cur_ptr;
     var carg_idx = 0;
     // Here we either have the actual argument, or a pair of BigInts for long
@@ -572,58 +671,62 @@ ffi_prep_closure_loc_js,
       case FFI_TYPE_SINT8:
         // Bad things happen if we don't align to 4 here
         STACK_ALLOC(cur_ptr, 1, 4);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_U8(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_UINT16:
       case FFI_TYPE_SINT16:
         // Bad things happen if we don't align to 4 here
         STACK_ALLOC(cur_ptr, 2, 4);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_U16(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_INT:
       case FFI_TYPE_UINT32:
       case FFI_TYPE_SINT32:
-      case FFI_TYPE_POINTER:
         STACK_ALLOC(cur_ptr, 4, 4);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_U32(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_STRUCT:
         // cur_arg is already a pointer to struct
         // copy it onto stack to pass by value
         STACK_ALLOC(cur_ptr, arg_size, arg_align);
-        HEAP8.subarray(cur_ptr, cur_ptr + arg_size).set(HEAP8.subarray(cur_arg, cur_arg + arg_size));
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        HEAP8.subarray(cur_ptr, cur_ptr + arg_size).set(HEAP8.subarray(DEC_PTR(cur_arg), DEC_PTR(cur_arg) + arg_size));
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         break;
       case FFI_TYPE_FLOAT:
         STACK_ALLOC(cur_ptr, 4, 4);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_F32(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_DOUBLE:
         STACK_ALLOC(cur_ptr, 8, 8);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_F64(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_UINT64:
       case FFI_TYPE_SINT64:
         STACK_ALLOC(cur_ptr, 8, 8);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_U64(cur_ptr, 0) = cur_arg;
         break;
       case FFI_TYPE_LONGDOUBLE:
         STACK_ALLOC(cur_ptr, 16, 8);
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
         DEREF_U64(cur_ptr, 0) = cur_arg;
         cur_arg = args[jsarg_idx++];
         DEREF_U64(cur_ptr, 1) = cur_arg;
         break;
+      case FFI_TYPE_POINTER:
+        STACK_ALLOC(cur_ptr, __SIZEOF_POINTER__, __SIZEOF_POINTER__);
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
+        DEREF_PTR(cur_ptr, 0) = cur_arg;
+        break;
       }
     }
     // If its a varargs call, last js argument is a pointer to the varargs.
-    var varargs = args[args.length - 1];
+    var varargs = DEC_PTR(args[args.length - 1]);
     // We have no way of knowing how many varargs were actually provided, this
     // fills the rest of the stack space allocated with nonsense. The onward
     // call will know to ignore the nonsense.
@@ -639,20 +742,20 @@ ffi_prep_closure_loc_js,
       if (arg_type_id === FFI_TYPE_STRUCT) {
         // In this case varargs is a pointer to pointer to struct so we need to
         // deref once
-        var struct_ptr = DEREF_U32(varargs, 0);
+        var struct_ptr = DEREF_PTR_NUMBER(varargs, 0);
         STACK_ALLOC(cur_ptr, arg_size, arg_align);
         HEAP8.subarray(cur_ptr, cur_ptr + arg_size).set(HEAP8.subarray(struct_ptr, struct_ptr + arg_size));
-        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(cur_ptr);
       } else {
-        DEREF_U32(args_ptr, carg_idx) = varargs;
+        DEREF_PTR(args_ptr, carg_idx) = ENC_PTR(varargs);
       }
-      varargs += 4;
+      varargs += __SIZEOF_POINTER__;
     }
     stackRestore(cur_ptr);
     stackAlloc(0); // stackAlloc enforces alignment invariants on the stack pointer
     LOG_DEBUG("CALL_CLOSURE", "closure:", closure, "fptr", CLOSURE__fun(closure), "cif", CLOSURE__cif(closure));
     getWasmTableEntry(CLOSURE__fun(closure))(
-        CLOSURE__cif(closure), ret_ptr, args_ptr,
+        CLOSURE__cif(closure), ENC_PTR(ret_ptr), ENC_PTR(args_ptr),
         CLOSURE__user_data(closure)
     );
     stackRestore(orig_stack_ptr);
@@ -677,9 +780,9 @@ ffi_prep_closure_loc_js,
     return FFI_BAD_TYPEDEF_MACRO;
   }
   setWasmTableEntry(codeloc, wasm_trampoline);
-  CLOSURE__cif(closure) = cif;
-  CLOSURE__fun(closure) = fun;
-  CLOSURE__user_data(closure) = user_data;
+  CLOSURE__cif(closure) = ENC_PTR(cif);
+  CLOSURE__fun(closure) = ENC_PTR(fun);
+  CLOSURE__user_data(closure) = ENC_PTR(user_data);
   return FFI_OK_MACRO;
 })
 
@@ -688,7 +791,7 @@ ffi_prep_closure_loc_js,
 ffi_status ffi_prep_closure_loc(ffi_closure *closure, ffi_cif *cif,
                                 void (*fun)(ffi_cif *, void *, void **, void *),
                                 void *user_data, void *codeloc) {
-  if (cif->abi != FFI_WASM32_EMSCRIPTEN)
+  if (cif->abi != FFI_EMSCRIPTEN_ABI)
     return FFI_BAD_ABI;
   return ffi_prep_closure_loc_js(closure, cif, (void *)fun, user_data,
                                      codeloc);

data/ext/ffi_c/libffi/src/{wasm32 → wasm}/ffitarget.h

@@ -42,14 +42,31 @@ typedef void (*ffi_fp)(void);
 
 typedef enum ffi_abi {
   FFI_FIRST_ABI = 0,
+#if __SIZEOF_POINTER__ == 4
   FFI_WASM32, // "raw", no structures, varargs, or closures (not implemented!)
   FFI_WASM32_EMSCRIPTEN, // structures, varargs, and split 64-bit params
+#elif __SIZEOF_POINTER__ == 8
+  FFI_WASM64,
+  FFI_WASM64_EMSCRIPTEN,
+#else
+#error "Unknown pointer size"
+#endif
   FFI_LAST_ABI,
+#if __SIZEOF_POINTER__ == 4
 #ifdef __EMSCRIPTEN__
   FFI_DEFAULT_ABI = FFI_WASM32_EMSCRIPTEN
 #else
   FFI_DEFAULT_ABI = FFI_WASM32
 #endif
+#elif __SIZEOF_POINTER__ == 8
+#ifdef __EMSCRIPTEN__
+  FFI_DEFAULT_ABI = FFI_WASM64_EMSCRIPTEN
+#else
+  FFI_DEFAULT_ABI = FFI_WASM64
+#endif
+#else
+#error "Unknown pointer size"
+#endif
 } ffi_abi;
 
 #define FFI_CLOSURES 1

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

@@ -41,9 +41,6 @@
 
 #if defined (X86_64) && defined (__i386__)
 #undef X86_64
-#warning ******************************************************
-#warning ********** X86 IS DEFINED ****************************
-#warning ******************************************************
 #define X86
 #endif
 

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

@@ -458,9 +458,7 @@ L(UW24):
 L(UW25):
 	# cfi_def_cfa_offset(closure_FS + 4)
 	FFI_CLOSURE_SAVE_REGS
-	movl	closure_FS-4(%esp), %ecx	/* load retaddr */
-	movl	closure_FS(%esp), %eax		/* load closure */
-	movl	%ecx, closure_FS(%esp)		/* move retaddr */
+	movl	closure_FS-4(%esp), %eax	/* load closure */
 	jmp	L(do_closure_REGISTER)
 L(UW26):
 	# cfi_endproc

data/ext/ffi_c/libffi/src/x86/sysv_intel.S

@@ -394,9 +394,7 @@ L(UW24):
 L(UW25):
 	/* cfi_def_cfa_offset(closure_FS + 4) */
 	FFI_CLOSURE_SAVE_REGS
-	mov	ecx, [esp+closure_FS-4] 	/* load retaddr */
-	mov	eax, [esp+closure_FS]		/* load closure */
-	mov	[esp+closure_FS], ecx		/* move retaddr */
+	mov	eax, [esp+closure_FS-4] 	/* load closure */
 	jmp	L(do_closure_REGISTER)
 L(UW26):
 	/* cfi_endproc */

data/ext/ffi_c/libffi/testsuite/Makefile.am

@@ -31,7 +31,7 @@ EXTRA_DIST = config/default.exp emscripten/build.sh emscripten/conftest.py \
 	libffi.call/struct9.c libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c \
 	libffi.call/struct_by_value_3f.c libffi.call/struct_by_value_4.c libffi.call/struct_by_value_4f.c \
 	libffi.call/struct_by_value_big.c libffi.call/struct_by_value_small.c libffi.call/struct_return_2H.c \
-	libffi.call/struct_int_float.c \
+	libffi.call/struct_int_float.c libffi.call/longjmp.c \
 	libffi.call/struct_return_8H.c libffi.call/uninitialized.c libffi.call/va_1.c \
 	libffi.call/va_2.c libffi.call/va_3.c libffi.call/va_struct1.c \
 	libffi.call/va_struct2.c libffi.call/va_struct3.c libffi.call/callback.c \
@@ -85,4 +85,5 @@ EXTRA_DIST = config/default.exp emscripten/build.sh emscripten/conftest.py \
 	libffi.complex/return_complex2_float.c libffi.complex/return_complex2_longdouble.c libffi.complex/return_complex_double.c \
 	libffi.complex/return_complex_float.c libffi.complex/return_complex_longdouble.c libffi.go/aa-direct.c \
 	libffi.go/closure1.c libffi.go/ffitest.h libffi.go/go.exp \
-	libffi.go/static-chain.h Makefile.am Makefile.in
+	libffi.go/static-chain.h Makefile.am Makefile.in \
+	libffi.threads/ffitest.h libffi.threads/threads.exp libffi.threads/tsan.c

data/ext/ffi_c/libffi/testsuite/Makefile.in

@@ -174,6 +174,8 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FFI_EXEC_TRAMPOLINE_TABLE = @FFI_EXEC_TRAMPOLINE_TABLE@
+FFI_VERSION_NUMBER = @FFI_VERSION_NUMBER@
+FFI_VERSION_STRING = @FFI_VERSION_STRING@
 FGREP = @FGREP@
 FILECMD = @FILECMD@
 GREP = @GREP@
@@ -224,6 +226,7 @@ TARGET = @TARGET@
 TARGETDIR = @TARGETDIR@
 TARGET_OBJ = @TARGET_OBJ@
 VERSION = @VERSION@
+WASM64_MEMORY64 = @WASM64_MEMORY64@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
@@ -316,7 +319,7 @@ EXTRA_DIST = config/default.exp emscripten/build.sh emscripten/conftest.py \
 	libffi.call/struct9.c libffi.call/struct_by_value_2.c libffi.call/struct_by_value_3.c \
 	libffi.call/struct_by_value_3f.c libffi.call/struct_by_value_4.c libffi.call/struct_by_value_4f.c \
 	libffi.call/struct_by_value_big.c libffi.call/struct_by_value_small.c libffi.call/struct_return_2H.c \
-	libffi.call/struct_int_float.c \
+	libffi.call/struct_int_float.c libffi.call/longjmp.c \
 	libffi.call/struct_return_8H.c libffi.call/uninitialized.c libffi.call/va_1.c \
 	libffi.call/va_2.c libffi.call/va_3.c libffi.call/va_struct1.c \
 	libffi.call/va_struct2.c libffi.call/va_struct3.c libffi.call/callback.c \
@@ -370,7 +373,8 @@ EXTRA_DIST = config/default.exp emscripten/build.sh emscripten/conftest.py \
 	libffi.complex/return_complex2_float.c libffi.complex/return_complex2_longdouble.c libffi.complex/return_complex_double.c \
 	libffi.complex/return_complex_float.c libffi.complex/return_complex_longdouble.c libffi.go/aa-direct.c \
 	libffi.go/closure1.c libffi.go/ffitest.h libffi.go/go.exp \
-	libffi.go/static-chain.h Makefile.am Makefile.in
+	libffi.go/static-chain.h Makefile.am Makefile.in \
+	libffi.threads/ffitest.h libffi.threads/threads.exp libffi.threads/tsan.c
 
 all: all-am
 

data/ext/ffi_c/libffi/testsuite/emscripten/build.sh

@@ -36,11 +36,11 @@ export PKG_CONFIG_PATH="$TARGET/lib/pkgconfig"
 export EM_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
 
 # Specific variables for cross-compilation
-export CHOST="wasm32-unknown-linux" # wasm32-unknown-emscripten
+export CHOST="${TARGET_HOST}-unknown-linux" # wasm32-unknown-emscripten
 
 autoreconf -fiv
 emconfigure ./configure --host=$CHOST --prefix="$TARGET" --enable-static --disable-shared --disable-dependency-tracking \
-  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs
+  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs ${EXTRA_CONFIGURE_FLAGS}
 make install
 cp fficonfig.h target/include/
 cp include/ffi_common.h target/include/

data/ext/ffi_c/libffi/testsuite/emscripten/node-tests.sh

@@ -8,16 +8,16 @@ fi
 # Common compiler flags
 export CFLAGS="-fPIC $EXTRA_CFLAGS"
 export CXXFLAGS="$CFLAGS -sNO_DISABLE_EXCEPTION_CATCHING $EXTRA_CXXFLAGS"
-export LDFLAGS="-sEXPORTED_FUNCTIONS=_main,_malloc,_free -sALLOW_TABLE_GROWTH -sASSERTIONS -sNO_DISABLE_EXCEPTION_CATCHING -sWASM_BIGINT"
+export LDFLAGS="-sEXPORTED_FUNCTIONS=_main,_malloc,_free -sALLOW_TABLE_GROWTH -sASSERTIONS -sNO_DISABLE_EXCEPTION_CATCHING -sWASM_BIGINT -Wno-main"
 
 # Specific variables for cross-compilation
-export CHOST="wasm32-unknown-linux" # wasm32-unknown-emscripten
+export CHOST="${TARGET_HOST}-unknown-linux" # wasm32-unknown-emscripten
 
 autoreconf -fiv
 emconfigure ./configure --prefix="$(pwd)/target" --host=$CHOST --enable-static --disable-shared \
-  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs ||
+  --disable-builddir --disable-multi-os-directory --disable-raw-api --disable-docs ${EXTRA_CONFIGURE_FLAGS} ||
   (cat config.log && exit 1)
 make
 
 EMMAKEN_JUST_CONFIGURE=1 emmake make check \
-  RUNTESTFLAGS="LDFLAGS_FOR_TARGET='$LDFLAGS'" || (cat testsuite/libffi.log && exit 1)
+  RUNTESTFLAGS="LDFLAGS_FOR_TARGET='$LDFLAGS $EXTRA_TEST_LDFLAGS'" || (cat testsuite/libffi.log && exit 1)