Respect runtime paths when loading shared libraries

src/lib/libdylink.js

@@ -48,6 +48,59 @@ var LibraryDylink = {
     registerWasmPlugin();
     `,
   $preloadedWasm: {},
+
+  $locateLibraryFromFS: (filename, searchDirs) => {
+    // Find the library in the filesystem.
+    // returns null if not found.
+    if (!(typeof PATH === 'object' && typeof FS === 'object')) {
+      // FILESYSTEM comes with FS and PATH modules
+      // so this will always pass, but closure compiler complains if we don't check this here.
+      return null
+    }
+
+    var candidates = [];
+    if (PATH.isAbs(filename)) {
+      candidates.push(filename);
+    } else if (searchDirs) {
+      for (var i = 0; i < searchDirs.length; i++) {
+        candidates.push(PATH.join(searchDirs[i], filename));
+      }
+    } else {
+      return null;
+    }
+
+    for (var i = 0; i < candidates.length; i++) {
+      var path = candidates[i];
+      try {
+        var res = FS.lookupPath(path);
+        return res.path;
+      } catch(e) {
+        // do nothing is file is not found
+      }
+    }
+
+    return null;
+  },
+
+  $readLibraryFromFS: (path) => {
+    var data = FS.readFile(path, {encoding: 'binary'});
+    return data;
+  },
+
+  $getDefaultLibDirs__deps: ['$ENV'],
+  $getDefaultLibDirs: () => {
+    return ENV['LD_LIBRARY_PATH']?.split(':') ?? [];
+  },
+
+  $replaceORIGIN: (parentLibPath, rpath) => {
+    if (rpath.startsWith('$ORIGIN')) {
+      // TODO: what to do if we only know the relative path of the file? It will return "." here.
+      var origin = PATH.dirname(parentLibPath);
+      return rpath.replace('$ORIGIN', origin);
+    }
+
+    return rpath
+  },
 #endif // FILESYSTEM
 
   $isSymbolDefined: (symName) => {
@@ -889,12 +942,12 @@ var LibraryDylink = {
     if (flags.loadAsync) {
       return metadata.neededDynlibs
         .reduce((chain, dynNeeded) => chain.then(() =>
-          loadDynamicLibrary(dynNeeded, flags, localScope)
+          loadDynamicLibrary(dynNeeded, flags, localScope, { parentLibPath: libName, paths: metadata.runtimePaths })
         ), Promise.resolve())
         .then(loadModule);
     }
 
-    metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
+    metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope, { parentLibPath: libName, paths: metadata.runtimePaths }));
     return loadModule();
   },
 
@@ -949,6 +1002,10 @@ var LibraryDylink = {
                               '$asyncLoad',
 #if FILESYSTEM
                               '$preloadedWasm',
+                              '$locateLibraryFromFS',
+                              '$readLibraryFromFS',
+                              '$getDefaultLibDirs',
+                              '$replaceORIGIN',
 #endif
 #if DYNCALLS || !WASM_BIGINT
                               '$registerDynCallSymbols',
@@ -959,11 +1016,24 @@ var LibraryDylink = {
      * @param {number=} handle
      * @param {Object=} localScope
      */`,
-  $loadDynamicLibrary: function(libName, flags = {global: true, nodelete: true}, localScope, handle) {
+  $loadDynamicLibrary: function(libName, flags = {global: true, nodelete: true}, localScope, rpath = {parentLibPath: '', paths: []}, handle) {
 #if DYLINK_DEBUG
     dbg(`loadDynamicLibrary: ${libName} handle: ${handle}`);
     dbg(`existing: ${Object.keys(LDSO.loadedLibsByName)}`);
 #endif
+
+#if FILESYSTEM
+      var runtimePathsAbs = (rpath.paths || []).map((p) => replaceORIGIN(rpath.parentLibPath, p));
+      var searchDirs = getDefaultLibDirs().concat(runtimePathsAbs);
+      var libNameAbs = locateLibraryFromFS(libName, searchDirs);
+      if (libNameAbs) {
+        libName = libNameAbs;
+      }
+#if DYLINK_DEBUG
+      dbg(`checking filesystem: ${libName}: ${libNameAbs ? 'found' : 'not found'}`);
+#endif
+#endif
+
     // when loadDynamicLibrary did not have flags, libraries were loaded
     // globally & permanently
 
@@ -1024,6 +1094,18 @@ var LibraryDylink = {
         }
       }
 
+#if FILESYSTEM
+      if (libNameAbs) {
+        var libData = readLibraryFromFS(libName);
+        if (libData) {
+#if DYLINK_DEBUG
+          dbg(`loaded library from filesystem: ${libName}`);
+#endif
+          return flags.loadAsync ? Promise.resolve(libData) : libData;
+        }
+      }
+#endif
+
       var libFile = locateFile(libName);
       if (flags.loadAsync) {
         return asyncLoad(libFile);
@@ -1142,11 +1224,11 @@ var LibraryDylink = {
     }
 
     if (jsflags.loadAsync) {
-      return loadDynamicLibrary(filename, combinedFlags, localScope, handle);
+      return loadDynamicLibrary(filename, combinedFlags, localScope, {}, handle);
     }
 
     try {
-      return loadDynamicLibrary(filename, combinedFlags, localScope, handle)
+      return loadDynamicLibrary(filename, combinedFlags, localScope, {}, handle)
     } catch (e) {
 #if ASSERTIONS
       err(`Error in loading dynamic library ${filename}: ${e}`);

src/lib/libwasmfs.js

@@ -512,7 +512,7 @@ addToLibrary({
     return FS_mknod(path, mode, 0);
   },
 
-  $FS_writeFile__deps: ['_wasmfs_write_file', '$stackSave', '$stackRestore'],
+  $FS_writeFile__deps: ['_wasmfs_write_file', '$stackSave', '$stackRestore', 'malloc', 'free'],
   $FS_writeFile: (path, data) => {
     var sp = stackSave();
     var pathBuffer = stringToUTF8OnStack(path);

test/other/codesize/test_codesize_hello_dylink.gzsize

@@ -1 +1 @@
-5892
+6148

test/other/codesize/test_codesize_hello_dylink.jssize

@@ -1 +1 @@
-12932
+13509

test/test_other.py

@@ -7662,6 +7662,135 @@ def test_ld_library_path(self, args):
     self.assertContained('Hello4', out)
     self.assertContained('Ok', out)
 
+  def test_ld_library_path_dependencies(self):
+    create_file('hello1_dep.c', r'''
+#include<stdio.h>
+
+void hello1_2() {
+  printf ("Hello1_2\n");
+  return;
+}
+''')
+    create_file('hello1.c', r'''
+#include <stdio.h>
+
+void hello1_2();
+
+void hello1() {
+  printf ("Hello1\n");
+  hello1_2();
+  return;
+}
+''')
+    create_file('pre.js', r'''
+Module.preRun = () => {
+  ENV['LD_LIBRARY_PATH']='/lib:/usr/lib:/usr/local/lib';
+};
+''')
+    create_file('main.c', r'''
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+
+int main() {
+  void *h;
+  void (*f)();
+  double (*f2)(double);
+
+  h = dlopen("libhello1.wasm", RTLD_NOW);
+  assert(h);
+  f = dlsym(h, "hello1");
+  assert(f);
+  f();
+  dlclose(h);
+
+  printf("Ok\n");
+
+  return 0;
+}
+''')
+    os.mkdir('subdir')
+    self.run_process([EMCC, '-o', 'subdir/libhello1_dep.so', 'hello1_dep.c', '-sSIDE_MODULE'])
+    self.run_process([EMCC, '-o', 'hello1.wasm', 'hello1.c', '-sSIDE_MODULE', 'subdir/libhello1_dep.so'])
+    self.run_process([EMCC, '--profiling-funcs', '-o', 'main.js', 'main.c', '-sMAIN_MODULE=2', '-sINITIAL_MEMORY=32Mb',
+                      '--embed-file', 'hello1.wasm@/libhello1.wasm',
+                      '--embed-file', 'subdir/libhello1_dep.so@/usr/lib/libhello1_dep.so',
+                      'hello1.wasm', '-sNO_AUTOLOAD_DYLIBS',
+                      '-L./subdir', '-lhello1_dep', '--pre-js', 'pre.js'])
+    out = self.run_js('main.js')
+    self.assertContained('Hello1', out)
+    self.assertContained('Hello1_2', out)
+    self.assertContained('Ok', out)
+
+  def test_rpath_dependencies(self):
+    create_file('hello1_dep.c', r'''
+#include<stdio.h>
+
+void hello1_2() {
+  printf ("Hello1_2\n");
+  return;
+}
+''')
+    create_file('hello1.c', r'''
+#include <stdio.h>
+
+void hello1_2();
+
+void hello1() {
+  printf ("Hello1\n");
+  hello1_2();
+  return;
+}
+''')
+    create_file('main.c', r'''
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+
+int main() {
+  void *h;
+  void (*f)();
+  double (*f2)(double);
+
+  h = dlopen("/usr/lib/libhello1.wasm", RTLD_NOW);
+  assert(h);
+  f = dlsym(h, "hello1");
+  assert(f);
+  f();
+  dlclose(h);
+
+  printf("Ok\n");
+
+  return 0;
+}
+''')
+    os.mkdir('subdir')
+
+    def _build(rpath_flag):
+      self.run_process([EMCC, '-o', 'subdir/libhello1_dep.so', 'hello1_dep.c', '-sSIDE_MODULE'])
+      self.run_process([EMCC, '-o', 'hello1.wasm', 'hello1.c', '-sSIDE_MODULE', 'subdir/libhello1_dep.so'] + rpath_flag)
+      self.run_process([EMCC, '--profiling-funcs', '-o', 'main.js', 'main.c', '-sMAIN_MODULE=2', '-sINITIAL_MEMORY=32Mb',
+                        '--embed-file', 'hello1.wasm@/usr/lib/libhello1.wasm',
+                        '--embed-file', 'subdir/libhello1_dep.so@/usr/lib/subdir/libhello1_dep.so',
+                        'hello1.wasm', '-sNO_AUTOLOAD_DYLIBS',
+                        '-L./subdir', '-lhello1_dep'])
+
+    # case 1) without rpath: fail to locate the library
+    _build([])
+    out = self.run_js('main.js', assert_returncode=NON_ZERO)
+    self.assertContained(r"no such file or directory, open '.*libhello1_dep\.so'", out, regex=True)
+
+    # case 2) with rpath: success
+    _build(['-Wl,-rpath,$ORIGIN/subdir'])
+    out = self.run_js('main.js')
+    self.assertContained('Hello1', out)
+    self.assertContained('Hello1_2', out)
+    self.assertContained('Ok', out)
+
   def test_dlopen_bad_flags(self):
     create_file('main.c', r'''
 #include <dlfcn.h>