Fix for -lGL + AUTO_NATIVE_LIBRARIES=0

When calling `map_to_js_libs('GL')` we were mapping this to the JS
libraries, and not also including the native `libgl` library.  Normally
this doesn't matter since `libgl` is included by default, but not when
`AUTO_NATIVE_LIBRARIES=0` is used.

This also happens to fix an old bug (#10171) where we would look on the
file system for `libGL.a` before looking in `map_to_js_libs`.

Fixes: #10171
Fixes: #14335

Author: sbc100

emcc.py

@@ -1050,7 +1050,7 @@ def run(args):
   if state.mode == Mode.POST_LINK_ONLY:
     settings.limit_settings(None)
     target, wasm_target = phase_linker_setup(options, state, newargs, settings_map)
-    process_libraries(state.link_flags, state.lib_dirs, [])
+    process_libraries(state, [])
     if len(input_files) != 1:
       exit_with_error('--post-link requires a single input file')
     phase_post_link(options, state, input_files[0][1], wasm_target, target)
@@ -1113,7 +1113,7 @@ def phase_calculate_linker_inputs(options, state, linker_inputs):
   state.link_flags = filter_link_flags(state.link_flags, using_lld)
 
   # Decide what we will link
-  state.link_flags = process_libraries(state.link_flags, state.lib_dirs, linker_inputs)
+  state.link_flags = process_libraries(state, linker_inputs)
 
   linker_args = [val for _, val in sorted(linker_inputs + state.link_flags)]
 
@@ -3502,18 +3502,20 @@ def find_library(lib, lib_dirs):
   return None
 
 
-def process_libraries(link_flags, lib_dirs, linker_inputs):
+def process_libraries(state, linker_inputs):
   new_flags = []
   libraries = []
   suffixes = STATICLIB_ENDINGS + DYNAMICLIB_ENDINGS
   system_libs_map = system_libs.Library.get_usable_variations()
 
   # Find library files
-  for i, flag in link_flags:
+  for i, flag in state.link_flags:
     if not flag.startswith('-l'):
       new_flags.append((i, flag))
       continue
+
     lib = strip_prefix(flag, '-l')
+    logger.debug('looking for library "%s"', lib)
     # We don't need to resolve system libraries to absolute paths here, we can just
     # let wasm-ld handle that.  However, we do want to map to the correct variant.
     # For example we map `-lc` to `-lc-mt` if we are building with threading support.
@@ -3522,23 +3524,30 @@ def process_libraries(link_flags, lib_dirs, linker_inputs):
       new_flags.append((i, '-l' + strip_prefix(lib.get_base_name(), 'lib')))
       continue
 
-    logger.debug('looking for library "%s"', lib)
+    js_libs, native_lib = building.map_to_js_libs(lib)
+    if js_libs is not None:
+      libraries += [(i, js_lib) for js_lib in js_libs]
+      # If native_lib is returned then include it in the link
+      # via forced_stdlibs.
+      if native_lib:
+        state.forced_stdlibs.append(native_lib)
+      continue
+
+    if building.map_and_apply_to_settings(lib):
+      continue
 
     path = None
     for suff in suffixes:
       name = 'lib' + lib + suff
-      path = find_library(name, lib_dirs)
+      path = find_library(name, state.lib_dirs)
       if path:
         break
 
     if path:
       linker_inputs.append((i, path))
       continue
-    jslibs = building.map_to_js_libs(lib)
-    if jslibs is not None:
-      libraries += [(i, jslib) for jslib in jslibs]
-    elif not building.map_and_apply_to_settings(lib):
-      new_flags.append((i, flag))
+
+    new_flags.append((i, flag))
 
   settings.SYSTEM_JS_LIBRARIES += libraries
 

tests/other/test_explict_gl_linking.c

@@ -0,0 +1,5 @@
+#include <EGL/egl.h>
+
+int main() {
+    return (int)eglGetProcAddress("foo");
+}

tests/test_other.py

@@ -10642,3 +10642,8 @@ def test_standard_library_mapping(self):
     self.assertContained(' -lc-mt ', err)
     self.assertContained(' -ldlmalloc-mt ', err)
     self.assertContained(' -lcompiler_rt-mt ', err)
+
+  def test_explict_gl_linking(self):
+    # ensure libgl exists
+    self.run_process([EMBUILDER, 'build', 'libgl'])
+    self.run_process([EMCC, test_file('other/test_explict_gl_linking.c'), '-sNO_AUTO_NATIVE_LIBRARIES', '-lGL'])

tools/building.py

@@ -1333,13 +1333,16 @@ def is_wasm_dylib(filename):
   return False
 
 
-# Given the name of a special Emscripten-implemented system library, returns an
-# array of absolute paths to JS library files inside emscripten/src/ that
-# corresponds to the library name.
 def map_to_js_libs(library_name):
+  """Given the name of a special Emscripten-implemented system library, returns an
+  pair containing
+  1. Array of absolute paths to JS library files, inside emscripten/src/ that corresponds to the
+     library name. `None` means there is no mapping and the library will be processed by the linker
+     as a require for normal native library.
+  2. Optional name of a corresponding native library to link in.
+  """
   # Some native libraries are implemented in Emscripten as system side JS libraries
   library_map = {
-    'c': [],
     'dl': [],
     'EGL': ['library_egl.js'],
     'GL': ['library_webgl.js', 'library_html5_webgl.js'],
@@ -1361,16 +1364,20 @@ def map_to_js_libs(library_name):
     'uuid': ['library_uuid.js'],
     'websocket': ['library_websocket.js']
   }
+  # And some are hybrid and require JS and native libraries to be included
+  native_library_map = {
+    'GL': 'libgl',
+  }
 
   if library_name in library_map:
     libs = library_map[library_name]
     logger.debug('Mapping library `%s` to JS libraries: %s' % (library_name, libs))
-    return libs
+    return (libs, native_library_map.get(library_name))
 
   if library_name.endswith('.js') and os.path.isfile(path_from_root('src', 'library_' + library_name)):
-    return ['library_' + library_name]
+    return (['library_' + library_name], None)
 
-  return None
+  return (None, None)
 
 
 # Map a linker flag to a settings. This lets a user write -lSDL2 and it will have the same effect as