Add test for EM_JS and i64 arguments

Ideally we should error out if WASM_BIGINT is not passed by I have
yet to find a good place to do that.

See #15871

Author: sbc100

emscripten.py

@@ -299,6 +299,24 @@ def emscript(in_wasm, out_wasm, outfile_js, memfile):
 
   update_settings_glue(metadata)
 
+  if not settings.WASM_BIGINT and metadata['emJsFuncs']:
+    module = webassembly.Module(in_wasm)
+    types = module.get_types()
+    import_map = {}
+    for imp in module.get_imports():
+      import_map[imp.field] = imp
+    for em_js_func, raw in metadata.get('emJsFuncs', {}).items():
+      c_sig = raw.split('<::>')[0].strip('()')
+      if c_sig:
+        c_sig = c_sig.split(',')
+      else:
+        c_sig = []
+      imp = import_map[em_js_func]
+      assert(imp.kind == webassembly.ExternType.FUNC)
+      signature = types[imp.type]
+      if len(signature.params) != len(c_sig):
+        exit_with_error('EM_JS functions with 64-bit arguments requires WASM_BIGINT to be enabled: `%s` (%s, %s)', em_js_func, c_sig, signature.params)
+
   if settings.SIDE_MODULE:
     if metadata['asmConsts']:
       exit_with_error('EM_ASM is not supported in side modules')

tests/core/test_em_js_i64.c

@@ -0,0 +1,11 @@
+#include <stdint.h>
+#include <emscripten.h>
+
+EM_JS(void, foo, (uint64_t a, int64_t b), {
+  console.log('a:' + a);
+  console.log('b:' + b);
+})
+
+int main() {
+  foo(42000000000ull, -42ll);
+}

tests/core/test_em_js_i64.out

@@ -0,0 +1,2 @@
+a:42000000000
+b:-42

tests/test_core.py

@@ -2142,6 +2142,14 @@ def test_em_js(self, args, force_c):
     self.do_core_test('test_em_js.cpp', force_c=force_c)
     self.assertContained("no args returning int", read_file('test_em_js.js'))
 
+  def test_em_js_i64(self):
+    err = self.expect_fail([EMCC, test_file('core/test_em_js_i64.c')])
+    self.assertContained('emcc: error: EM_JS functions with 64-bit arguments requires WASM_BIGINT to be enabled: `foo`', err)
+
+    self.set_setting('WASM_BIGINT')
+    self.node_args += ['--experimental-wasm-bigint']
+    self.do_core_test('test_em_js_i64.c')
+
   def test_runtime_stacksave(self):
     self.do_runf(test_file('core/test_runtime_stacksave.c'), 'success')
 

tools/webassembly.py

@@ -114,13 +114,14 @@ class InvalidWasmError(BaseException):
 
 Section = namedtuple('Section', ['type', 'size', 'offset', 'name'])
 Limits = namedtuple('Limits', ['flags', 'initial', 'maximum'])
-Import = namedtuple('Import', ['kind', 'module', 'field'])
+Import = namedtuple('Import', ['kind', 'module', 'field', 'type'])
 Export = namedtuple('Export', ['name', 'kind', 'index'])
 Global = namedtuple('Global', ['type', 'mutable', 'init'])
 Dylink = namedtuple('Dylink', ['mem_size', 'mem_align', 'table_size', 'table_align', 'needed', 'export_info', 'import_info'])
 Table = namedtuple('Table', ['elem_type', 'limits'])
 FunctionBody = namedtuple('FunctionBody', ['offset', 'size'])
 DataSegment = namedtuple('DataSegment', ['flags', 'init', 'offset', 'size'])
+FuncType = namedtuple('FuncType', ['params', 'returns'])
 
 
 class Module:
@@ -210,6 +211,27 @@ def sections(self):
       yield Section(section_type, section_size, section_offset, name)
       offset = section_offset + section_size
 
+  def get_types(self):
+    type_section = self.get_section(SecType.TYPE)
+    if not type_section:
+      return []
+    self.seek(type_section.offset)
+    num_types = self.readULEB()
+    types = []
+    for i in range(num_types):
+      params = []
+      returns = []
+      type_form = self.readByte()
+      assert type_form == 0x60
+      num_params = self.readULEB()
+      for j in range(num_params):
+        params.append(self.read_type())
+      num_returns = self.readULEB()
+      for j in range(num_returns):
+        returns.append(self.read_type())
+      types.append(FuncType(params, returns))
+    return types
+
   def parse_features_section(self):
     features = []
     sec = self.get_custom_section('target_features')
@@ -315,22 +337,23 @@ def get_imports(self):
       mod = self.readString()
       field = self.readString()
       kind = ExternType(self.readByte())
-      imports.append(Import(kind, mod, field))
+      type_ = None
       if kind == ExternType.FUNC:
-        self.readULEB()  # sig
+        type_ = self.readULEB()
       elif kind == ExternType.GLOBAL:
-        self.readSLEB()  # global type
+        type_ = self.readSLEB()
         self.readByte()  # mutable
       elif kind == ExternType.MEMORY:
         self.read_limits()  # limits
       elif kind == ExternType.TABLE:
-        self.readSLEB()  # table type
+        type_ = self.readSLEB()
         self.read_limits()  # limits
       elif kind == ExternType.TAG:
         self.readByte()  # attribute
-        self.readULEB()  # sig
+        type_ = self.readULEB()
       else:
         assert False
+      imports.append(Import(kind, mod, field, type_))
 
     return imports