Look for both .debug and dsym debugging symbol information for stripped executable.

[flackr]

Summary

Currently Symbols::LocateExecutableSymbolFile on MacOSX only looks for external dsym debugging information, however if running on a stripped dwarf executable it should also check for a .debug file as well.

[flackr]

I wanted to float this patch by you to get an early impression. Previously we only looked for dsym debugging info on mac and only .debug on linux. This patch should allow us to locate either. What I've tried to do is move as much of the symbol location into common/Symbols.cpp that I can. What do you think of this direction?

Interestingly the Test TestSharedLibStrippedSymbols.py should have caught this on mac except that test/make/Makefile.rules only seems to strip dsym on darwin. I can try to fix this too and verify with this patch.

source/Host/common/Symbols.cpp

146 ↗

(On Diff #24173)

I didn't notice this when I was moving the code over but I'll remove this commented out code.

[flackr]

source/Host/common/Symbols.cpp

219 ↗

(On Diff #24173)

Also, is there a better place to put these forward declarations? My impression was that include/Host/Symbols.h was for things we wanted to publicly expose whereas this is sort of an implementation detail, but if it can go there I will move it.

[tberghammer]

I don't like having these forward declarations but I think the problem have a different root cause.

I would do the following changes in order to get rid of them and clean up the code further:

• Remove (almost) all conditional compilation because when we compile these files into LLDB we need all implementation
• Move all OSX and MachO specific code into macosx/Symbols.cpp
• Make the common class the base class of the OSX specific class and replace the static functions with virtual ones for greater flexibility

[clayborg]

So there is some code "source/Host/macosx/Symbols.cpp":

SkinnyMachOFileContainsArchAndUUID(...)
UniversalMachOFileContainsArchAndUUID(...)
FileAtPathContainsArchAndUUID(...)

That was created long before I eventually created the static class function:

static size_t
ObjectFile::GetModuleSpecifications (const FileSpec &file,
                         lldb::offset_t file_offset,
                         lldb::offset_t file_size,
                         ModuleSpecList &specs);

We should switch over to using ObjectFile::GetModuleSpecifications() in both "source/Host/macosx/Symbols.cpp" and if needed in "source/Host/common/Symbols.cpp" and update this patch. This should reduce the size of the patch considerably.

source/Host/common/Symbols.cpp

33–43 ↗

(On Diff #24173)

This function is not needed, please use the static class function:

size_t ObjectFile::GetModuleSpecifications (const FileSpec &file,
                             lldb::offset_t file_offset,
                             lldb::offset_t file_size,
                             ModuleSpecList &specs);

114–123 ↗

(On Diff #24173)

This function isn't needed please use ObjectFile::GetModuleSpecifications()

177–183 ↗

(On Diff #24173)

This function isn't needed, please use ObjectFile::GetModuleSpecifications().

[flackr]

Use ObjectFile::GetModuleSpecifications to check for matching module spec.

[flackr]

Greg, please check if I'm checking the module spec correctly. I'm not sure if I should only be looking for matching UUID and arch whereas the ModuleSpecList::FindMatchingModuleSpec seems like it will check the FileSpec and PlatformFileSpec as well. It passes the stripped symbols test though which I presume is testing it.

In D9174#159961, @tberghammer wrote:

I don't like having these forward declarations but I think the problem have a different root cause.

I would do the following changes in order to get rid of them and clean up the code further:

• Remove (almost) all conditional compilation because when we compile these files into LLDB we need all implementation
• Move all OSX and MachO specific code into macosx/Symbols.cpp
• Make the common class the base class of the OSX specific class and replace the static functions with virtual ones for greater flexibility

At this point I think the only ugly bit is LocateMacOSXFilesUsingDebugSymbols. I could add this to the Symbols.h header to avoid the need for conditional compilation.

[clayborg]

Looks good.

[flackr]

The lovely test suite caught a couple errors which I've addressed in this patch

• NULL is acceptable input for arch or uuid to Symbols::FindSymbolFileInBundle to ignore that attribute.
• Properly check for dsym symbols even if there's no symbol filename in the module spec.

[clayborg]

Looks good as long as the test suite is happy.

lldb/trunk/source/Host/common/Symbols.cpp

 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/SafeMachO.h"
 
 #include "llvm/Support/FileSystem.h"
 
+// From MacOSX system header "mach/machine.h"
+typedef int cpu_type_t;
+typedef int cpu_subtype_t;
+
 using namespace lldb;
 using namespace lldb_private;
+using namespace llvm::MachO;
+
+#if defined(__APPLE__)
+
+// Forward declaration of method defined in source/Host/macosx/Symbols.cpp
+int
+LocateMacOSXFilesUsingDebugSymbols
+(
+    const ModuleSpec &module_spec,
+    FileSpec *out_exec_fspec,   // If non-NULL, try and find the executable
+    FileSpec *out_dsym_fspec    // If non-NULL try and find the debug symbol file
+);
+
+#else
+
+int
+LocateMacOSXFilesUsingDebugSymbols
+(
+    const ModuleSpec &module_spec,
+    FileSpec *out_exec_fspec,   // If non-NULL, try and find the executable
+    FileSpec *out_dsym_fspec    // If non-NULL try and find the debug symbol file
+) {
+    // Cannot find MacOSX files using debug symbols on non MacOSX.
+    return 0;
+}
+
+#endif
+
+static bool
+LocateDSYMInVincinityOfExecutable (const ModuleSpec &module_spec, FileSpec &dsym_fspec)
+{
+    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
+    if (exec_fspec)
+    {
+        char path[PATH_MAX];
+        if (exec_fspec->GetPath(path, sizeof(path)))
+        {
+            // Make sure the module isn't already just a dSYM file...
+            if (strcasestr(path, ".dSYM/Contents/Resources/DWARF") == NULL)
+            {
+                size_t obj_file_path_length = strlen(path);
+                ::strncat(path, ".dSYM/Contents/Resources/DWARF/", sizeof(path) - strlen(path) - 1);
+                ::strncat(path, exec_fspec->GetFilename().AsCString(), sizeof(path) - strlen(path) - 1);
+
+                dsym_fspec.SetFile(path, false);
+
+                ModuleSpecList module_specs;
+                ModuleSpec matched_module_spec;
+                if (dsym_fspec.Exists() &&
+                    ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0, module_specs) &&
+                    module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
+                {
+                    return true;
+                }
+                else
+                {
+                    path[obj_file_path_length] = '\0';
+
+                    char *last_dot = strrchr(path, '.');
+                    while (last_dot != NULL && last_dot[0])
+                    {
+                        char *next_slash = strchr(last_dot, '/');
+                        if (next_slash != NULL)
+                        {
+                            *next_slash = '\0';
+                            ::strncat(path, ".dSYM/Contents/Resources/DWARF/", sizeof(path) - strlen(path) - 1);
+                            ::strncat(path, exec_fspec->GetFilename().AsCString(), sizeof(path) - strlen(path) - 1);
+                            dsym_fspec.SetFile(path, false);
+                            if (dsym_fspec.Exists() &&
+                                ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0, module_specs) &&
+                                module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
+                            {
+                                return true;
+                            }
+                            else
+                            {
+                                *last_dot = '\0';
+                                char *prev_slash = strrchr(path, '/');
+                                if (prev_slash != NULL)
+                                    *prev_slash = '\0';
+                                else
+                                    break;
+                            }
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    dsym_fspec.Clear();
+    return false;
+}
 
-#if defined (__linux__) || defined (__FreeBSD__)
+FileSpec
+LocateExecutableSymbolFileDsym (const ModuleSpec &module_spec)
+{
+    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
+    const ArchSpec *arch = module_spec.GetArchitecturePtr();
+    const UUID *uuid = module_spec.GetUUIDPtr();
+
+    Timer scoped_timer (__PRETTY_FUNCTION__,
+                        "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)",
+                        exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
+                        arch ? arch->GetArchitectureName() : "<NULL>",
+                        uuid);
+
+    FileSpec symbol_fspec;
+    // First try and find the dSYM in the same directory as the executable or in
+    // an appropriate parent directory
+    if (LocateDSYMInVincinityOfExecutable (module_spec, symbol_fspec) == false)
+    {
+        // We failed to easily find the dSYM above, so use DebugSymbols
+        LocateMacOSXFilesUsingDebugSymbols (module_spec, NULL, &symbol_fspec);
+    }
+    return symbol_fspec;
+}
 
 FileSpec
 Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
 {
-    // FIXME
-    return FileSpec();
+    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
+    const ArchSpec *arch = module_spec.GetArchitecturePtr();
+    const UUID *uuid = module_spec.GetUUIDPtr();
+    Timer scoped_timer (__PRETTY_FUNCTION__,
+                        "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
+                        exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
+                        arch ? arch->GetArchitectureName() : "<NULL>",
+                        uuid);
+
+    FileSpec objfile_fspec;
+    ModuleSpecList module_specs;
+    ModuleSpec matched_module_spec;
+    if (exec_fspec &&
+        ObjectFile::GetModuleSpecifications(*exec_fspec, 0, 0, module_specs) &&
+        module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
+    {
+        objfile_fspec = exec_fspec;
+    }
+    else
+    {
+        LocateMacOSXFilesUsingDebugSymbols (module_spec, &objfile_fspec, NULL);
+    }
+    return objfile_fspec;
 }
 
 FileSpec
 Symbols::LocateExecutableSymbolFile (const ModuleSpec &module_spec)
 {
     const char *symbol_filename = module_spec.GetSymbolFileSpec().GetFilename().AsCString();
-    if (!symbol_filename || !symbol_filename[0])
-        return FileSpec();
-
+    if (symbol_filename && symbol_filename[0])
+    {
         FileSpecList debug_file_search_paths (Target::GetDefaultDebugFileSearchPaths());
 
         // Add module directory.
         const ConstString &file_dir = module_spec.GetFileSpec().GetDirectory();
         debug_file_search_paths.AppendIfUnique (FileSpec(file_dir.AsCString("."), true));
 
         // Add current working directory.
         debug_file_search_paths.AppendIfUnique (FileSpec(".", true));
 
         // Add /usr/lib/debug directory.
         debug_file_search_paths.AppendIfUnique (FileSpec("/usr/lib/debug", true));
 
         std::string uuid_str;
         const UUID &module_uuid = module_spec.GetUUID();
         if (module_uuid.IsValid())
         {
             // Some debug files are stored in the .build-id directory like this:
             //   /usr/lib/debug/.build-id/ff/e7fe727889ad82bb153de2ad065b2189693315.debug
             uuid_str = module_uuid.GetAsString("");
             uuid_str.insert (2, 1, '/');
             uuid_str = uuid_str + ".debug";
         }
 
         // Get directory of our module. Needed to check debug files like this:
         //   /usr/lib/debug/usr/lib/library.so.debug
         std::string module_directory = module_spec.GetFileSpec().GetDirectory().AsCString();
 
         size_t num_directories = debug_file_search_paths.GetSize();
         for (size_t idx = 0; idx < num_directories; ++idx)
         {
             FileSpec dirspec = debug_file_search_paths.GetFileSpecAtIndex (idx);
             dirspec.ResolvePath();
             if (!dirspec.Exists() || !dirspec.IsDirectory())
                 continue;
 
             std::vector<std::string> files;
             std::string dirname = dirspec.GetPath();
 
             files.push_back (dirname + "/" + symbol_filename);
             files.push_back (dirname + "/.debug/" + symbol_filename);
             files.push_back (dirname + "/.build-id/" + uuid_str);
             files.push_back (dirname + module_directory + "/" + symbol_filename);
 
             const uint32_t num_files = files.size();
             for (size_t idx_file = 0; idx_file < num_files; ++idx_file)
             {
                 const std::string &filename = files[idx_file];
                 FileSpec file_spec (filename.c_str(), true);
 
                 if (llvm::sys::fs::equivalent (file_spec.GetPath(), module_spec.GetFileSpec().GetPath()))
                     continue;
 
                 if (file_spec.Exists())
                 {
                     lldb_private::ModuleSpecList specs;
                     const size_t num_specs = ObjectFile::GetModuleSpecifications (file_spec, 0, 0, specs);
                     assert (num_specs <= 1 && "Symbol Vendor supports only a single architecture");
                     if (num_specs == 1)
                     {
                         ModuleSpec mspec;
                         if (specs.GetModuleSpecAtIndex (0, mspec))
                         {
                             if (mspec.GetUUID() == module_uuid)
                                 return file_spec;
                         }
                     }
                 }
             }
         }
-
-    return FileSpec();
     }
 
-FileSpec
-Symbols::FindSymbolFileInBundle (const FileSpec& symfile_bundle,
-                                 const lldb_private::UUID *uuid,
-                                 const ArchSpec *arch)
-{
-    // FIXME
-    return FileSpec();
+    return LocateExecutableSymbolFileDsym(module_spec);
 }
 
-bool
-Symbols::DownloadObjectAndSymbolFile (ModuleSpec &module_spec, bool force_lookup)
-{
-    // Fill in the module_spec.GetFileSpec() for the object file and/or the
-    // module_spec.GetSymbolFileSpec() for the debug symbols file.
-    return false;
-}
-
-#elif !defined (__APPLE__)
-
-FileSpec
-Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
-{
-    // FIXME
-    return FileSpec();
-}
-
-FileSpec
-Symbols::LocateExecutableSymbolFile (const ModuleSpec &module_spec)
-{
-    // FIXME
-    return FileSpec();
-}
+#if !defined (__APPLE__)
 
 FileSpec
 Symbols::FindSymbolFileInBundle (const FileSpec& symfile_bundle,
                                  const lldb_private::UUID *uuid,
                                  const ArchSpec *arch)
 {
+    // FIXME
     return FileSpec();
 }
 
 bool
 Symbols::DownloadObjectAndSymbolFile (ModuleSpec &module_spec, bool force_lookup)
 {
     // Fill in the module_spec.GetFileSpec() for the object file and/or the
     // module_spec.GetSymbolFileSpec() for the debug symbols file.
     return false;
 }
 
 #endif

lldb/trunk/source/Host/macosx/Symbols.cpp

 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/CleanUp.h"
 #include "Host/macosx/cfcpp/CFCBundle.h"
 #include "Host/macosx/cfcpp/CFCData.h"
 #include "Host/macosx/cfcpp/CFCReleaser.h"
 #include "Host/macosx/cfcpp/CFCString.h"
 #include "mach/machine.h"
 
-
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::MachO;
 
 #if !defined (__arm__) && !defined (__arm64__) && !defined (__aarch64__) // No DebugSymbols on the iOS devices
 extern "C" {
 
 CFURLRef DBGCopyFullDSYMURLForUUID (CFUUIDRef uuid, CFURLRef exec_url);
 CFDictionaryRef DBGCopyDSYMPropertyLists (CFURLRef dsym_url);
 
 }
 #endif
 
-static bool
-SkinnyMachOFileContainsArchAndUUID
-(
-    const FileSpec &file_spec,
-    const ArchSpec *arch,
-    const lldb_private::UUID *uuid,   // the UUID we are looking for
-    off_t file_offset,
-    DataExtractor& data,
-    lldb::offset_t data_offset,
-    const uint32_t magic
-)
-{
-    assert(magic == MH_MAGIC || magic == MH_CIGAM || magic == MH_MAGIC_64 || magic == MH_CIGAM_64);
-    if (magic == MH_MAGIC || magic == MH_MAGIC_64)
-        data.SetByteOrder (lldb::endian::InlHostByteOrder());
-    else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
-        data.SetByteOrder (eByteOrderLittle);
-    else
-        data.SetByteOrder (eByteOrderBig);
-
-    uint32_t i;
-    const uint32_t cputype      = data.GetU32(&data_offset);    // cpu specifier
-    const uint32_t cpusubtype   = data.GetU32(&data_offset);    // machine specifier
-    data_offset+=4; // Skip mach file type
-    const uint32_t ncmds        = data.GetU32(&data_offset);    // number of load commands
-    const uint32_t sizeofcmds   = data.GetU32(&data_offset);    // the size of all the load commands
-    data_offset+=4; // Skip flags
-
-    // Check the architecture if we have a valid arch pointer
-    if (arch)
-    {
-        ArchSpec file_arch(eArchTypeMachO, cputype, cpusubtype);
-
-        if (!file_arch.IsCompatibleMatch(*arch))
-            return false;
-    }
-
-    // The file exists, and if a valid arch pointer was passed in we know
-    // if already matches, so we can return if we aren't looking for a specific
-    // UUID
-    if (uuid == NULL)
-        return true;
-
-    if (magic == MH_CIGAM_64 || magic == MH_MAGIC_64)
-        data_offset += 4;   // Skip reserved field for in mach_header_64
-
-    // Make sure we have enough data for all the load commands
-    if (magic == MH_CIGAM_64 || magic == MH_MAGIC_64)
-    {
-        if (data.GetByteSize() < sizeof(struct mach_header_64) + sizeofcmds)
-        {
-            DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset, sizeof(struct mach_header_64) + sizeofcmds));
-            data.SetData (data_buffer_sp);
-        }
-    }
-    else
-    {
-        if (data.GetByteSize() < sizeof(struct mach_header) + sizeofcmds)
-        {
-            DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset, sizeof(struct mach_header) + sizeofcmds));
-            data.SetData (data_buffer_sp);
-        }
-    }
-
-    for (i=0; i<ncmds; i++)
-    {
-        const lldb::offset_t cmd_offset = data_offset;    // Save this data_offset in case parsing of the segment goes awry!
-        uint32_t cmd        = data.GetU32(&data_offset);
-        uint32_t cmd_size   = data.GetU32(&data_offset);
-        if (cmd == LC_UUID)
-        {
-            lldb_private::UUID file_uuid (data.GetData(&data_offset, 16), 16);
-            if (file_uuid == *uuid)
-                return true;
-            return false;
-        }
-        data_offset = cmd_offset + cmd_size;
-    }
-    return false;
-}
-
-bool
-UniversalMachOFileContainsArchAndUUID
-(
-    const FileSpec &file_spec,
-    const ArchSpec *arch,
-    const lldb_private::UUID *uuid,
-    off_t file_offset,
-    DataExtractor& data,
-    lldb::offset_t data_offset,
-    const uint32_t magic
-)
-{
-    assert(magic == FAT_MAGIC || magic == FAT_CIGAM);
-
-    // Universal mach-o files always have their headers encoded as BIG endian
-    data.SetByteOrder(eByteOrderBig);
-
-    uint32_t i;
-    const uint32_t nfat_arch = data.GetU32(&data_offset);   // number of structs that follow
-    const uint32_t fat_header_and_arch_size = sizeof(struct fat_header) + nfat_arch * sizeof(struct fat_arch);
-    if (data.GetByteSize() < fat_header_and_arch_size)
-    {
-        DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset, fat_header_and_arch_size));
-        data.SetData (data_buffer_sp);
-    }
-
-    for (i=0; i<nfat_arch; i++)
-    {
-        cpu_type_t      arch_cputype        = data.GetU32(&data_offset);    // cpu specifier (int)
-        cpu_subtype_t   arch_cpusubtype     = data.GetU32(&data_offset);    // machine specifier (int)
-        uint32_t        arch_offset         = data.GetU32(&data_offset);    // file offset to this object file
-    //  uint32_t        arch_size           = data.GetU32(&data_offset);    // size of this object file
-    //  uint32_t        arch_align          = data.GetU32(&data_offset);    // alignment as a power of 2
-        data_offset += 8;   // Skip size and align as we don't need those
-        // Only process this slice if the cpu type/subtype matches
-        if (arch)
-        {
-            ArchSpec fat_arch(eArchTypeMachO, arch_cputype, arch_cpusubtype);
-            if (!fat_arch.IsExactMatch(*arch))
-                continue;
-        }
-
-        // Create a buffer with only the arch slice date in it
-        DataExtractor arch_data;
-        DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset + arch_offset, 0x1000));
-        arch_data.SetData(data_buffer_sp);
-        lldb::offset_t arch_data_offset = 0;
-        uint32_t arch_magic = arch_data.GetU32(&arch_data_offset);
-
-        switch (arch_magic)
-        {
-        case MH_MAGIC:
-        case MH_CIGAM:
-        case MH_MAGIC_64:
-        case MH_CIGAM_64:
-            if (SkinnyMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset + arch_offset, arch_data, arch_data_offset, arch_magic))
-                return true;
-            break;
-        }
-    }
-    return false;
-}
-
-static bool
-FileAtPathContainsArchAndUUID
-(
-    const FileSpec &file_spec,
-    const ArchSpec *arch,
-    const lldb_private::UUID *uuid
-)
-{
-    DataExtractor data;
-    off_t file_offset = 0;
-    DataBufferSP data_buffer_sp (file_spec.ReadFileContents (file_offset, 0x1000));
-
-    if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0)
-    {
-        data.SetData(data_buffer_sp);
-
-        lldb::offset_t data_offset = 0;
-        uint32_t magic = data.GetU32(&data_offset);
-
-        switch (magic)
-        {
-        // 32 bit mach-o file
-        case MH_MAGIC:
-        case MH_CIGAM:
-        case MH_MAGIC_64:
-        case MH_CIGAM_64:
-            return SkinnyMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic);
-
-        // fat mach-o file
-        case FAT_MAGIC:
-        case FAT_CIGAM:
-            return UniversalMachOFileContainsArchAndUUID (file_spec, arch, uuid, file_offset, data, data_offset, magic);
-
-        default:
-            break;
-        }
-    }
-    return false;
-}
-
-FileSpec
-Symbols::FindSymbolFileInBundle (const FileSpec& dsym_bundle_fspec,
-                                 const lldb_private::UUID *uuid,
-                                 const ArchSpec *arch)
-{
-    char path[PATH_MAX];
-
-    FileSpec dsym_fspec;
-
-    if (dsym_bundle_fspec.GetPath(path, sizeof(path)))
-    {
-        ::strncat (path, "/Contents/Resources/DWARF", sizeof(path) - strlen(path) - 1);
-
-        lldb_utility::CleanUp <DIR *, int> dirp (opendir(path), NULL, closedir);
-        if (dirp.is_valid())
-        {
-            dsym_fspec.GetDirectory().SetCString(path);
-            struct dirent* dp;
-            while ((dp = readdir(dirp.get())) != NULL)
-            {
-                // Only search directories
-                if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN)
-                {
-                    if (dp->d_namlen == 1 && dp->d_name[0] == '.')
-                        continue;
-
-                    if (dp->d_namlen == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.')
-                        continue;
-                }
-
-                if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN)
-                {
-                    dsym_fspec.GetFilename().SetCString(dp->d_name);
-                    if (FileAtPathContainsArchAndUUID (dsym_fspec, arch, uuid))
-                        return dsym_fspec;
-                }
-            }
-        }
-    }
-    dsym_fspec.Clear();
-    return dsym_fspec;
-}
-
-static int
+int
 LocateMacOSXFilesUsingDebugSymbols
 (
     const ModuleSpec &module_spec,
     FileSpec *out_exec_fspec,   // If non-NULL, try and find the executable
     FileSpec *out_dsym_fspec    // If non-NULL try and find the debug symbol file
 )
 {
     int items_found = 0;
if (uuid && uuid->IsValid())
                             // No dictionary, check near the dSYM bundle for an executable that matches...
                             if (::CFURLGetFileSystemRepresentation (dsym_url.get(), true, (UInt8*)path, sizeof(path)-1))
                             {
                                 char *dsym_extension_pos = ::strstr (path, ".dSYM");
                                 if (dsym_extension_pos)
                                 {
                                     *dsym_extension_pos = '\0';
                                     FileSpec file_spec (path, true);
+                                    ModuleSpecList module_specs;
+                                    ModuleSpec matched_module_spec;
                                     switch (file_spec.GetFileType())
                                     {
                                         case FileSpec::eFileTypeDirectory:  // Bundle directory?
                                             {
                                                 CFCBundle bundle (path);
                                                 CFCReleaser<CFURLRef> bundle_exe_url (bundle.CopyExecutableURL ());
                                                 if (bundle_exe_url.get())
                                                 {
                                                     if (::CFURLGetFileSystemRepresentation (bundle_exe_url.get(), true, (UInt8*)path, sizeof(path)-1))
                                                     {
                                                         FileSpec bundle_exe_file_spec (path, true);
-                                                        
-                                                        if (FileAtPathContainsArchAndUUID (bundle_exe_file_spec, arch, uuid))
+                                                        if (ObjectFile::GetModuleSpecifications(bundle_exe_file_spec, 0, 0, module_specs) &&
+                                                            module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
                                                         {
                                                             ++items_found;
                                                             *out_exec_fspec = bundle_exe_file_spec;
                                                         }
                                                     }
                                                 }
                                             }
                                             break;
-                                            
                                         case FileSpec::eFileTypePipe:       // Forget pipes
                                         case FileSpec::eFileTypeSocket:     // We can't process socket files
                                         case FileSpec::eFileTypeInvalid:    // File doesn't exist...
                                             break;
 
                                         case FileSpec::eFileTypeUnknown:
                                         case FileSpec::eFileTypeRegular:
                                         case FileSpec::eFileTypeSymbolicLink:
                                         case FileSpec::eFileTypeOther:
-                                            if (FileAtPathContainsArchAndUUID (file_spec, arch, uuid))
+                                            if (ObjectFile::GetModuleSpecifications(file_spec, 0, 0, module_specs) &&
+                                                module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
+
                                             {
                                                 ++items_found;
                                                 *out_exec_fspec = file_spec;
                                             }
                                             break;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 #endif // #if !defined (__arm__) && !defined (__arm64__) && !defined (__aarch64__)
 
     return items_found;
 }
 
-static bool
-LocateDSYMInVincinityOfExecutable (const ModuleSpec &module_spec, FileSpec &dsym_fspec)
-{
-    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
-    if (exec_fspec)
-    {
-        char path[PATH_MAX];
-        if (exec_fspec->GetPath(path, sizeof(path)))
-        {
-            // Make sure the module isn't already just a dSYM file...
-            if (strcasestr(path, ".dSYM/Contents/Resources/DWARF") == NULL)
-            {
-                size_t obj_file_path_length = strlen(path);
-                strlcat(path, ".dSYM/Contents/Resources/DWARF/", sizeof(path));
-                strlcat(path, exec_fspec->GetFilename().AsCString(), sizeof(path));
+FileSpec
+Symbols::FindSymbolFileInBundle (const FileSpec& dsym_bundle_fspec,
+                                 const lldb_private::UUID *uuid,
+                                 const ArchSpec *arch)
 
-                dsym_fspec.SetFile(path, false);
+    FileSpec dsym_fspec;
 
-                if (dsym_fspec.Exists() && FileAtPathContainsArchAndUUID (dsym_fspec, module_spec.GetArchitecturePtr(), module_spec.GetUUIDPtr()))
-                {
-                    return true;
-                }
-                else
-                {
-                    path[obj_file_path_length] = '\0';
+    if (dsym_bundle_fspec.GetPath(path, sizeof(path)))
+        ::strncat (path, "/Contents/Resources/DWARF", sizeof(path) - strlen(path) - 1);
 
-                    char *last_dot = strrchr(path, '.');
-                    while (last_dot != NULL && last_dot[0])
-                    {
-                        char *next_slash = strchr(last_dot, '/');
-                        if (next_slash != NULL)
-                        {
-                            *next_slash = '\0';
-                            strlcat(path, ".dSYM/Contents/Resources/DWARF/", sizeof(path));
-                            strlcat(path, exec_fspec->GetFilename().AsCString(), sizeof(path));
-                            dsym_fspec.SetFile(path, false);
-                            if (dsym_fspec.Exists() && FileAtPathContainsArchAndUUID (dsym_fspec, module_spec.GetArchitecturePtr(), module_spec.GetUUIDPtr()))
-                                return true;
-                            else
-                            {
-                                *last_dot = '\0';
-                                char *prev_slash = strrchr(path, '/');
-                                if (prev_slash != NULL)
-                                    *prev_slash = '\0';
-                                else
-                                    break;
-                            }
-                        }
-                        else
-                        {
-                            break;
-                        }
-                    }
+        lldb_utility::CleanUp <DIR *, int> dirp (opendir(path), NULL, closedir);
+        if (dirp.is_valid())
+            dsym_fspec.GetDirectory().SetCString(path);
+            struct dirent* dp;
+            while ((dp = readdir(dirp.get())) != NULL)
+                // Only search directories
+                if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN)
+                    if (dp->d_namlen == 1 && dp->d_name[0] == '.')
+                        continue;
+
+                    if (dp->d_namlen == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.')
+                        continue;
+
+                if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN)
+                    dsym_fspec.GetFilename().SetCString(dp->d_name);
+                    ModuleSpecList module_specs;
+                    if (ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0, module_specs))
+                    {
+                        ModuleSpec spec;
+                        for (size_t i = 0; i < module_specs.GetSize(); ++i)
+                        {
+                            assert(module_specs.GetModuleSpecAtIndex(i, spec));
+                            if ((uuid == NULL || (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) &&
+                                (arch == NULL || (spec.GetArchitecturePtr() && spec.GetArchitecture().IsCompatibleMatch(*arch))))
+                            {
+                                return dsym_fspec;
                             }
                         }
                     }
                 }
-    dsym_fspec.Clear();
-    return false;
             }
-
-FileSpec
-Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
-{
-    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
-    const ArchSpec *arch = module_spec.GetArchitecturePtr();
-    const UUID *uuid = module_spec.GetUUIDPtr();
-    Timer scoped_timer (__PRETTY_FUNCTION__,
-                        "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
-                        exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
-                        arch ? arch->GetArchitectureName() : "<NULL>",
-                        uuid);
-
-    FileSpec objfile_fspec;
-    if (exec_fspec && FileAtPathContainsArchAndUUID (exec_fspec, arch, uuid))
-        objfile_fspec = exec_fspec;
-    else
-        LocateMacOSXFilesUsingDebugSymbols (module_spec, &objfile_fspec, NULL);
-    return objfile_fspec;
         }
-
-FileSpec
-Symbols::LocateExecutableSymbolFile (const ModuleSpec &module_spec)
-{
-    const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
-    const ArchSpec *arch = module_spec.GetArchitecturePtr();
-    const UUID *uuid = module_spec.GetUUIDPtr();
-
-    Timer scoped_timer (__PRETTY_FUNCTION__,
-                        "LocateExecutableSymbolFile (file = %s, arch = %s, uuid = %p)",
-                        exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
-                        arch ? arch->GetArchitectureName() : "<NULL>",
-                        uuid);
-
-    FileSpec symbol_fspec;
-    // First try and find the dSYM in the same directory as the executable or in
-    // an appropriate parent directory
-    if (LocateDSYMInVincinityOfExecutable (module_spec, symbol_fspec) == false)
-    {
-        // We failed to easily find the dSYM above, so use DebugSymbols
-        LocateMacOSXFilesUsingDebugSymbols (module_spec, NULL, &symbol_fspec);
     }
-    return symbol_fspec;
+    dsym_fspec.Clear();
+    return dsym_fspec;
 }
 
-
 static bool
 GetModuleSpecInfoFromUUIDDictionary (CFDictionaryRef uuid_dict, ModuleSpec &module_spec)
 {
     bool success = false;
     if (uuid_dict != NULL && CFGetTypeID (uuid_dict) == CFDictionaryGetTypeID ())
     {
         std::string str;
         CFStringRef cf_str;