Report missing EXPORTED_FUNCTIONS by default (#7311)

Author: sbc100

emscripten.py

@@ -27,7 +27,7 @@
 from tools import gen_struct_info
 from tools import jsrun, tempfiles
 from tools.response_file import substitute_response_files
-from tools.shared import WINDOWS, asstr, path_from_root
+from tools.shared import WINDOWS, asstr, path_from_root, exit_with_error
 from tools.toolchain_profiler import ToolchainProfiler
 
 if __name__ == '__main__':
@@ -618,18 +618,19 @@ def get_all_implemented(forwarded_json, metadata):
 # be a response file, in which case, load it
 def get_original_exported_functions():
   ret = shared.Settings.ORIGINAL_EXPORTED_FUNCTIONS
-  if ret[0] == '@':
+  if ret and ret[0] == '@':
     ret = json.loads(open(ret[1:]).read())
   return ret
 
 
 def check_all_implemented(all_implemented, pre):
-  if shared.Settings.ASSERTIONS and shared.Settings.ORIGINAL_EXPORTED_FUNCTIONS:
-    original_exports = get_original_exported_functions()
-    for requested in original_exports:
-      if not is_already_implemented(requested, pre, all_implemented):
-        # could be a js library func
-        logging.warning('function requested to be exported, but not implemented: "%s"', requested)
+  for requested in get_original_exported_functions():
+    if not is_already_implemented(requested, pre, all_implemented):
+      # could be a js library func
+      if shared.Settings.ERROR_ON_UNDEFINED_SYMBOLS:
+        exit_with_error('undefined exported function: "%s"', requested)
+      elif shared.Settings.WARN_ON_UNDEFINED_SYMBOLS:
+        logging.warning('undefined exported function: "%s"', requested)
 
 
 def is_already_implemented(requested, pre, all_implemented):
@@ -694,8 +695,7 @@ def include_asm_consts(pre, forwarded_json, metadata):
   for s in range(len(all_sigs)):
     sig = all_sigs[s]
     if 'j' in sig:
-      logging.error('emscript: EM_ASM should not receive i64s as inputs, they are not valid in JS')
-      sys.exit(1)
+      exit_with_error('emscript: EM_ASM should not receive i64s as inputs, they are not valid in JS')
     call_type = call_types[s] if s < len(call_types) else ''
     if '_emscripten_asm_const_' + call_type + sig in forwarded_json['Functions']['libraryFunctions']:
       continue # Only one invoker needs to be emitted for each ASM_CONST (signature x call_type) item
@@ -2020,16 +2020,7 @@ def create_exported_implemented_functions_wasm(pre, forwarded_json, metadata):
     if key in all_exported_functions or export_all or (export_bindings and key.startswith('_emscripten_bind')):
       exported_implemented_functions.add(key)
 
-  if shared.Settings.ASSERTIONS and shared.Settings.ORIGINAL_EXPORTED_FUNCTIONS:
-    original_exports = get_original_exported_functions()
-    for requested in original_exports:
-      # check if already implemented
-      # special-case malloc, EXPORTED by default for internal use, but we bake in a trivial allocator and warn at runtime if used in ASSERTIONS \
-      if requested not in all_implemented and \
-         requested != '_malloc' and \
-         (('function ' + asstr(requested)) not in pre): # could be a js library func
-        logging.warning('function requested to be exported, but not implemented: "%s"', requested)
-
+  check_all_implemented(all_implemented, pre)
   return exported_implemented_functions
 
 

src/settings.js

@@ -698,13 +698,15 @@ var STRICT = 0;
 // (and don't want to mess with the existing buildsystem), and functions might
 // be implemented later on, say in --pre-js, so you may want to build with -s
 // WARN_ON_UNDEFINED_SYMBOLS=0 to disable the warnings if they annoy you.  See
-// also ERROR_ON_UNDEFINED_SYMBOLS
+// also ERROR_ON_UNDEFINED_SYMBOLS.  Any undefined symbols that are listed in-
+// EXPORTED_FUNCTIONS will also be reported.
 var WARN_ON_UNDEFINED_SYMBOLS = 1;
 
 // If set to 1, we will give a link-time error on any undefined symbols (see
-// WARN_ON_UNDEFINED_SYMBOLS). The default value is 1. To allow undefined symbols
-// at link time set this to 0, in which case if an undefined function is called
-// a runtime error will occur.
+// WARN_ON_UNDEFINED_SYMBOLS). The default value is 1. To allow undefined
+// symbols at link time set this to 0, in which case if an undefined function is
+// called a runtime error will occur.  Any undefined symbols that are listed in
+// EXPORTED_FUNCTIONS will also be reported.
 var ERROR_ON_UNDEFINED_SYMBOLS = 1;
 
 // If set to 1, any -lfoo directives pointing to nonexisting library files will

tests/test_core.py

@@ -6342,7 +6342,7 @@ def process(filename):
   open(filename, 'w').write(src)
 '''
 
-    self.set_setting('EXPORTED_FUNCTIONS', self.get_setting('EXPORTED_FUNCTIONS') + ['_get_int', '_get_float', '_get_bool', '_get_string', '_print_int', '_print_float', '_print_bool', '_print_string', '_multi', '_pointer', '_call_ccall_again', '_malloc'])
+    self.set_setting('EXPORTED_FUNCTIONS', ['_get_int', '_get_float', '_get_bool', '_get_string', '_print_int', '_print_float', '_print_bool', '_print_string', '_multi', '_pointer', '_call_ccall_again', '_malloc'])
     self.do_run_in_out_file_test('tests', 'core', 'test_ccall', js_transform=post)
 
     if '-O2' in self.emcc_args or self.is_emterpreter():

tests/test_other.py

@@ -1584,11 +1584,11 @@ def test_export_in_a(self):
 
     # Sanity check: exporting without a definition does not cause it to appear.
     # Note: exporting main prevents emcc from warning that it generated no code.
-    run_process([PYTHON, EMCC, 'main.c', '-s', '''EXPORTED_FUNCTIONS=['_main', '%s']''' % full_export_name])
+    run_process([PYTHON, EMCC, 'main.c', '-s', 'ERROR_ON_UNDEFINED_SYMBOLS=0', '-s', "EXPORTED_FUNCTIONS=['_main', '%s']" % full_export_name])
     self.assertFalse(self.is_exported_in_wasm(expect_export, 'a.out.wasm'))
 
     # Actual test: defining symbol in library and exporting it causes it to appear in the output.
-    run_process([PYTHON, EMCC, 'main.c', '-L.', '-lexport', '-s', '''EXPORTED_FUNCTIONS=['%s']''' % full_export_name])
+    run_process([PYTHON, EMCC, 'main.c', '-L.', '-lexport', '-s', "EXPORTED_FUNCTIONS=['%s']" % full_export_name])
     self.assertTrue(self.is_exported_in_wasm(expect_export, 'a.out.wasm'))
 
   def test_embed_file(self):
@@ -1840,6 +1840,20 @@ def test_link_memcpy(self):
 ''', output)
     self.assertNotContained('warning: library.js memcpy should not be running, it is only for testing!', output)
 
+  def test_undefined_function(self):
+    cmd = [PYTHON, EMCC, path_from_root('tests', 'hello_world.cpp')]
+    run_process(cmd)
+
+    # adding a missing symbol to EXPORTED_FUNCTIONS should cause failure
+    cmd += ['-s', "EXPORTED_FUNCTIONS=['foobar']"]
+    proc = run_process(cmd, stderr=PIPE, check=False)
+    self.assertNotEqual(proc.returncode, 0)
+    self.assertContained('undefined exported function: "foobar"', proc.stderr)
+
+    # setting ERROR_ON_UNDEFINED_SYMBOLS=0 suppresses error
+    cmd += ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=0']
+    proc = run_process(cmd)
+
   def test_undefined_symbols(self):
     with open('main.cpp', 'w') as f:
       f.write(r'''
@@ -3969,9 +3983,9 @@ def test_bad_export(self):
       self.clear()
       cmd = [PYTHON, EMCC, path_from_root('tests', 'hello_world.c'), '-s', 'EXPORTED_FUNCTIONS=["' + m + '_main"]']
       print(cmd)
-      stderr = run_process(cmd, stderr=PIPE).stderr
+      stderr = run_process(cmd, stderr=PIPE, check=False).stderr
       if m:
-        assert 'function requested to be exported, but not implemented: " _main"' in stderr, stderr
+        self.assertContained('undefined exported function: " _main"', stderr)
       else:
         self.assertContained('hello, world!', run_js('a.out.js'))
 
@@ -8792,20 +8806,21 @@ def test_emcc_parsing(self):
       # extra newline in response file - should be ignored
       ("EXPORTED_FUNCTIONS=@response", ''),
       # stray slash
-      ("EXPORTED_FUNCTIONS=['_a', '_b', \\'_c', '_d']", '''function requested to be exported, but not implemented: "\\\\'_c'"'''),
+      ("EXPORTED_FUNCTIONS=['_a', '_b', \\'_c', '_d']", '''undefined exported function: "\\\\'_c'"'''),
       # stray slash
-      ("EXPORTED_FUNCTIONS=['_a', '_b',\ '_c', '_d']", '''function requested to be exported, but not implemented: "\\\\ '_c'"'''),
+      ("EXPORTED_FUNCTIONS=['_a', '_b',\ '_c', '_d']", '''undefined exported function: "\\\\ '_c'"'''),
       # stray slash
-      ('EXPORTED_FUNCTIONS=["_a", "_b", \\"_c", "_d"]', 'function requested to be exported, but not implemented: "\\\\"_c""'),
+      ('EXPORTED_FUNCTIONS=["_a", "_b", \\"_c", "_d"]', 'undefined exported function: "\\\\"_c""'),
       # stray slash
-      ('EXPORTED_FUNCTIONS=["_a", "_b",\ "_c", "_d"]', 'function requested to be exported, but not implemented: "\\\\ "_c"'),
+      ('EXPORTED_FUNCTIONS=["_a", "_b",\ "_c", "_d"]', 'undefined exported function: "\\\\ "_c"'),
       # missing comma
-      ('EXPORTED_FUNCTIONS=["_a", "_b" "_c", "_d"]', 'function requested to be exported, but not implemented: "_b" "_c"'),
+      ('EXPORTED_FUNCTIONS=["_a", "_b" "_c", "_d"]', 'undefined exported function: "_b" "_c"'),
     ]:
       print(export_arg)
-      err = run_process([PYTHON, EMCC, 'src.c', '-s', export_arg], stdout=PIPE, stderr=PIPE).stderr
-      print(err)
+      proc = run_process([PYTHON, EMCC, 'src.c', '-s', export_arg], stdout=PIPE, stderr=PIPE, check=not expected)
+      print(proc.stderr)
       if not expected:
-        assert not err
+        assert not proc.stderr
       else:
-        self.assertContained(expected, err)
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertContained(expected, proc.stderr)