Get ObjectFileMachO to handle @executable_path in main executable's LC_LOAD_DYLIB commands

[jingham]

Summary

ObjectFileMachO does some work to decode RPATHS & @executable_path and the like. But it wasn't handling the case where an LC_LOAD_DYLIB in the main executable referred to the library by @executable_path. This patch gets that to work.

I also added a test that ensures that we read in a local loaded library from the main executable to exercise this case. The test is currently only enabled on macOS, just because I don't know what other platforms support finding this. If you own such a platform, please adjust the test to include that platform.

[clayborg]

Looks fine.

[jingham]

Closed by r298290.

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/Makefile

+LEVEL = ../../make
+
+DYLIB_NAME := unlikely_name
+DYLIB_CXX_SOURCES := foo.cpp
+CXX_SOURCES := main.cpp
+CFLAGS_EXTRAS += -fPIC
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/TestPreRunDylibs.py

+from __future__ import print_function
+
+import unittest2
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+
+class TestPreRunLibraries(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    @skipIf(oslist=no_match(['darwin','macos']))
+    def test(self):
+        """Test that we find directly linked dylib pre-run."""
+
+        self.build()
+        target = self.dbg.CreateTarget("a.out")
+        self.assertTrue(target, VALID_TARGET)
+
+        # I don't know what the name of a shared library
+        # extension is in general, so instead of using FindModule,
+        # I'll iterate through the module and do a basename match.
+        found_it = False
+        for module in target.modules:
+            file_name = module.GetFileSpec().GetFilename()
+            if file_name.find("unlikely_name") != -1:
+                found_it = True
+                break
+
+        self.assertTrue(found_it, "Couldn't find unlikely_to_occur_name in loaded libraries.")
+
+            

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/foo.h

+LLDB_TEST_API inline int foo1() { return 1; } // !BR1
+
+LLDB_TEST_API inline int foo2() { return 2; } // !BR2
+
+LLDB_TEST_API extern int call_foo1();
+LLDB_TEST_API extern int call_foo2();

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/foo.cpp

+#include "foo.h"
+
+int call_foo1() { return foo1(); }

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/main.cpp

+#include "foo.h"
+
+int call_foo2() { return foo2(); }
+
+int
+main() // !BR_main
+{
+  return call_foo1() + call_foo2();
+}

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

uint32_t ObjectFileMachO::GetDependentModules(FileSpecList &files) {
   uint32_t count = 0;
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     struct load_command load_cmd;
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     std::vector<std::string> rpath_paths;
     std::vector<std::string> rpath_relative_paths;
+    std::vector<std::string> at_exec_relative_paths;
     const bool resolve_path = false; // Don't resolve the dependent file paths
                                      // since they may not reside on this system
     uint32_t i;
     for (i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
       if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
         break;
 
for (i = 0; i < m_header.ncmds; ++i) {
         const char *path = m_data.PeekCStr(name_offset);
         if (path) {
           if (load_cmd.cmd == LC_RPATH)
             rpath_paths.push_back(path);
           else {
             if (path[0] == '@') {
               if (strncmp(path, "@rpath", strlen("@rpath")) == 0)
                 rpath_relative_paths.push_back(path + strlen("@rpath"));
+              else if (strncmp(path, "@executable_path", 
+                       strlen("@executable_path")) == 0)
+                at_exec_relative_paths.push_back(path 
+                                                 + strlen("@executable_path"));
             } else {
               FileSpec file_spec(path, resolve_path);
               if (files.AppendIfUnique(file_spec))
                 count++;
             }
           }
         }
       } break;
 
       default:
         break;
       }
       offset = cmd_offset + load_cmd.cmdsize;
     }
 
-    if (!rpath_paths.empty()) {
-      // Fixup all LC_RPATH values to be absolute paths
-      FileSpec this_file_spec(m_file);
-      this_file_spec.ResolvePath();
+    
+    if (!rpath_paths.empty()) {
+      // Fixup all LC_RPATH values to be absolute paths
       std::string loader_path("@loader_path");
       std::string executable_path("@executable_path");
       for (auto &rpath : rpath_paths) {
         if (rpath.find(loader_path) == 0) {
           rpath.erase(0, loader_path.size());
           rpath.insert(0, this_file_spec.GetDirectory().GetCString());
         } else if (rpath.find(executable_path) == 0) {
           rpath.erase(0, executable_path.size());
if (!rpath_paths.empty()) {
           file_spec = file_spec.GetNormalizedPath();
           if (file_spec.Exists() && files.AppendIfUnique(file_spec)) {
             count++;
             break;
           }
         }
       }
     }
+
+    // We may have @executable_paths but no RPATHS.  Figure those out here.
+    // Only do this if this object file is the executable.  We have no way to
+    // get back to the actual executable otherwise, so we won't get the right
+    // path.
+    if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
+      FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
+      for (const auto &at_exec_relative_path : at_exec_relative_paths) {
+        FileSpec file_spec = 
+            exec_dir.CopyByAppendingPathComponent(at_exec_relative_path);
+        file_spec = file_spec.GetNormalizedPath();
+        if (file_spec.Exists() && files.AppendIfUnique(file_spec)) {
+          count++;
+          break;
+        }
+      }
+    }
   }
   return count;
 }
 
 lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {
   // If the object file is not an executable it can't hold the entry point.
   // m_entry_point_address
   // is initialized to an invalid address, so we can just return that.