Use basename of main executable in POSIX-DYLD on Android.

[sas]

Summary

The Android dynamic linker reports only the basename of each SO entry, so for
the above check to be successful, we need to compare it to the basename of the
main executable.

This also has a nasty side-effect when working with older version of
Android (verified on platform version 16), and debugging PIE
executables: the dynamic linker has a bug and reports the load address
of the main executable (which is a shared object, because PIE) to be 0.
We then try to update the list of loaded sections for all shared
objects, including the main executable, and set the load address to 0,
which breaks everything that relies on resolving addresses in the main
executable (breakpoints, stepping, etc). This commit also fixes that broken
behavior when debugging on older Androids. This bug doesn't happen on newer
Android versions (verified for Android L).

[clayborg]

lgtm

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h

protected:
     UpdateSOEntries();
 
     bool
     UpdateSOEntriesForAddition();
 
     bool
     UpdateSOEntriesForDeletion();
 
+    bool
+    SOEntryIsMainExecutable(const SOEntry &entry);
+
     /// Reads the current list of shared objects according to the link map
     /// supplied by the runtime linker.
     bool
     TakeSnapshot(SOEntryList &entry_list);
 
     enum PThreadField { eSize, eNElem, eOffset };
 
     bool FindMetadata(const char *name, PThreadField field, uint32_t& value);
 };
 
 #endif

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
+#include "llvm/Support/Path.h"
+
 #include "DYLDRendezvous.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 /// Locates the address of the rendezvous structure.  Returns the address on
 /// success and LLDB_INVALID_ADDRESS on failure.
 static addr_t
if (m_current.map_addr == 0)
         return false;
 
     for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
     {
         if (!ReadSOEntryFromMemory(cursor, entry))
             return false;
 
         // Only add shared libraries and not the executable.
-        // On Linux this is indicated by an empty path in the entry.
-        // On FreeBSD it is the name of the executable.
-        if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
+        if (SOEntryIsMainExecutable(entry))
             continue;
 
         pos = std::find(m_soentries.begin(), m_soentries.end(), entry);
         if (pos == m_soentries.end())
         {
             m_soentries.push_back(entry);
             m_added_soentries.push_back(entry);
         }
for (iterator I = begin(); I != end(); ++I)
             m_removed_soentries.push_back(*I);
     }
 
     m_soentries = entry_list;
     return true;
 }
 
 bool
+DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry)
+{
+    // On Linux the executable is indicated by an empty path in the entry. On
+    // FreeBSD it is the full path to the executable. On Android, it is the
+    // basename of the executable.
+
+    auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
+    auto os_type = triple.getOS();
+    auto env_type = triple.getEnvironment();
+
+    switch (os_type) {
+        case llvm::Triple::FreeBSD:
+            return ::strcmp(entry.path.c_str(), m_exe_path) == 0;
+        case llvm::Triple::Linux:
+            return entry.path.empty() || (env_type == llvm::Triple::Android &&
+                   llvm::sys::path::filename(m_exe_path) == entry.path);
+        default:
+            return false;
+    }
+}
+
+bool
 DYLDRendezvous::TakeSnapshot(SOEntryList &entry_list)
 {
     SOEntry entry;
 
     if (m_current.map_addr == 0)
         return false;
 
     for (addr_t cursor = m_current.map_addr; cursor != 0; cursor = entry.next)
     {
         if (!ReadSOEntryFromMemory(cursor, entry))
             return false;
 
         // Only add shared libraries and not the executable.
-        // On Linux this is indicated by an empty path in the entry.
-        // On FreeBSD it is the name of the executable.
-        if (entry.path.empty() || ::strcmp(entry.path.c_str(), m_exe_path) == 0)
+        if (SOEntryIsMainExecutable(entry))
             continue;
 
         entry_list.push_back(entry);
     }
 
     return true;
 }