Make DynamicLoaderPOSIXDYLD::DidAttach to deduce a target executable by pid if no executable hasn't been assigned to a target so far.

[ovyalov]

Summary

If user attaches to a local process by pid without executable assigned to a target we can deduce an executable path by pid, otherwise no symbols are loaded and not possible to set up breakpoints.

[ovyalov]

Friendly ping.

[clayborg]

Doesn't the auxv data say what the executable is, or does it only contain the shared libraries? If it contains the executable you should check if the executable matches the executable in the target. If it doesn't you will need to get the process info and always update the executable if needed. Examples to show how this can happen are below:

You might want to check if the executable is correct or not regardless of what it is set to. Try this:

In one terminal:
% /bin/cat

And leave it there so it is waiting for stdin

Then in another terminal do:

(lldb) file /bin/ls
(lldb) process attach --pid 123

Where 123 is the process ID for /bin/cat. You should switch the executable if it isn't correct.

Also, try making a program "a.out" that exec()'s itself into something else like "b.out" and make sure the executable updates when the process exec's into another executable and can hit a breakpoint that you set in "a.out" and "b.out" (like setting a breakpoint at "main" with "(lldb) b main".

The job of the dynamic loader is to keep the target up to date and make sure the executable is always correct. You can't rely on what the target contains. The architecture also needs to be updated sometimes in case you do:

(lldb) target create --arch i386 a.out

And then you attach to a b.out that is "x86_64"...

[ovyalov]

Thank you for suggestions - I've made corresponding changes to handle such situations when a module file name and/or architecture changes.
Initially I tried to use AT_EXECFN but as I can see it's not reliable option - for example, when I start application from its binary directory (e.g., ./CppTest) AT_EXECFN will be set to "./CppTest" instead of providing a full path.

[clayborg]

Looks good.

[Eugene.Zelenko]

Committed in r225332.

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

protected:
     lldb::addr_t
     ComputeLoadOffset();
 
     /// Computes a value for m_entry_point returning the computed address on
     /// success and LLDB_INVALID_ADDRESS on failure.
     lldb::addr_t
     GetEntryPoint();
 
+    /// Loads ModuleSpec data from inferior process.
+    bool
+    GetProcessModuleSpec(lldb_private::ModuleSpec& module_spec);
+
 private:
     DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
 #endif  // liblldb_DynamicLoaderPOSIXDYLD_H_

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (m_dyld_bid != LLDB_INVALID_BREAK_ID)
         m_dyld_bid = LLDB_INVALID_BREAK_ID;
     }
 }
 
 void
 DynamicLoaderPOSIXDYLD::DidAttach()
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-    ModuleSP executable_sp;
-    addr_t load_offset;
-
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
 
     m_auxv.reset(new AuxVector(m_process));
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
 
-    executable_sp = GetTargetExecutable();
-    load_offset = ComputeLoadOffset();
+    ModuleSP executable_sp = GetTargetExecutable();
+    ModuleSpec process_module_spec;
+    if (GetProcessModuleSpec(process_module_spec))
+    {
+        if (executable_sp == nullptr || !executable_sp->MatchesModuleSpec(process_module_spec))
+        {
+            executable_sp.reset(new Module(process_module_spec));
+            assert(m_process != nullptr);
+            m_process->GetTarget().SetExecutableModule(executable_sp, false);
+        }
+    }
+
+    addr_t load_offset = ComputeLoadOffset();
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " executable '%s', load_offset 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, executable_sp ? executable_sp->GetFileSpec().GetPath().c_str () : "<null executable>", load_offset);
 
 
     if (executable_sp && load_offset != LLDB_INVALID_ADDRESS)
     {
         ModuleList module_list;
 
DynamicLoaderPOSIXDYLD::GetThreadLocalData (const lldb::ModuleSP module, const lldb::ThreadSP thread)
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     if (log)
         log->Printf("DynamicLoaderPOSIXDYLD::Performed TLS lookup: "
                     "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64 ", modid=%" PRId64 ", tls_block=0x%" PRIx64 "\n",
                     mod->GetObjectName().AsCString(""), link_map, tp, (int64_t)modid, tls_block);
 
     return tls_block;
 }
+
+bool
+DynamicLoaderPOSIXDYLD::GetProcessModuleSpec (ModuleSpec& module_spec)
+{
+    if (m_process == nullptr)
+        return false;
+
+    auto& target = m_process->GetTarget ();
+    ProcessInstanceInfo process_info;
+    if (!target.GetPlatform ()->GetProcessInfo (m_process->GetID (), process_info))
+        return false;
+
+    module_spec = ModuleSpec (process_info.GetExecutableFile (), process_info.GetArchitecture ());
+    return true;
+}