ffi 1.1.2 → 1.17.0

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

@@ -0,0 +1,947 @@
+/* -----------------------------------------------------------------------
+   ffi.c - Copyright (c) 2018-2023  Hood Chatham, Brion Vibber, Kleis Auke Wolthuizen, and others.
+
+   wasm32/emscripten 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>
+#include <stdint.h>
+
+#include <emscripten/emscripten.h>
+
+#ifdef DEBUG_F
+#define LOG_DEBUG(args...)  \
+  console.warn(`====LIBFFI(line __LINE__)`, args)
+#else
+#define LOG_DEBUG(args...) 0
+#endif
+
+#define EM_JS_MACROS(ret, name, args, body...) EM_JS(ret, name, args, body)
+
+#if WASM_BIGINT
+EM_JS_DEPS(libffi, "$getWasmTableEntry,$setWasmTableEntry,$getEmptyTableSlot,$convertJsFunctionToWasm");
+#define CALL_FUNCTION_POINTER(ptr, args...) \
+  (LOG_DEBUG("CALL_FUNC_PTR", ptr, args),   \
+  getWasmTableEntry(ptr).apply(null, args))
+
+#define JS_FUNCTION_TO_WASM convertJsFunctionToWasm
+#else
+EM_JS_DEPS(libffi, "$getWasmTableEntry,$setWasmTableEntry,$getEmptyTableSlot,$convertJsFunctionToWasm,$dynCall,$generateFuncType,$uleb128Encode");
+#define CALL_FUNCTION_POINTER(ptr, args...)     \
+  (LOG_DEBUG("CALL_FUNC_PTR", sig, ptr, args),  \
+  dynCall(sig, ptr, args))
+
+#define JS_FUNCTION_TO_WASM createLegalizerWrapper
+#endif
+
+// Signature calculations are not needed if WASM_BIGINT is present.
+#if WASM_BIGINT
+#define SIG(sig)
+#else
+#define SIG(sig) sig
+#endif
+
+#define DEREF_U8(addr, offset) HEAPU8[addr + offset]
+#define DEREF_S8(addr, offset) HEAP8[addr + offset]
+#define DEREF_U16(addr, offset) HEAPU16[(addr >> 1) + offset]
+#define DEREF_S16(addr, offset) HEAP16[(addr >> 1) + offset]
+#define DEREF_U32(addr, offset) HEAPU32[(addr >> 2) + offset]
+#define DEREF_S32(addr, offset) HEAP32[(addr >> 2) + offset]
+
+#define DEREF_F32(addr, offset) HEAPF32[(addr >> 2) + offset]
+#define DEREF_F64(addr, offset) HEAPF64[(addr >> 3) + offset]
+
+#if WASM_BIGINT
+// We have HEAPU64 in this case.
+#define DEREF_U64(addr, offset) HEAPU64[(addr >> 3) + offset]
+#endif
+
+
+#define CHECK_FIELD_OFFSET(struct, field, offset)                                  \
+  _Static_assert(                                                                  \
+    offsetof(struct, field) == offset,                                             \
+    "Memory layout of '" #struct "' has changed: '" #field "' is in an unexpected location");
+
+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, 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__NFIXEDARGS(addr) DEREF_U32(addr, 6)
+
+CHECK_FIELD_OFFSET(ffi_type, size, 0);
+CHECK_FIELD_OFFSET(ffi_type, alignment, 4);
+CHECK_FIELD_OFFSET(ffi_type, type, 6);
+CHECK_FIELD_OFFSET(ffi_type, elements, 8);
+
+#define FFI_TYPE__SIZE(addr) DEREF_U32(addr, 0)
+#define FFI_TYPE__ALIGN(addr) DEREF_U16(addr + 4, 0)
+#define FFI_TYPE__TYPEID(addr) DEREF_U16(addr + 6, 0)
+#define FFI_TYPE__ELEMENTS(addr) DEREF_U32(addr + 8, 0)
+
+#define ALIGN_ADDRESS(addr, align) (addr &= (~((align) - 1)))
+#define STACK_ALLOC(stack, size, align) ((stack -= (size)), ALIGN_ADDRESS(stack, align))
+
+// Most wasm runtimes support at most 1000 Js trampoline args.
+#define MAX_ARGS 1000
+
+#include <stddef.h>
+
+#define VARARGS_FLAG 1
+
+#define FFI_OK_MACRO 0
+_Static_assert(FFI_OK_MACRO == FFI_OK, "FFI_OK must be 0");
+
+#define FFI_BAD_TYPEDEF_MACRO 1
+_Static_assert(FFI_BAD_TYPEDEF_MACRO == FFI_BAD_TYPEDEF, "FFI_BAD_TYPEDEF must be 1");
+
+ffi_status FFI_HIDDEN
+ffi_prep_cif_machdep(ffi_cif *cif)
+{
+  if (cif->abi != FFI_WASM32_EMSCRIPTEN)
+    return FFI_BAD_ABI;
+  // This is called after ffi_prep_cif_machdep_var so we need to avoid
+  // overwriting cif->nfixedargs.
+  if (!(cif->flags & VARARGS_FLAG))
+    cif->nfixedargs = cif->nargs;
+  if (cif->nargs > MAX_ARGS)
+    return FFI_BAD_TYPEDEF;
+  if (cif->rtype->type == FFI_TYPE_COMPLEX)
+    return FFI_BAD_TYPEDEF;
+  // If they put the COMPLEX type into a struct we won't notice, but whatever.
+  for (int i = 0; i < cif->nargs; i++)
+    if (cif->arg_types[i]->type == FFI_TYPE_COMPLEX)
+      return FFI_BAD_TYPEDEF;
+  return FFI_OK;
+}
+
+ffi_status FFI_HIDDEN
+ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned nfixedargs, unsigned ntotalargs)
+{
+  cif->flags |= VARARGS_FLAG;
+  cif->nfixedargs = nfixedargs;
+  // The varargs takes up one extra argument
+  if (cif->nfixedargs + 1 > MAX_ARGS)
+    return FFI_BAD_TYPEDEF;
+  return FFI_OK;
+}
+
+/**
+ * A Javascript helper function. This takes an argument typ which is a wasm
+ * pointer to an ffi_type object. It returns a pair a type and a type id.
+ *
+ *    - If it is not a struct, return its type and its typeid field.
+ *    - If it is a struct of size >= 2, return the type and its typeid (which
+ *      will be FFI_TYPE_STRUCT)
+ *    - If it is a struct of size 0, return FFI_TYPE_VOID (????? this is broken)
+ *    - If it is a struct of size 1, replace it with the single field and apply
+ *      the same logic again to that.
+ *
+ * By always unboxing structs up front, we can avoid messy casework later.
+ */
+EM_JS_MACROS(
+void,
+unbox_small_structs, (ffi_type 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
+    // is a work around for the fact that Python will give incorrect values for
+    // the size of the field in these cases: it says that the struct has pointer
+    // size and alignment and are of type pointer, even though it is more
+    // accurately a struct and has a larger size. Keeping it as a struct here
+    // will let us get the ABI right (which is in fact that the true argument is
+    // a pointer to the stack... so maybe Python issn't so wrong??)
+    //
+    // 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) {
+      break;
+    }
+    var elements = FFI_TYPE__ELEMENTS(type_ptr);
+    var first_element = DEREF_U32(elements, 0);
+    if (first_element === 0) {
+      type_id = FFI_TYPE_VOID;
+      break;
+    } else if (DEREF_U32(elements, 1) === 0) {
+      type_ptr = first_element;
+      type_id = FFI_TYPE__TYPEID(first_element);
+    } else {
+      break;
+    }
+  }
+  return [type_ptr, type_id];
+})
+
+EM_JS_MACROS(
+void,
+ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
+{
+  var abi = CIF__ABI(cif);
+  var nargs = CIF__NARGS(cif);
+  var nfixedargs = CIF__NFIXEDARGS(cif);
+  var arg_types_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];
+  var orig_stack_ptr = stackSave();
+  var cur_stack_ptr = orig_stack_ptr;
+
+  var args = [];
+  // Does our onwards call return by argument or normally? We return by argument
+  // no matter what.
+  var ret_by_arg = false;
+
+  if (rtype_id === FFI_TYPE_COMPLEX) {
+    throw new Error('complex ret marshalling nyi');
+  }
+  if (rtype_id < 0 || rtype_id > FFI_TYPE_LAST) {
+    throw new Error('Unexpected rtype ' + rtype_id);
+  }
+  // If the return type is a struct with multiple entries or a long double, the
+  // function takes an extra first argument which is a pointer to return value.
+  // Conveniently, we've already received a pointer to return value, so we can
+  // 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);
+    ret_by_arg = true;
+  }
+
+  SIG(var sig = "");
+
+#if !WASM_BIGINT
+  switch(rtype_id) {
+  case FFI_TYPE_VOID:
+    SIG(sig = 'v');
+    break;
+  case FFI_TYPE_STRUCT:
+  case FFI_TYPE_LONGDOUBLE:
+    SIG(sig = 'vi');
+    break;
+  case FFI_TYPE_INT:
+  case FFI_TYPE_UINT8:
+  case FFI_TYPE_SINT8:
+  case FFI_TYPE_UINT16:
+  case FFI_TYPE_SINT16:
+  case FFI_TYPE_UINT32:
+  case FFI_TYPE_SINT32:
+  case FFI_TYPE_POINTER:
+    SIG(sig = 'i');
+    break;
+  case FFI_TYPE_FLOAT:
+    SIG(sig = 'f');
+    break;
+  case FFI_TYPE_DOUBLE:
+    SIG(sig = 'd');
+    break;
+  case FFI_TYPE_UINT64:
+  case FFI_TYPE_SINT64:
+    SIG(sig = 'j');
+    break;
+  }
+#endif
+
+  // Accumulate a Javascript list of arguments for the Javascript wrapper for
+  // the wasm function. The Javascript wrapper does a type conversion from
+  // 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_type_ptr = arg_unboxed[0];
+    var arg_type_id = arg_unboxed[1];
+
+    // It's okay here to always use unsigned integers as long as the size is 32
+    // or 64 bits. Smaller sizes get extended to 32 bits differently according
+    // to whether they are signed or unsigned.
+    switch (arg_type_id) {
+    case FFI_TYPE_INT:
+    case FFI_TYPE_SINT32:
+    case FFI_TYPE_UINT32:
+    case FFI_TYPE_POINTER:
+      args.push(DEREF_U32(arg_ptr, 0));
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_FLOAT:
+      args.push(DEREF_F32(arg_ptr, 0));
+      SIG(sig += 'f');
+      break;
+    case FFI_TYPE_DOUBLE:
+      args.push(DEREF_F64(arg_ptr, 0));
+      SIG(sig += 'd');
+      break;
+    case FFI_TYPE_UINT8:
+      args.push(DEREF_U8(arg_ptr, 0));
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_SINT8:
+      args.push(DEREF_S8(arg_ptr, 0));
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_UINT16:
+      args.push(DEREF_U16(arg_ptr, 0));
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_SINT16:
+      args.push(DEREF_S16(arg_ptr, 0));
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_UINT64:
+    case FFI_TYPE_SINT64:
+      #if WASM_BIGINT
+      args.push(DEREF_U64(arg_ptr, 0));
+      #else
+      args.push(DEREF_U32(arg_ptr, 0));
+      args.push(DEREF_U32(arg_ptr, 1));
+      #endif
+      SIG(sig += 'j');
+      break;
+    case FFI_TYPE_LONGDOUBLE:
+      // long double is passed as a pair of BigInts.
+      #if WASM_BIGINT
+      args.push(DEREF_U64(arg_ptr, 0));
+      args.push(DEREF_U64(arg_ptr, 1));
+      #else
+      args.push(DEREF_U32(arg_ptr, 0));
+      args.push(DEREF_U32(arg_ptr, 1));
+      args.push(DEREF_U32(arg_ptr, 2));
+      args.push(DEREF_U32(arg_ptr, 3));
+      #endif
+      SIG(sig += "jj");
+      break;
+    case FFI_TYPE_STRUCT:
+      // 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 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);
+      SIG(sig += 'i');
+      break;
+    case FFI_TYPE_COMPLEX:
+      throw new Error('complex marshalling nyi');
+    default:
+      throw new Error('Unexpected type ' + arg_type_id);
+    }
+  }
+
+  // Wasm functions can't directly manipulate the callstack, so varargs
+  // arguments have to go on a separate stack. A varags function takes one extra
+  // argument which is a pointer to where on the separate stack the args are
+  // located. Because stacks are allocated backwards, we have to loop over the
+  // varargs backwards.
+  //
+  // 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) {
+    SIG(sig += 'i');
+    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_type_ptr = arg_unboxed[0];
+      var arg_type_id = arg_unboxed[1];
+      switch (arg_type_id) {
+      case FFI_TYPE_UINT8:
+      case FFI_TYPE_SINT8:
+        STACK_ALLOC(cur_stack_ptr, 1, 1);
+        DEREF_U8(cur_stack_ptr, 0) = DEREF_U8(arg_ptr, 0);
+        break;
+      case FFI_TYPE_UINT16:
+      case FFI_TYPE_SINT16:
+        STACK_ALLOC(cur_stack_ptr, 2, 2);
+        DEREF_U16(cur_stack_ptr, 0) = DEREF_U16(arg_ptr, 0);
+        break;
+      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);
+        break;
+      case FFI_TYPE_DOUBLE:
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+        STACK_ALLOC(cur_stack_ptr, 8, 8);
+        DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
+        DEREF_U32(cur_stack_ptr, 1) = DEREF_U32(arg_ptr, 1);
+        break;
+      case FFI_TYPE_LONGDOUBLE:
+        STACK_ALLOC(cur_stack_ptr, 16, 8);
+        DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
+        DEREF_U32(cur_stack_ptr, 1) = DEREF_U32(arg_ptr, 1);
+        DEREF_U32(cur_stack_ptr, 2) = DEREF_U32(arg_ptr, 2);
+        DEREF_U32(cur_stack_ptr, 3) = DEREF_U32(arg_ptr, 3);
+        break;
+      case FFI_TYPE_STRUCT:
+        // 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)]);
+        break;
+      case FFI_TYPE_COMPLEX:
+        throw new Error('complex arg marshalling nyi');
+      default:
+        throw new Error('Unexpected argtype ' + arg_type_id);
+      }
+    }
+    // extra normal argument which is the pointer to the varargs.
+    args.push(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];
+      var arg_target = struct_info[0];
+      var arg_ptr = struct_info[1];
+      var size = struct_info[2];
+      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;
+    }
+  }
+  stackRestore(cur_stack_ptr);
+  stackAlloc(0); // stackAlloc enforces alignment invariants on the stack pointer
+  var result = CALL_FUNCTION_POINTER(fn, args);
+  // Put the stack pointer back (we moved it if there were any struct args or we
+  // made a varargs call)
+  stackRestore(orig_stack_ptr);
+
+  // We need to return by argument. If return value was a nontrivial struct or
+  // long double, the onwards call already put the return value in rvalue
+  if (ret_by_arg) {
+    return;
+  }
+
+  // Otherwise the result was automatically converted from C into Javascript and
+  // we need to manually convert it back to C.
+  switch (rtype_id) {
+  case FFI_TYPE_VOID:
+    break;
+  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:
+    DEREF_F32(rvalue, 0) = result;
+    break;
+  case FFI_TYPE_DOUBLE:
+    DEREF_F64(rvalue, 0) = result;
+    break;
+  case FFI_TYPE_UINT8:
+  case FFI_TYPE_SINT8:
+    DEREF_U8(rvalue, 0) = result;
+    break;
+  case FFI_TYPE_UINT16:
+  case FFI_TYPE_SINT16:
+    DEREF_U16(rvalue, 0) = result;
+    break;
+  case FFI_TYPE_UINT64:
+  case FFI_TYPE_SINT64:
+    #if WASM_BIGINT
+    DEREF_U64(rvalue, 0) = result;
+    #else
+    DEREF_U32(rvalue, 0) = result;
+    DEREF_U32(rvalue, 1) = getTempRet0();
+    #endif
+    break;
+  case FFI_TYPE_COMPLEX:
+    throw new Error('complex ret marshalling nyi');
+  default:
+    throw new Error('Unexpected rtype ' + rtype_id);
+  }
+});
+
+void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) {
+  ffi_call_js(cif, fn, rvalue, avalue);
+}
+
+CHECK_FIELD_OFFSET(ffi_closure, ftramp, 4*0);
+CHECK_FIELD_OFFSET(ffi_closure, cif, 4*1);
+CHECK_FIELD_OFFSET(ffi_closure, fun, 4*2);
+CHECK_FIELD_OFFSET(ffi_closure, user_data, 4*3);
+
+#define CLOSURE__wrapper(addr) DEREF_U32(addr, 0)
+#define CLOSURE__cif(addr) DEREF_U32(addr, 1)
+#define CLOSURE__fun(addr) DEREF_U32(addr, 2)
+#define CLOSURE__user_data(addr) DEREF_U32(addr, 3)
+
+EM_JS_MACROS(void *, ffi_closure_alloc_js, (size_t size, void **code), {
+  var closure = _malloc(size);
+  var index = getEmptyTableSlot();
+  DEREF_U32(code, 0) = index;
+  CLOSURE__wrapper(closure) = index;
+  return closure;
+})
+
+void * __attribute__ ((visibility ("default")))
+ffi_closure_alloc(size_t size, void **code) {
+  return ffi_closure_alloc_js(size, code);
+}
+
+EM_JS_MACROS(void, ffi_closure_free_js, (void *closure), {
+  var index = CLOSURE__wrapper(closure);
+  freeTableIndexes.push(index);
+  _free(closure);
+})
+
+void __attribute__ ((visibility ("default")))
+ffi_closure_free(void *closure) {
+  return ffi_closure_free_js(closure);
+}
+
+#if !WASM_BIGINT
+
+// When !WASM_BIGINT, we assume there is no JS bigint integration, so JavaScript
+// functions cannot take 64 bit integer arguments.
+//
+// We need to make our own wasm legalizer adaptor that splits 64 bit integer
+// arguments and then calls the JavaScript trampoline, then the JavaScript
+// trampoline reassembles them, calls the closure, then splits the result (if
+// it's a 64 bit integer) and the adaptor puts it back together.
+//
+// This is basically the reverse of the Emscripten function
+// createDyncallWrapper.
+EM_JS(void, createLegalizerWrapper, (int trampoline, int sig), {
+  if(!sig.includes("j")) {
+    return convertJsFunctionToWasm(trampoline, sig);
+  }
+  var sections = [];
+  var prelude = [
+    0x00, 0x61, 0x73, 0x6d, // magic ("\0asm")
+    0x01, 0x00, 0x00, 0x00, // version: 1
+  ];
+  sections.push(prelude);
+  var wrappersig = [
+    // if return type is j, we will put the upper 32 bits into tempRet0.
+    sig[0].replace("j", "i"),
+    // in the rest of the argument list, one 64 bit integer is legalized into
+    // two 32 bit integers.
+    sig.slice(1).replace(/j/g, "ii"),
+  ].join("");
+
+  var typeSectionBody = [
+    0x03, // number of types = 3
+  ];
+  generateFuncType(wrappersig, typeSectionBody); // The signature of the wrapper we are generating
+  generateFuncType(sig, typeSectionBody); // the signature of the function pointer we will call
+  generateFuncType("i", typeSectionBody); // the signature of getTempRet0
+
+  var typeSection = [0x01 /* Type section code */];
+  uleb128Encode(typeSectionBody.length, typeSection); // length of section in bytes
+  typeSection.push.apply(typeSection, typeSectionBody);
+  sections.push(typeSection);
+
+  var importSection = [
+    0x02, // import section code
+    0x0d, // length of section in bytes
+    0x02, // number of imports = 2
+    // Import the getTempRet0 function, which we will call "r"
+    0x01, 0x65, // name "e"
+    0x01, 0x72, // name "r"
+    0x00, // importing a function
+    0x02, // type 2 = () -> i32
+    // Import the wrapped function, which we will call "f"
+    0x01, 0x65, // name "e"
+    0x01, 0x66, // name "f"
+    0x00, // importing a function
+    0x00, // type 0 = wrappersig
+  ];
+  sections.push(importSection);
+
+  var functionSection = [
+    0x03, // function section code
+    0x02, // length of section in bytes
+    0x01, // number of functions = 1
+    0x01, // type 1 = sig
+  ];
+  sections.push(functionSection);
+
+  var exportSection = [
+    0x07, // export section code
+    0x05, // length of section in bytes
+    0x01, // One export
+    0x01, 0x66, // name "f"
+    0x00, // type: function
+    0x02, // function index 2 = the wrapper function
+  ];
+  sections.push(exportSection);
+
+  var convert_code = [];
+  convert_code.push(0x00); // no local variables (except the arguments)
+
+  function localGet(j) {
+    convert_code.push(0x20); // local.get
+    uleb128Encode(j, convert_code);
+  }
+
+  for (var i = 1; i < sig.length; i++) {
+    if (sig[i] == "j") {
+      localGet(i - 1);
+      convert_code.push(
+        0xa7 // i32.wrap_i64
+      );
+      localGet(i - 1);
+      convert_code.push(
+        0x42, 0x20, // i64.const 32
+        0x88,       // i64.shr_u
+        0xa7        // i32.wrap_i64
+      );
+    } else {
+      localGet(i - 1);
+    }
+  }
+  convert_code.push(
+    0x10, 0x01 // call f
+  );
+  if (sig[0] === "j") {
+    // Need to reassemble a 64 bit integer. Lower 32 bits is on stack. Upper 32
+    // bits we get from getTempRet0
+    convert_code.push(
+      0xad,       // i64.extend_i32_unsigned
+      0x10, 0x00, // Call function 0 (r = getTempRet0)
+      // join lower 32 bits and upper 32 bits
+      0xac,       // i64.extend_i32_signed
+      0x42, 0x20, // i64.const 32
+      0x86,       // i64.shl,
+      0x84        // i64.or
+    );
+  }
+  convert_code.push(0x0b); // end
+
+  var codeBody = [0x01]; // one code
+  uleb128Encode(convert_code.length, codeBody);
+  codeBody.push.apply(codeBody, convert_code);
+  var codeSection = [0x0a /* Code section code */];
+  uleb128Encode(codeBody.length, codeSection);
+  codeSection.push.apply(codeSection, codeBody);
+  sections.push(codeSection);
+
+  var bytes = new Uint8Array([].concat.apply([], sections));
+  // We can compile this wasm module synchronously because it is small.
+  var module = new WebAssembly.Module(bytes);
+  var instance = new WebAssembly.Instance(module, {
+    e: {
+      r: getTempRet0,
+      f: trampoline,
+    },
+  });
+  return instance.exports.f;
+});
+#endif
+
+EM_JS_MACROS(
+ffi_status,
+ffi_prep_closure_loc_js,
+(ffi_closure *closure, ffi_cif *cif, void *fun, void *user_data, void *codeloc),
+{
+  var abi = CIF__ABI(cif);
+  var nargs = CIF__NARGS(cif);
+  var nfixedargs = CIF__NFIXEDARGS(cif);
+  var arg_types_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];
+
+  // First construct the signature of the javascript trampoline we are going to create.
+  // Important: this is the signature for calling us, the onward call always has sig viiii.
+  var sig;
+  var ret_by_arg = false;
+  switch (rtype_id) {
+  case FFI_TYPE_VOID:
+    sig = 'v';
+    break;
+  case FFI_TYPE_STRUCT:
+  case FFI_TYPE_LONGDOUBLE:
+    // Return via a first pointer argument.
+    sig = 'vi';
+    ret_by_arg = true;
+    break;
+  case FFI_TYPE_INT:
+  case FFI_TYPE_UINT8:
+  case FFI_TYPE_SINT8:
+  case FFI_TYPE_UINT16:
+  case FFI_TYPE_SINT16:
+  case FFI_TYPE_UINT32:
+  case FFI_TYPE_SINT32:
+  case FFI_TYPE_POINTER:
+    sig = 'i';
+    break;
+  case FFI_TYPE_FLOAT:
+    sig = 'f';
+    break;
+  case FFI_TYPE_DOUBLE:
+    sig = 'd';
+    break;
+  case FFI_TYPE_UINT64:
+  case FFI_TYPE_SINT64:
+    sig = 'j';
+    break;
+  case FFI_TYPE_COMPLEX:
+    throw new Error('complex ret marshalling nyi');
+  default:
+    throw new Error('Unexpected rtype ' + rtype_id);
+  }
+  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_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)]);
+  }
+  for (var i = 0; i < nfixedargs; i++) {
+    switch (unboxed_arg_type_id_list[i]) {
+    case FFI_TYPE_INT:
+    case FFI_TYPE_UINT8:
+    case FFI_TYPE_SINT8:
+    case FFI_TYPE_UINT16:
+    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:
+      sig += 'f';
+      break;
+    case FFI_TYPE_DOUBLE:
+      sig += 'd';
+      break;
+    case FFI_TYPE_LONGDOUBLE:
+      sig += 'jj';
+      break;
+    case FFI_TYPE_UINT64:
+    case FFI_TYPE_SINT64:
+      sig += 'j';
+      break;
+    case FFI_TYPE_COMPLEX:
+      throw new Error('complex marshalling nyi');
+    default:
+      throw new Error('Unexpected argtype ' + arg_type_id);
+    }
+  }
+  if (nfixedargs < nargs) {
+    // extra pointer to varargs stack
+    sig += "i";
+  }
+  LOG_DEBUG("CREATE_CLOSURE",  "sig:", sig);
+  function trampoline() {
+    var args = Array.prototype.slice.call(arguments);
+    var size = 0;
+    var orig_stack_ptr = stackSave();
+    var cur_ptr = orig_stack_ptr;
+    var ret_ptr;
+    var jsarg_idx = 0;
+    // Should we return by argument or not? The onwards call returns by argument
+    // no matter what. (Warning: ret_by_arg means the opposite in ffi_call)
+    if (ret_by_arg) {
+      ret_ptr = args[jsarg_idx++];
+    } else {
+      // We might return 4 bytes or 8 bytes, allocate 8 just in case.
+      STACK_ALLOC(cur_ptr, 8, 8);
+      ret_ptr = cur_ptr;
+    }
+    cur_ptr -= 4 * nargs;
+    var args_ptr = cur_ptr;
+    var carg_idx = 0;
+    // Here we either have the actual argument, or a pair of BigInts for long
+    // double, or a pointer to struct. We have to store into args_ptr[i] a
+    // pointer to the ith argument. If the argument is a struct, just store the
+    // pointer. Otherwise allocate stack space and copy the js argument onto the
+    // stack.
+    for (; carg_idx < nfixedargs; carg_idx++) {
+      // jsarg_idx might start out as 0 or 1 depending on ret_by_arg
+      // it advances an extra time for long double
+      var cur_arg = args[jsarg_idx++];
+      var arg_type_info = unboxed_arg_type_info_list[carg_idx];
+      var arg_size = arg_type_info[0];
+      var arg_align = arg_type_info[1];
+      var arg_type_id = unboxed_arg_type_id_list[carg_idx];
+      switch (arg_type_id) {
+      case FFI_TYPE_UINT8:
+      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_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_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_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;
+        break;
+      case FFI_TYPE_FLOAT:
+        STACK_ALLOC(cur_ptr, 4, 4);
+        DEREF_U32(args_ptr, carg_idx) = 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_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;
+        #if WASM_BIGINT
+        DEREF_U64(cur_ptr, 0) = cur_arg;
+        #else
+        // Bigint arg was split by legalizer adaptor
+        DEREF_U32(cur_ptr, 0) = cur_arg;
+        cur_arg = args[jsarg_idx++];
+        DEREF_U32(cur_ptr, 1) = cur_arg;
+        #endif
+        break;
+      case FFI_TYPE_LONGDOUBLE:
+        STACK_ALLOC(cur_ptr, 16, 8);
+        DEREF_U32(args_ptr, carg_idx) = cur_ptr;
+        #if WASM_BIGINT
+        DEREF_U64(cur_ptr, 0) = cur_arg;
+        cur_arg = args[jsarg_idx++];
+        DEREF_U64(cur_ptr, 1) = cur_arg;
+        #else
+        // Was split by legalizer adaptor
+        DEREF_U32(cur_ptr, 0) = cur_arg;
+        cur_arg = args[jsarg_idx++];
+        DEREF_U32(cur_ptr, 1) = cur_arg;
+        cur_arg = args[jsarg_idx++];
+        DEREF_U32(cur_ptr, 2) = cur_arg;
+        cur_arg = args[jsarg_idx++];
+        DEREF_U32(cur_ptr, 3) = cur_arg;
+        #endif
+        break;
+      }
+    }
+    // If its a varargs call, last js argument is a pointer to the varargs.
+    var varargs = 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.
+
+    // We either have a pointer to the argument if the argument is not a struct
+    // or a pointer to pointer to struct. We need to store a pointer to the
+    // argument into args_ptr[i]
+    for (; carg_idx < nargs; carg_idx++) {
+      var arg_type_id = unboxed_arg_type_id_list[carg_idx];
+      var arg_type_info = unboxed_arg_type_info_list[carg_idx];
+      var arg_size = arg_type_info[0];
+      var arg_align = arg_type_info[1];
+      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);
+        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;
+      } else {
+        DEREF_U32(args_ptr, carg_idx) = varargs;
+      }
+      varargs += 4;
+    }
+    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__user_data(closure)
+    );
+    stackRestore(orig_stack_ptr);
+
+    // If we aren't supposed to return by argument, figure out what to return.
+    if (!ret_by_arg) {
+      switch (sig[0]) {
+      case "i":
+        return DEREF_U32(ret_ptr, 0);
+      case "j":
+        #if WASM_BIGINT
+        return DEREF_U64(ret_ptr, 0);
+        #else
+        // Split the return i64, set the upper 32 bits into tempRet0 and return
+        // the lower 32 bits.
+        setTempRet0(DEREF_U32(ret_ptr, 1));
+        return DEREF_U32(ret_ptr, 0);
+        #endif
+      case "d":
+        return DEREF_F64(ret_ptr, 0);
+      case "f":
+        return DEREF_F32(ret_ptr, 0);
+      }
+    }
+  }
+  try {
+    var wasm_trampoline = JS_FUNCTION_TO_WASM(trampoline, sig);
+  } catch(e) {
+    return FFI_BAD_TYPEDEF_MACRO;
+  }
+  setWasmTableEntry(codeloc, wasm_trampoline);
+  CLOSURE__cif(closure) = cif;
+  CLOSURE__fun(closure) = fun;
+  CLOSURE__user_data(closure) = user_data;
+  return FFI_OK_MACRO;
+})
+
+// EM_JS does not correctly handle function pointer arguments, so we need a
+// helper
+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)
+    return FFI_BAD_ABI;
+  return ffi_prep_closure_loc_js(closure, cif, (void *)fun, user_data,
+                                     codeloc);
+}