Merge remote-tracking branch 'origin/main' into issue-20983

Author: ypujante

.circleci/ccache.conf

@@ -0,0 +1,2 @@
+debug = true
+debug_level = 1

.circleci/config.yml

@@ -209,9 +209,11 @@ commands:
       - run:
           name: "Ccache stats and configuration"
           command: |
-            ls ~/cache/sysroot/lib/wasm32-emscripten || echo "no build"
+            ls -l ~/cache/sysroot/lib/wasm32-emscripten || echo "no build"
+            ls -l ~/cache/sysroot/include/emscripten/heap.h
             cat ~/cache/sysroot/lib/wasm32-emscripten/crtbegin.o.ccache-log
             date
+            cat ~/cache/build/libcompiler_rt/absvdi2.o.ccache-log
             ccache -s
             ccache --print-stats
             ccache -p
@@ -574,8 +576,6 @@ jobs:
       EMCC_CORES: 16
       EMCC_USE_NINJA: 1
       EM_COMPILER_WRAPPER: "ccache"
-      CCACHE_DEBUG: 1
-      CCACHE_DEBUGLEVEL: 1
     steps:
       - checkout
       - run:
@@ -611,6 +611,12 @@ jobs:
             - restore_cache:
                 name: "Restore Ccache cache"
                 key: clang-{{ checksum "~/emsdk/clang_version.txt" }}
+      - run:
+          name: Configure ccache
+          command: |
+            mkdir -p ~/.ccache
+            cat .circleci/ccache.conf
+            cp .circleci/ccache.conf ~/.ccache
       - build-libs
       - run:
           name: Clean build directory
@@ -820,7 +826,31 @@ jobs:
           command: echo "NODE_JS = NODE_JS_TEST" >> ~/emsdk/.emscripten
       - run-tests:
           title: "wasm64_4gb"
-          test_targets: "wasm64_4gb
+          test_targets: "wasm64_4gb"
+      - upload-test-results
+  test-wasm64-misc:
+    environment:
+      LANG: "C.UTF-8"
+    # We don't use `bionic` here since its too old to run recent node versions:
+    # `/lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.28' not found`
+    executor: linux-python
+    steps:
+      - prepare-for-tests
+      # The linux-python image uses /home/circleci rather than /root and jsvu
+      # hardcodes /root into its launcher scripts so we need to reinstall v8.
+      - run: rm -rf $HOME/.jsvu
+      - install-v8
+      - install-node-canary
+      # When running wasm64 tests we need to make sure we use the testing
+      # version of node (node canary) when running the compiler output (e.g.
+      # in configure tests.
+      - run:
+          name: configure node canary
+          command: echo "NODE_JS = NODE_JS_TEST" >> ~/emsdk/.emscripten
+      - run-tests:
+          title: "wasm64"
+          test_targets: "
+            other.*_wasm64
             core_2gb.test_*em_asm*
             core_2gb.test_*embind*
             core_2gb.test_fs_js_api_wasmfs
@@ -829,8 +859,7 @@ jobs:
             wasm64l.test_bigswitch
             wasm64l.test_module_wasm_memory
             wasm64l.test_longjmp2_emscripten
-            wasm64l.test_embind_val_basics_legacy
-            other.*_wasm64"
+            wasm64l.test_embind_val_basics_legacy"
       - upload-test-results
   test-jsc:
     executor: linux-python
@@ -1280,6 +1309,9 @@ workflows:
       - test-core3:
           requires:
             - build-linux
+      - test-wasm64-misc:
+          requires:
+            - build-linux
       - test-wasm64-4gb:
           requires:
             - build-linux

emcc.py

@@ -31,13 +31,12 @@
 import tarfile
 from dataclasses import dataclass
 from enum import Enum, auto, unique
-from subprocess import PIPE
 
 
 from tools import shared, system_libs, utils, cmdline
 from tools import diagnostics, building, compile
 from tools.shared import unsuffixed_basename, get_file_suffix
-from tools.shared import run_process, exit_with_error, DEBUG
+from tools.shared import exit_with_error, DEBUG
 from tools.shared import in_temp
 from tools.shared import DYLIB_EXTENSIONS
 from tools.cmdline import CLANG_FLAGS_WITH_ARGS
@@ -242,27 +241,6 @@ def run(args):
     print(utils.EMSCRIPTEN_VERSION)
     return 0
 
-  if '--cflags' in args:
-    # fake running the command, to see the full args we pass to clang
-    args = [x for x in args if x != '--cflags']
-    with shared.get_temp_files().get_file(suffix='.o') as temp_target:
-      input_file = 'hello_world.c'
-      compiler = shared.EMCC
-      if shared.run_via_emxx:
-        compiler = shared.EMXX
-      cmd = [compiler, utils.path_from_root('test', input_file), '-v', '-c', '-o', temp_target] + args
-      proc = run_process(cmd, stderr=PIPE, check=False)
-      if proc.returncode != 0:
-        print(proc.stderr)
-        exit_with_error('error getting cflags')
-      lines = [x for x in proc.stderr.splitlines() if clang in x and input_file in x]
-      if not lines:
-        exit_with_error(f'unable to parse output of `{cmd}`:\n{proc.stderr}')
-      parts = shlex.split(lines[0].replace('\\', '\\\\'))
-      parts = [x for x in parts if x not in ['-c', '-o', '-v', '-emit-llvm'] and input_file not in x and temp_target not in x]
-      print(shlex.join(parts[1:]))
-    return 0
-
   if '-dumpmachine' in args or '-print-target-triple' in args or '--print-target-triple' in args:
     print(shared.get_llvm_target())
     return 0
@@ -314,6 +292,13 @@ def run(args):
 
   phase_setup(options, state)
 
+  if '--cflags' in args:
+    # Just print the flags we pass to clang and exit.  We need to do this after
+    # phase_setup because the setup sets things like SUPPORT_LONGJMP.
+    cflags = compile.get_cflags(x for x in args if x != '--cflags')
+    print(shlex.join(cflags))
+    return 0
+
   if options.reproduce:
     create_reproduce_file(options.reproduce, args)
 

src/modules.mjs

@@ -433,6 +433,11 @@ function exportSymbol(name) {
 function exportRuntimeSymbols() {
   // optionally export something.
   function shouldExport(name) {
+    // Native exports are not available to be exported initially.  Instead,
+    // they get exported later in `assignWasmExports`.
+    if (nativeAliases[name]) {
+      return false;
+    }
     // If requested to be exported, export it.
     if (EXPORTED_RUNTIME_METHODS.has(name)) {
       // Unless we are in MODULARIZE=instance mode then HEAP objects are

test/test_other.py

@@ -689,19 +689,20 @@ def test_js_transform(self):
     self.assertIn('transformed!', read_file('a.out.js'))
 
   @crossplatform
+  @also_with_wasm64
   def test_emcc_cflags(self):
-    output = self.run_process([EMCC, '--cflags'], stdout=PIPE)
+    output = self.run_process([EMCC, '--cflags'] + self.get_cflags(), stdout=PIPE)
     flags = output.stdout.strip()
-    self.assertContained('-target wasm32-unknown-emscripten', flags)
+    self.assertContained(r'-target wasm\d\d-unknown-emscripten', flags, regex=True)
     self.assertContained('--sysroot=', flags)
-    output = self.run_process([EMXX, '--cflags'], stdout=PIPE)
+    output = self.run_process([EMXX, '--cflags'] + self.get_cflags(), stdout=PIPE)
     flags = output.stdout.strip()
-    self.assertContained('-target wasm32-unknown-emscripten', flags)
+    self.assertContained(r'-target wasm\d\d-unknown-emscripten', flags, regex=True)
     self.assertContained('--sysroot=', flags)
     # check they work
     cmd = [CLANG_CC, test_file('hello_world.c')] + shlex.split(flags.replace('\\', '\\\\')) + ['-c', '-o', 'out.o']
     self.run_process(cmd)
-    self.run_process([EMCC, 'out.o'])
+    self.run_process([EMCC, 'out.o'] + self.get_cflags())
     self.assertContained('hello, world!', self.run_js('a.out.js'))
 
   @crossplatform
@@ -4947,6 +4948,35 @@ def test_jslib_aliases(self, args):
 '''
     self.do_runf('main.c', expected, cflags=['--js-library', 'foo.js'] + args)
 
+  @parameterized({
+    '': ([],),
+    'closure': (['--closure=1'],),
+  })
+  def test_jslib_export_alias(self, args):
+    create_file('lib.js', '''
+      addToLibrary({
+        $foo: 'main',
+        $bar: '__indirect_function_table',
+        $baz: 'memory',
+      });
+    ''')
+    create_file('extern_pre.js', r'''
+      Module = {
+        onRuntimeInitialized: () => {
+          const assert = require('assert');
+          console.log("onRuntimeInitialized");
+          console.log('foo:', typeof Module.foo)
+          console.log('bar:', typeof Module.bar)
+          console.log('baz:', typeof Module.baz)
+          assert(Module.foo instanceof Function);
+          assert(Module.bar instanceof WebAssembly.Table);
+          assert(Module.baz instanceof WebAssembly.Memory);
+          console.log('done');
+        }
+      };
+    ''')
+    self.do_runf('hello_world.c', 'done\n', cflags=['--js-library=lib.js', '--extern-pre-js=extern_pre.js', '-sEXPORTED_RUNTIME_METHODS=foo,bar,baz'] + args)
+
   def test_postjs_errors(self):
     create_file('post.js', '#preprocess\n#error This is an error')
     err = self.expect_fail([EMCC, test_file('hello_world.c'), '--post-js', 'post.js'])

tools/emscripten.py

@@ -980,6 +980,7 @@ def create_receiving(function_exports, other_exports, library_symbols, aliases):
     assert alias in exports, f'expected alias target ({alias}) to be exported'
     alias_inverse_map.setdefault(alias, []).append(sym)
 
+  do_module_exports = (settings.MODULARIZE or not settings.MINIMAL_RUNTIME) and settings.MODULARIZE != 'instance'
   receiving.append('\nfunction assignWasmExports(wasmExports) {')
   for sym, sig in exports.items():
     is_function = sig is not None
@@ -988,11 +989,13 @@ def create_receiving(function_exports, other_exports, library_symbols, aliases):
     if generate_dyncall_assignment and is_function and sym.startswith('dynCall_'):
       sig_str = sym.replace('dynCall_', '')
       assignment += f" = dynCalls['{sig_str}']"
-    if (settings.MODULARIZE or not settings.MINIMAL_RUNTIME) and should_export(mangled) and settings.MODULARIZE != 'instance':
+    if do_module_exports and should_export(mangled):
       assignment += f" = Module['{mangled}']"
     if sym in alias_inverse_map:
       for target in alias_inverse_map[sym]:
         assignment += f" = {target}"
+        if do_module_exports and target in settings.EXPORTED_RUNTIME_METHODS:
+          assignment += f" = Module['{target}']"
     if is_function and install_debug_wrapper(sym):
       nargs = len(sig.params)
       receiving.append(f"  {assignment} = createExportWrapper('{sym}', {nargs});")