PNaCl Dynamic Linking: Added portable dependencies to shared objects.

src/untrusted/pll_loader/pll_loader.cc

 // Copyright 2016 The Native Client Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "native_client/src/untrusted/pll_loader/pll_loader.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
+#include <string>
 
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/untrusted/pnacl_dynloader/dynloader.h"
 
 namespace {
 
 // This is a simple implementation that does not support multiple threads.
 // It demonstrates how we can optimize if we know that pthread_create()
 // will never be called.
 void *TLSBlockGetter(PLLTLSBlockGetter *closure) {
@@ skipping 63 matching lines @@
   return base;
 }
 
 void ModuleSet::SetSonameSearchPath(const std::vector<std::string> &dir_list) {
   search_path_ = dir_list;
 }
 
 void ModuleSet::AddBySoname(const char *soname) {
   // TODO(smklein): Deduplicate rather than failing once dependencies are added.
   if (sonames_.count(soname) != 0) {
-    NaClLog(LOG_FATAL, "PLL Loader found duplicate soname: %s\n", soname);
+    // This module has already been added to the ModuleSet.

[Mark Seaborn, 2016/03/30 23:24:57]

I think your current test case doesn't actually verify that a given soname isn't
loaded twice.

If you wanted to test that, you could have AddBySoname() return the PLLRoot*,
and change pll_loader_test.cc t check that it returns the same pointer when
called a second time for the same soname.  (You could do that as a separate
change.)

[Sean Klein, 2016/04/01 23:12:24]

This is behavior I'm adding in this CL; I'll test it in this CL.

Instead of checking for the same PLLRoot, I'll check that the second invocation
returns NULL.

This will require returning "void *" from AddByFilename as well.

+    return;
   }
   sonames_.insert(soname);
 
   // Actually load the module implied by the soname.
   for (auto path : search_path_) {
     // Appending "/" might be unnecessary, but "foo/bar" and "foo//bar" should
     // point to the same file.
     path.append("/");
     path.append(soname);
+    path.append(".translated");
     struct stat buf;
     if (stat(path.c_str(), &buf) == 0) {
       AddByFilename(path.c_str());
       return;
     }
   }
 
-  NaClLog(LOG_FATAL, "PLL Loader cannot find shared object file: %s\n", soname);
+  NaClLog(LOG_FATAL, "PLL Loader cannot find shared object: %s\n", soname);
 }
 
 void ModuleSet::AddByFilename(const char *filename) {
   void *pso_root;
   int err = pnacl_load_elf_file(filename, &pso_root);
   if (err != 0) {
-    NaClLog(LOG_FATAL, "pnacl_load_elf_file() failed: errno=%d\n", err);
+    NaClLog(LOG_FATAL,
+            "pll_loader could not open %s: errno=%d\n", filename, err);
   }
-  modules_.push_back(PLLModule((const PLLRoot *) pso_root));
+  const PLLModule module = PLLModule((const PLLRoot *) pso_root);
+  modules_.push_back(module);
+  const char *dependencies_list = module.GetDependenciesList();
+  size_t dependencies_count = module.GetDependenciesCount();
+  size_t string_index = 0;
+  for (size_t i = 0; i < dependencies_count; i++) {
+    std::string dependency_filename(dependencies_list + string_index);
+    string_index += dependency_filename.length() + 1;
+    AddBySoname(dependency_filename.c_str());
+  }
 }
 
 void *ModuleSet::GetSym(const char *name) {
   for (auto &module : modules_) {
     if (void *sym = module.GetExportedSym(name))
       return sym;
   }
   return NULL;
 }
 
 void ModuleSet::ResolveRefs() {
   for (auto &module : modules_) {
     for (size_t index = 0, count = module.root()->import_count;
          index < count; ++index) {
       const char *sym_name = module.GetImportedSymbolName(index);
       uintptr_t sym_value = (uintptr_t) GetSym(sym_name);
       if (sym_value == 0) {
         NaClLog(LOG_FATAL, "Undefined symbol: \"%s\"\n", sym_name);
       }
       *(uintptr_t *) module.root()->imported_ptrs[index] += sym_value;
     }
 
     // Initialize TLS.
     if (PLLTLSBlockGetter *tls_block_getter = module.root()->tls_block_getter) {
       tls_block_getter->func = TLSBlockGetter;
       tls_block_getter->arg = module.InstantiateTLSBlock();
     }
   }
 }