dylink: Synchronize dlsym calls (as well as dlopen) between threads

This is important for #18376.

Author: sbc100

src/library_addfunction.js

@@ -175,27 +175,36 @@ mergeInto(LibraryManager.library, {
     }
   },
 
+  $getFunctionAddress__deps: ['$updateTableMap', '$functionsInTableMap'],
+  $getFunctionAddress: function(func) {
+    // First, create the map if this is the first use.
+    if (!functionsInTableMap) {
+      functionsInTableMap = new WeakMap();
+      updateTableMap(0, wasmTable.length);
+    }
+    if (!functionsInTableMap.has(func)) {
+      return 0;
+    }
+    return functionsInTableMap.get(func);
+  },
+
   /**
    * Add a function to the table.
    * 'sig' parameter is required if the function being added is a JS function.
    */
   $addFunction__docs: '/** @param {string=} sig */',
-  $addFunction__deps: ['$convertJsFunctionToWasm', '$updateTableMap',
+  $addFunction__deps: ['$convertJsFunctionToWasm', '$getFunctionAddress',
                        '$functionsInTableMap', '$getEmptyTableSlot',
                        '$getWasmTableEntry', '$setWasmTableEntry'],
   $addFunction: function(func, sig) {
   #if ASSERTIONS
     assert(typeof func != 'undefined');
   #endif // ASSERTIONS
-
     // Check if the function is already in the table, to ensure each function
-    // gets a unique index. First, create the map if this is the first use.
-    if (!functionsInTableMap) {
-      functionsInTableMap = new WeakMap();
-      updateTableMap(0, wasmTable.length);
-    }
-    if (functionsInTableMap.has(func)) {
-      return functionsInTableMap.get(func);
+    // gets a unique index.
+    var rtn = getFunctionAddress(func);
+    if (rtn) {
+      return rtn;
     }
 
     // It's not in the table, add it now.

src/library_async.js

@@ -283,7 +283,7 @@ mergeInto(LibraryManager.library, {
       // Exported functions in side modules are not listed in `Module["asm"]`,
       // So we should use `resolveGlobalSymbol` helper function, which is defined in `library_dylink.js`.
       if (!func) {
-        func = resolveGlobalSymbol(name, false);
+        func = resolveGlobalSymbol(name, false)[0];
       }
 #endif
       return func;

src/library_dylink.js

@@ -36,7 +36,10 @@ var LibraryDylink = {
       // First look for the orig$ symbol which is the symbols without
       // any legalization performed.
       sym = wasmImports['orig$' + symName];
-      if (sym) return sym;
+      if (sym) {
+        symName = 'orig$' + symName;
+        return [sym, symName];
+      }
     }
 #endif
     if (isSymbolDefined(symName)) {
@@ -48,9 +51,10 @@ var LibraryDylink = {
 #if !DISABLE_EXCEPTION_CATCHING
     else if (symName.startsWith('__cxa_find_matching_catch_')) {
       sym = wasmImports['__cxa_find_matching_catch'];
+      symName = __cxa_find_matching_catch;
     }
 #endif
-    return sym;
+    return [sym, symName];
   },
 
   $GOT: {},
@@ -104,7 +108,7 @@ var LibraryDylink = {
   },
 
   $updateGOT__internal: true,
-  $updateGOT__deps: ['$GOT', '$isInternalSym', '$addFunction'],
+  $updateGOT__deps: ['$GOT', '$isInternalSym', '$addFunction', '$getFunctionAddress'],
   $updateGOT: function(exports, replace) {
 #if DYLINK_DEBUG
     dbg("updateGOT: adding " + Object.keys(exports).length + " symbols");
@@ -192,7 +196,7 @@ var LibraryDylink = {
 #endif
     for (var symName in GOT) {
       if (GOT[symName].value == 0) {
-        var value = resolveGlobalSymbol(symName, true)
+        var value = resolveGlobalSymbol(symName, true)[0];
         if (!value && !GOT[symName].required) {
           // Ignore undefined symbols that are imported as weak.
 #if DYLINK_DEBUG
@@ -234,13 +238,15 @@ var LibraryDylink = {
   _dlopen_js__deps: [function() { error(dlopenMissingError); }],
   _emscripten_dlopen_js__deps: [function() { error(dlopenMissingError); }],
   _dlsym_js__deps: [function() { error(dlopenMissingError); }],
+  _dlsym_catchup_js__deps: [function() { error(dlopenMissingError); }],
 #else
   $dlopenMissingError: `= ${dlopenMissingError}`,
   _dlopen_js__deps: ['$dlopenMissingError'],
   _emscripten_dlopen_js__deps: ['$dlopenMissingError'],
   _dlsym_js__deps: ['$dlopenMissingError'],
+  _dlsym_catchup_js__deps: ['$dlopenMissingError'],
 #endif
-  _dlopen_js: function(filename, flag) {
+  _dlopen_js: function(handle) {
     abort(dlopenMissingError);
   },
   _emscripten_dlopen_js: function(handle, onsuccess, onerror, user_data) {
@@ -249,6 +255,9 @@ var LibraryDylink = {
   _dlsym_js: function(handle, symbol) {
     abort(dlopenMissingError);
   },
+  _dlsym_catchup_js: function(handle, symbolIndex) {
+    abort(dlopenMissingError);
+  },
   _dlinit: function(main_dso_handle) {},
 #else // MAIN_MODULE != 0
   // dynamic linker/loader (a-la ld.so on ELF systems)
@@ -591,7 +600,7 @@ var LibraryDylink = {
       var moduleExports;
 
       function resolveSymbol(sym) {
-        var resolved = resolveGlobalSymbol(sym);
+        var resolved = resolveGlobalSymbol(sym)[0];
         if (!resolved) {
           resolved = moduleExports[sym];
         }
@@ -1061,21 +1070,44 @@ var LibraryDylink = {
     }
   },
 
+  _dlsym_catchup_js__sig: 'ppp',
+  _dlsym_catchup_js: function(handle, symbolIndex) {
+#if DYLINK_DEBUG
+    dbg("_dlsym_catchup: handle=" + ptrToString(handle) + " symbolIndex=" + symbolIndex);
+#endif
+    var symDict = wasmImports;
+    if (handle != {{{ cDefine('RTLD_DEFAULT') }}}) {
+      var lib = LDSO.loadedLibsByHandle[handle];
+      symDict = lib.module;
+    }
+    var symName = Object.keys(symDict)[symbolIndex];
+    var sym = symDict[symName];
+    var result = addFunction(sym, sym.sig);
+#if DYLINK_DEBUG
+    dbg('_dlsym_catchup: result=' + result);
+#endif
+    return result;
+  },
+
   // void* dlsym(void* handle, const char* symbol);
-  _dlsym_js__deps: ['$dlSetError'],
+  _dlsym_js__deps: ['$dlSetError', '$getFunctionAddress', '$addFunction'],
   _dlsym_js__sig: 'ppp',
-  _dlsym_js: function(handle, symbol) {
+  _dlsym_js: function(handle, symbol, symbolIndex) {
     // void *dlsym(void *restrict handle, const char *restrict name);
     // http://pubs.opengroup.org/onlinepubs/009695399/functions/dlsym.html
     symbol = UTF8ToString(symbol);
     var result;
+    var newSymIndex;
 
     if (handle == {{{ cDefine('RTLD_DEFAULT') }}}) {
-      result = resolveGlobalSymbol(symbol, true);
+      var resolved = resolveGlobalSymbol(symbol, true);
+      result = resolved[0];
       if (!result) {
         dlSetError('Tried to lookup unknown symbol "' + symbol + '" in dynamic lib: RTLD_DEFAULT');
         return 0;
       }
+      name = resolved[1];
+      newSymIndex = Object.keys(wasmImports).indexOf(name);
     } else {
       var lib = LDSO.loadedLibsByHandle[handle];
 #if ASSERTIONS
@@ -1085,16 +1117,21 @@ var LibraryDylink = {
         dlSetError('Tried to lookup unknown symbol "' + symbol + '" in dynamic lib: ' + lib.name)
         return 0;
       }
+      newSymIndex = Object.keys(lib.module).indexOf(symbol);
 #if !WASM_BIGINT
-      result = lib.module['orig$' + symbol];
-      if (!result)
+      var origSym = 'orig$' + symbol;
+      result = lib.module[origSym];
+      if (result) {
+        newSymIndex = Object.keys(lib.module).indexOf(origSym);
+      }
+      else
 #endif
       result = lib.module[symbol];
     }
 
     if (typeof result == 'function') {
 #if DYLINK_DEBUG
-      dbg('dlsym: ' + symbol + ' getting table slot for: ' + result);
+      dbg('dlsym_js: ' + symbol + ' getting table slot for: ' + result);
 #endif
 
 #if ASYNCIFY
@@ -1103,14 +1140,26 @@ var LibraryDylink = {
         result = result.orig;
       }
 #endif
-      // Insert the function into the wasm table.  If its a direct wasm function
-      // the second argument will not be needed.  If its a JS function we rely
-      // on the `sig` attribute being set based on the `<func>__sig` specified
-      // in library JS file.
-      result = addFunction(result, result.sig);
+      var addr = getFunctionAddress(result);
+      if (addr) {
+#if DYLINK_DEBUG
+        dbg('symbol already exists in table: ' + symbol);
+#endif
+        result = addr;
+      } else {
+        // Insert the function into the wasm table.  If its a direct wasm
+        // function the second argument will not be needed.  If its a JS
+        // function we rely on the `sig` attribute being set based on the
+        // `<func>__sig` specified in library JS file.
+        result = addFunction(result, result.sig);
+#if DYLINK_DEBUG
+        dbg('adding symbol to table: ' + symbol);
+#endif
+        {{{ makeSetValue('symbolIndex', 0, 'newSymIndex', '*') }}};
+      }
     }
 #if DYLINK_DEBUG
-    dbg('dlsym: ' + symbol + ' -> ' + result);
+    dbg('dlsym_js: ' + symbol + ' -> ' + result);
 #endif
     return result;
   },

src/parseTools.js

@@ -1114,7 +1114,7 @@ function getEntryFunction() {
     entryFunction = '_emscripten_proxy_main';
   }
   if (MAIN_MODULE) {
-    return `resolveGlobalSymbol('${entryFunction}');`
+    return `resolveGlobalSymbol('${entryFunction}')[0];`
   }
   return '_' + entryFunction;
 }