Support loading files even when incorrect file name specified by the linker

[tberghammer]

Summary

Support loading files even when incorrect file name specified by the linker

"Incorrect" file name seen on Android whene the main executable is
called "app_process32" (or 64) but the linker specifies the package
name (e.g. com.android.calculator2). Additionally it can be present
in case of some linker bugs.

This CL adds logic to try to fetch the correct file name from the proc
file system based on the base address sepcified by the linker in case
we are failed to load the module by name.

[clayborg]

Looks good. Please pipe the GetName through the SBMemoryRegionInfo by modifying the SBMemoryRegionInfo.h, SBMemoryRegionInfo.cpp, and SBMemoryRegionInfo.i files. The signature should be:

const char *
SBMemoryRegionInfo::GetName();

Since m_name is a ConstString, you can just return the m_name.GetCString() since the string is owned by the string pool.

[tberghammer]

Add SBMemoryRegionInfo::GetName

lldb/trunk/docs/lldb-gdb-remote.txt

tuples to return are:
     start:<start-addr>; // <start-addr> is a big endian hex address that is 
                         // the start address of the range that contains <addr>
     
     size:<size>;    // <size> is a big endian hex byte size of the address
                     // of the range that contains <addr>
     
     permissions:<permissions>;  // <permissions> is a string that contains one
                                 // or more of the characters from "rwx"
-                                
+    name:<name>; // <name> is a hex encoded string that contains the name of
+                 // the memory region mapped at the given address. In case of
+                 // regions backed by a file it have to be the absolute path of
+                 // the file while for anonymous regions it have to be the name
+                 // associated to the region if that is available.
+                                
     error:<ascii-byte-error-string>; // where <ascii-byte-error-string> is
                                      // a hex encoded string value that 
                                      // contains an error string
                                     
 If the address requested is not in a mapped region (e.g. we've jumped through
 a NULL pointer and are at 0x0) currently lldb expects to get back the size 
 of the unmapped region -- that is, the distance to the next valid region.
 For instance, with a Mac OS X process which has nothing mapped in the first

lldb/trunk/include/lldb/API/SBMemoryRegionInfo.h

public:
     /// space.
     ///
     /// @return
     ///     true if this memory address is in the process address space.
     //------------------------------------------------------------------
     bool
     IsMapped ();
 
+    
+    //------------------------------------------------------------------
+    /// Returns the name of the memory region mapped at the given
+    /// address.
+    ///
+    /// @return
+    ///     In case of memory mapped files it is the absolute path of
+    ///     the file otherwise it is a name associated with the memory
+    ///     region. If no name can be determined the returns nullptr.
+    //------------------------------------------------------------------
+    const char *
+    GetName();
+
     bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);

lldb/trunk/include/lldb/Target/MemoryRegionInfo.h

 //===-- MemoryRegionInfo.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_MemoryRegionInfo_h
 #define lldb_MemoryRegionInfo_h
 
+#include "lldb/Core/ConstString.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Utility/Range.h"
 
 namespace lldb_private
 {
     class MemoryRegionInfo
     {
     public:
public:
             return m_execute;
         }
         
         OptionalBool
         GetMapped () const
         {
             return m_mapped;
         }
-        
+        const ConstString&
+        GetName () const
+        {
+            return m_name;
+        }
+        
         void
         SetReadable (OptionalBool val)
         {
             m_read = val;
         }
         
         void
         SetWritable (OptionalBool val)
         {
             m_write = val;
         }
         
         void
         SetExecutable (OptionalBool val)
         {
             m_execute = val;
         }
         
         void
         SetMapped (OptionalBool val)
         {
             m_mapped = val;
         }
 
+        void
+        SetName (const char* name)
+        {
+            m_name = ConstString(name);
+        }
+
         //----------------------------------------------------------------------
         // Get permissions as a uint32_t that is a mask of one or more bits from
         // the lldb::Permissions
         //----------------------------------------------------------------------
         uint32_t
         GetLLDBPermissions() const
         {
             uint32_t permissions = 0;
public:
         }
         
     protected:
         RangeType m_range;
         OptionalBool m_read;
         OptionalBool m_write;
         OptionalBool m_execute;
         OptionalBool m_mapped;
+        ConstString m_name;
     };
 }
 
 #endif // #ifndef lldb_MemoryRegionInfo_h

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def parse_memory_region_packet(self, context):
         # Ensure we have a context.
         self.assertIsNotNone(context.get("memory_region_response"))
 
         # Pull out key:value; pairs.
         mem_region_dict = self.parse_key_val_dict(context.get("memory_region_response"))
 
         # Validate keys are known.
         for (key, val) in list(mem_region_dict.items()):
-            self.assertTrue(key in ["start", "size", "permissions", "error"])
+            self.assertTrue(key in ["start", "size", "permissions", "name", "error"])
             self.assertIsNotNone(val)
 
         # Return the dictionary of key-value pairs for the memory region.
         return mem_region_dict
 
     def assert_address_within_memory_region(self, test_address, mem_region_dict):
         self.assertIsNotNone(mem_region_dict)
         self.assertTrue("start" in mem_region_dict)

lldb/trunk/source/API/SBMemoryRegionInfo.cpp

SBMemoryRegionInfo::IsExecutable () {
     return m_opaque_ap->GetExecutable() == MemoryRegionInfo::eYes;
 }
 
 bool
 SBMemoryRegionInfo::IsMapped () {
     return m_opaque_ap->GetMapped() == MemoryRegionInfo::eYes;
 }
 
+const char *
+SBMemoryRegionInfo::GetName () {
+    return m_opaque_ap->GetName().AsCString();
+}
+
 bool
 SBMemoryRegionInfo::GetDescription (SBStream &description)
 {
     Stream &strm = description.ref();
     const addr_t load_addr = m_opaque_ap->GetRange().base;
 
     strm.Printf ("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr, load_addr + m_opaque_ap->GetRange().size);
     strm.Printf (m_opaque_ap->GetReadable() ? "R" : "-");
     strm.Printf (m_opaque_ap->GetWritable() ? "W" : "-");
     strm.Printf (m_opaque_ap->GetExecutable() ? "X" : "-");
     strm.Printf ("]");
 
     return true;
 }

lldb/trunk/source/Core/DynamicLoader.cpp

 //===-- DynamicLoader.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Target/DynamicLoader.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DynamicLoader*
 DynamicLoader::FindPlugin (Process *process, const char *plugin_name)
 {
     DynamicLoaderCreateInstance create_callback = nullptr;

 ModuleSP
 DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
                                    addr_t link_map_addr,
                                    addr_t base_addr,
                                    bool base_addr_is_offset)
 {
     Target &target = m_process->GetTarget();
     ModuleList &modules = target.GetImages();
+    ModuleSpec module_spec (file, target.GetArchitecture());
     ModuleSP module_sp;
 
-    ModuleSpec module_spec (file, target.GetArchitecture());
     if ((module_sp = modules.FindFirstModule (module_spec)))
     {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, base_addr_is_offset);
+        return module_sp;
     }
-    else if ((module_sp = target.GetSharedModule(module_spec)))
+
+    if ((module_sp = target.GetSharedModule(module_spec)))
     {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, base_addr_is_offset);
+        return module_sp;
     }
-    else
-    {
-        if (base_addr_is_offset)
-        {
-            // Try to fetch the load address of the file from the process as we need absolute load
-            // address to read the file out of the memory instead of a load bias.
-            bool is_loaded = false;
-            lldb::addr_t load_addr;
-            Error error = m_process->GetFileLoadAddress(file, is_loaded, load_addr);
-            if (error.Success() && is_loaded)
-                base_addr = load_addr;
+
+    bool check_alternative_file_name = true;
+        {
+            check_alternative_file_name = false;
         }
+    }
+
+    // We failed to find the module based on its name. Lets try to check if we can find a
+    // different name based on the memory region info.
+    if (check_alternative_file_name)
+    {
+        MemoryRegionInfo memory_info;
+        Error error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
+        if (error.Success() && memory_info.GetMapped() && memory_info.GetRange().GetRangeBase() == base_addr)
+        {
+            ModuleSpec new_module_spec(FileSpec(memory_info.GetName().AsCString(), false),
+                                       target.GetArchitecture());
+
+            if ((module_sp = modules.FindFirstModule(new_module_spec)))
+            {
+                UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
+                return module_sp;
+            }
+
+            if ((module_sp = target.GetSharedModule(new_module_spec)))
+            {
+                UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
+                return module_sp;
+            }
+        }
+    }
 
-        if ((module_sp = m_process->ReadModuleFromMemory(file, base_addr)))
-        {
-            UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
-            target.GetImages().AppendIfNeeded(module_sp);
-        }
-    }
 
     return module_sp;
 }
 
 int64_t
 DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr, int size_in_bytes)
 {
     Error error;

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

ParseMemoryRegionInfoFromProcMapsLine (const std::string &maps_line, MemoryRegionInfo &memory_region_info)
     const char exec_perm_char = line_extractor.GetChar ();
     if (exec_perm_char == 'x')
         memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eYes);
     else if (exec_perm_char == '-')
         memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo);
     else
         return Error ("unexpected /proc/{pid}/maps exec permission char");
 
+    line_extractor.GetChar();              // Read the private bit
+    line_extractor.SkipSpaces();           // Skip the separator
+    line_extractor.GetHexMaxU64(false, 0); // Read the offset
+    line_extractor.GetHexMaxU64(false, 0); // Read the major device number
+    line_extractor.GetChar();              // Read the device id separator
+    line_extractor.GetHexMaxU64(false, 0); // Read the major device number
+    line_extractor.SkipSpaces();           // Skip the separator
+    line_extractor.GetU64(0, 10);          // Read the inode number
+
+    line_extractor.SkipSpaces();
+    const char* name = line_extractor.Peek();
+    if (name)
+        memory_region_info.SetName(name);
+
     return Error ();
 }
 
 Error
 NativeProcessLinux::GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info)
 {
     // FIXME review that the final memory region returned extends to the end of the virtual address space,
     // with no perms if it is not mapped.

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (m_supports_memory_region_info != eLazyBoolNo)
                     {
                         // The reported region does not contain this address -- we're looking at an unmapped page
                         region_info.SetReadable (MemoryRegionInfo::eNo);
                         region_info.SetWritable (MemoryRegionInfo::eNo);
                         region_info.SetExecutable (MemoryRegionInfo::eNo);
                         region_info.SetMapped(MemoryRegionInfo::eNo);
                     }
                 }
+                else if (name.compare ("name") == 0)
+                {
+                    StringExtractorGDBRemote name_extractor;
+                    name_extractor.GetStringRef().swap(value);
+                    name_extractor.GetHexByteString(value);
+                    region_info.SetName(value.c_str());
+                }
                 else if (name.compare ("error") == 0)
                 {
                     StringExtractorGDBRemote name_extractor;
                     // Swap "value" over into "name_extractor"
                     name_extractor.GetStringRef().swap(value);
                     // Now convert the HEX bytes into a string value
                     name_extractor.GetHexByteString (value);
                     error.SetErrorString(value.c_str());

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

else
                 response.PutChar ('r');
             if (region_info.GetWritable ())
                 response.PutChar('w');
             if (region_info.GetExecutable())
                 response.PutChar ('x');
 
             response.PutChar (';');
         }
+
+        // Name
+        ConstString name = region_info.GetName();
+        if (name)
+        {
+            response.PutCString("name:");
+            response.PutCStringAsRawHex8(name.AsCString());
+            response.PutChar(';');
+        }
     }
 
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_Z (StringExtractorGDBRemote &packet)
 {