[wasm64] making JS bindings wasm64 aware

Author: aardappel

src/runtime.js

@@ -21,6 +21,10 @@ var Compiletime = {
 // code used both at compile time and runtime is defined here, then put on
 // the Runtime object for compile time and support.js for the generated code
 
+function getPointerSize() {
+  return MEMORY64 ? 8 : 4;
+}
+
 function getNativeTypeSize(type) {
   switch (type) {
     case 'i1': case 'i8': return 1;
@@ -31,7 +35,7 @@ function getNativeTypeSize(type) {
     case 'double': return 8;
     default: {
       if (type[type.length-1] === '*') {
-        return 4; // A pointer
+        return getPointerSize();
       } else if (type[0] === 'i') {
         var bits = Number(type.substr(1));
         assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
@@ -53,6 +57,6 @@ var Runtime = {
     return Math.max(getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
   },
 
-  POINTER_SIZE: 4,
-  QUANTUM_SIZE: 4,
+  POINTER_SIZE: getPointerSize(),
+  QUANTUM_SIZE: getPointerSize(),
 };

src/support.js

@@ -6,6 +6,10 @@
 
 var STACK_ALIGN = {{{ STACK_ALIGN }}};
 
+function getPointerSize() {
+  return {{{ MEMORY64 ? 8 : 4 }}};
+}
+
 {{{ getNativeTypeSize }}}
 
 function warnOnce(text) {

tests/core/test_typeid.cpp

@@ -8,17 +8,18 @@
 #include <stdio.h>
 #include <string.h>
 #include <typeinfo>
+#include <stdint.h>
 int main() {
   printf("*\n");
 #define MAX 100
-  int ptrs[MAX];
+  long ptrs[MAX];
   int groups[MAX];
-  memset(ptrs, 0, MAX * sizeof(int));
+  memset(ptrs, 0, MAX * sizeof(long));
   memset(groups, 0, MAX * sizeof(int));
   int next_group = 1;
 #define TEST(X)                         \
   {                                     \
-    int ptr = (int)&typeid(X);          \
+    intptr_t ptr = (intptr_t)&typeid(X);          \
     int group = 0;                      \
     int i;                              \
     for (i = 0; i < MAX; i++) {         \

tests/runner.py

@@ -60,6 +60,7 @@
   'wasm2js3',
   'wasm2jss',
   'wasm2jsz',
+  'wasm64'
 ]
 
 # The default core test mode, used when none is specified
@@ -312,6 +313,8 @@ def parse_args(args):
   parser.add_argument('tests', nargs='*')
   parser.add_argument('--failfast', dest='failfast', action='store_const',
                       const=True, default=False)
+  parser.add_argument('--force64', dest='force64', action='store_const',
+                      const=True, default=False)
   return parser.parse_args()
 
 
@@ -324,6 +327,8 @@ def configure():
   common.EMTEST_LACKS_NATIVE_CLANG = int(os.getenv('EMTEST_LACKS_NATIVE_CLANG', '0'))
   common.EMTEST_REBASELINE = int(os.getenv('EMTEST_REBASELINE', '0'))
   common.EMTEST_VERBOSE = int(os.getenv('EMTEST_VERBOSE', '0')) or shared.DEBUG
+  global FORCE64
+  FORCE64 = int(os.getenv('EMTEST_FORCE64', '0'))
   if common.EMTEST_VERBOSE:
     logging.root.setLevel(logging.DEBUG)
 
@@ -361,6 +366,7 @@ def set_env(name, option_value):
   set_env('EMTEST_REBASELINE', options.rebaseline)
   set_env('EMTEST_VERBOSE', options.verbose)
   set_env('EMTEST_CORES', options.cores)
+  set_env('EMTEST_FORCE64', options.force64)
 
   configure()
 

tests/test_benchmark.py

@@ -51,6 +51,8 @@
 
 LLVM_FEATURE_FLAGS = ['-mnontrapping-fptoint']
 
+FORCE64 = 0
+
 
 class Benchmarker():
   # called when we init the object, which is during startup, even if we are
@@ -205,12 +207,14 @@ def build(self, parent, filename, args, shared_args, emcc_args, native_args, nat
       OPTIMIZATIONS,
       '-s', 'INITIAL_MEMORY=256MB',
       '-s', 'FILESYSTEM=0',
-      '--closure=1',
-      '-s', 'MINIMAL_RUNTIME',
       '-s', 'ENVIRONMENT=node,shell',
       '-s', 'BENCHMARK=%d' % (1 if IGNORE_COMPILATION and not has_output_parser else 0),
       '-o', final
     ] + shared_args + emcc_args + LLVM_FEATURE_FLAGS + self.extra_args
+    if FORCE64:
+      cmd += ['--profiling']
+    else:
+      cmd += ['--closure=1', '-sMINIMAL_RUNTIME']
     if 'FORCE_FILESYSTEM' in cmd:
       cmd = [arg if arg != 'FILESYSTEM=0' else 'FILESYSTEM=1' for arg in cmd]
     if PROFILING:
@@ -353,22 +357,30 @@ def cleanup(self):
 
 # Benchmarkers
 
-benchmarkers = [
-  NativeBenchmarker('clang', [CLANG_CC], [CLANG_CXX]),
-  # NativeBenchmarker('gcc',   ['gcc', '-no-pie'],  ['g++', '-no-pie'])
-]
+benchmarkers = []
+
+if not FORCE64:
+  benchmarkers += [
+    NativeBenchmarker('clang', [CLANG_CC], [CLANG_CXX]),
+    # NativeBenchmarker('gcc',   ['gcc', '-no-pie'],  ['g++', '-no-pie'])
+  ]
 
 if config.V8_ENGINE and config.V8_ENGINE in config.JS_ENGINES:
   # avoid the baseline compiler running, because it adds a lot of noise
   # (the nondeterministic time it takes to get to the full compiler ends up
   # mattering as much as the actual benchmark)
   aot_v8 = config.V8_ENGINE + ['--no-liftoff']
   default_v8_name = os.environ.get('EMBENCH_NAME') or 'v8'
-  benchmarkers += [
-    EmscriptenBenchmarker(default_v8_name, aot_v8),
-    EmscriptenBenchmarker(default_v8_name + '-lto', aot_v8, ['-flto']),
-    # EmscriptenWasm2CBenchmarker('wasm2c')
-  ]
+  if FORCE64:
+    benchmarkers += [
+      EmscriptenBenchmarker(default_v8_name, aot_v8, ['-sMEMORY64=2']),
+    ]
+  else:
+    benchmarkers += [
+      EmscriptenBenchmarker(default_v8_name, aot_v8),
+      EmscriptenBenchmarker(default_v8_name + '-lto', aot_v8, ['-flto']),
+      # EmscriptenWasm2CBenchmarker('wasm2c')
+    ]
   if os.path.exists(CHEERP_BIN):
     benchmarkers += [
       # CheerpBenchmarker('cheerp-v8-wasm', aot_v8),
@@ -385,9 +397,14 @@ def cleanup(self):
     ]
 
 if config.NODE_JS and config.NODE_JS in config.JS_ENGINES:
-  benchmarkers += [
-    # EmscriptenBenchmarker('Node.js', config.NODE_JS),
-  ]
+  if FORCE64:
+    benchmarkers += [
+      EmscriptenBenchmarker('Node.js', config.NODE_JS, ['-sMEMORY64=2']),
+    ]
+  else:
+    benchmarkers += [
+      # EmscriptenBenchmarker('Node.js', config.NODE_JS),
+    ]
 
 
 class benchmark(common.RunnerCore):