Support thread local storage in module list dyld plugin

Summary:
llvm#67470 added TLS support for live debugging and coredump debugging with posix dyld.
This diff adds TLS support for module list dyld for coredump debugging.

To support TLS we have to:
* Capture main executable from `prpsinfo.pr_fname` so that use it to successfully resolve m_rendezvous.
* Implement `DynamicLoaderDumpWithModuleList::GetThreadLocalData()` similar to posix dyld

Test Plan: Can examine TLS variable in coredump without specifying the main executable.

Reviewers: gclayton, wanyi, hyubo, #lldb_team

Reviewed By: wanyi

Subscribers: #lldb_team

Differential Revision: https://phabricator.intern.facebook.com/D49889758

Tasks: T161060329

Author: jeffreytan81

lldb/source/Plugins/DynamicLoader/ModuleList-DYLD/DynamicLoaderDumpWithModuleList.cpp

@@ -118,6 +118,12 @@ void DynamicLoaderDumpWithModuleList::LoadAllModules(
     LoadModuleCallback callback) {
 
   if (m_rendezvous.Resolve()) {
+    // The rendezvous class doesn't enumerate the main module, so track that
+    // ourselves here.
+    ModuleSP executable = GetTargetExecutable();
+    if (executable)
+      m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
+
     DYLDRendezvous::iterator I;
     DYLDRendezvous::iterator E;
     for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {
@@ -127,7 +133,7 @@ void DynamicLoaderDumpWithModuleList::LoadAllModules(
           GetModuleInfo(I->base_addr);
       if (mod_info_opt.has_value())
         (*mod_info_opt).get_size(module_size);
-      callback(I->file_spec.GetPath(), I->base_addr, module_size);
+      callback(I->file_spec.GetPath(), I->base_addr, module_size, I->link_addr);
     }
 
     DetectModuleListMismatch();
@@ -159,7 +165,7 @@ void DynamicLoaderDumpWithModuleList::LoadAllModules(
           !mod_info.get_size(module_size) || !ShouldLoadModule(name))
         continue;
 
-      callback(SanitizeName(name), base_addr, module_size);
+      callback(SanitizeName(name), base_addr, module_size, /*link_map_addr=*/0);
     }
   }
 }
@@ -196,12 +202,11 @@ void DynamicLoaderDumpWithModuleList::DidAttach() {
 
   ModuleList module_list;
   LoadAllModules([&](const std::string &name, addr_t base_addr,
-                     addr_t module_size) {
+                     addr_t module_size, addr_t link_map_addr) {
     // vdso module has already been loaded.
     if (base_addr == m_vdso_base)
       return;
 
-    addr_t link_map_addr = 0;
     FileSpec file(name, m_process->GetTarget().GetArchitecture().GetTriple());
     const bool base_addr_is_offset = false;
     ModuleSP module_sp = DynamicLoader::LoadModuleAtAddress(
@@ -224,6 +229,7 @@ void DynamicLoaderDumpWithModuleList::DidAttach() {
                            base_addr_is_offset);
       m_process->GetTarget().GetImages().Append(module_sp, /*notify*/ true);
     }
+    m_loaded_modules[module_sp] = link_map_addr;
   });
 
   m_process->GetTarget().ModulesDidLoad(module_list);
@@ -260,3 +266,82 @@ void DynamicLoaderDumpWithModuleList::LoadVDSO() {
 lldb_private::Status DynamicLoaderDumpWithModuleList::CanLoadImage() {
   return Status();
 }
+
+// TODO: refactor and merge this implementation with
+// DynamicLoaderPOSIXDYLD::GetThreadLocalData
+lldb::addr_t DynamicLoaderDumpWithModuleList::GetThreadLocalData(
+    const lldb::ModuleSP module_sp, const lldb::ThreadSP thread,
+    lldb::addr_t tls_file_addr) {
+  Log *log = GetLog(LLDBLog::DynamicLoader);
+  auto it = m_loaded_modules.find(module_sp);
+  if (it == m_loaded_modules.end()) {
+    LLDB_LOGF(
+        log, "GetThreadLocalData error: module(%s) not found in loaded modules",
+        module_sp->GetObjectName().AsCString());
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  addr_t link_map = it->second;
+  if (link_map == LLDB_INVALID_ADDRESS || link_map == 0) {
+    LLDB_LOGF(log,
+              "GetThreadLocalData error: invalid link map address=0x%" PRIx64,
+              link_map);
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  const DYLDRendezvous::ThreadInfo &metadata = m_rendezvous.GetThreadInfo();
+  if (!metadata.valid) {
+    LLDB_LOGF(log,
+              "GetThreadLocalData error: fail to read thread info metadata");
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  LLDB_LOGF(log,
+            "GetThreadLocalData info: link_map=0x%" PRIx64
+            ", thread info metadata: "
+            "modid_offset=0x%" PRIx32 ", dtv_offset=0x%" PRIx32
+            ", tls_offset=0x%" PRIx32 ", dtv_slot_size=%" PRIx32 "\n",
+            link_map, metadata.modid_offset, metadata.dtv_offset,
+            metadata.tls_offset, metadata.dtv_slot_size);
+
+  // Get the thread pointer.
+  addr_t tp = thread->GetThreadPointer();
+  if (tp == LLDB_INVALID_ADDRESS) {
+    LLDB_LOGF(log, "GetThreadLocalData error: fail to read thread pointer");
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  // Find the module's modid.
+  int modid_size = 4; // FIXME(spucci): This isn't right for big-endian 64-bit
+  int64_t modid = ReadUnsignedIntWithSizeInBytes(
+      link_map + metadata.modid_offset, modid_size);
+  if (modid == -1) {
+    LLDB_LOGF(log, "GetThreadLocalData error: fail to read modid");
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  // Lookup the DTV structure for this thread.
+  addr_t dtv_ptr = tp + metadata.dtv_offset;
+  addr_t dtv = ReadPointer(dtv_ptr);
+  if (dtv == LLDB_INVALID_ADDRESS) {
+    LLDB_LOGF(log, "GetThreadLocalData error: fail to read dtv");
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  // Find the TLS block for this module.
+  addr_t dtv_slot = dtv + metadata.dtv_slot_size * modid;
+  addr_t tls_block = ReadPointer(dtv_slot + metadata.tls_offset);
+
+  LLDB_LOGF(log,
+            "DynamicLoaderDumpWithModuleList::Performed TLS lookup: "
+            "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64
+            ", modid=%" PRId64 ", tls_block=0x%" PRIx64 "\n",
+            module_sp->GetObjectName().AsCString(""), link_map, tp,
+            (int64_t)modid, tls_block);
+
+  if (tls_block == LLDB_INVALID_ADDRESS) {
+    LLDB_LOGF(log, "GetThreadLocalData error: fail to read tls_block");
+    return LLDB_INVALID_ADDRESS;
+  } else
+    return tls_block + tls_file_addr;
+}

lldb/source/Plugins/DynamicLoader/ModuleList-DYLD/DynamicLoaderDumpWithModuleList.h

@@ -59,10 +59,7 @@ class DynamicLoaderDumpWithModuleList : public lldb_private::DynamicLoader {
 
   lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
                                   const lldb::ThreadSP thread,
-                                  lldb::addr_t tls_file_addr) override {
-    // TODO: how to implement this?
-    return LLDB_INVALID_ADDRESS;
-  }
+                                  lldb::addr_t tls_file_addr) override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
@@ -73,7 +70,8 @@ class DynamicLoaderDumpWithModuleList : public lldb_private::DynamicLoader {
   const DynamicLoaderDumpWithModuleList &
   operator=(const DynamicLoaderDumpWithModuleList &) = delete;
 
-  typedef std::function<void(const std::string &, lldb::addr_t, lldb::addr_t)>
+  typedef std::function<void(const std::string &, lldb::addr_t, lldb::addr_t,
+                             lldb::addr_t)>
       LoadModuleCallback;
   void LoadAllModules(LoadModuleCallback callback);
 
@@ -107,6 +105,12 @@ class DynamicLoaderDumpWithModuleList : public lldb_private::DynamicLoader {
   /// It can be used to cross check with posix r_debug link map.
   std::unordered_map<lldb::addr_t, const LoadedModuleInfoList::LoadedModuleInfo>
       m_module_addr_to_info_map;
+
+  // TODO: merge with DynamicLoaderPOSIXDYLD::m_loaded_modules
+  // The same as DynamicLoaderPOSIXDYLD::m_loaded_modules to track all loaded
+  // module's link map addresses. It is used by TLS to get DTV data structure.
+  std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
+      m_loaded_modules;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MODULELIST_DYLD_DYNAMICLOADERDUMPWITHMODULELIST_H

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

@@ -259,12 +259,23 @@ Status ProcessElfCore::DoLoadCore() {
   // the main executable using data we found in the core file notes.
   lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
   if (!exe_module_sp) {
-    // The first entry in the NT_FILE might be our executable
     if (!m_nt_file_entries.empty()) {
+      // The first entry in the NT_FILE might be our executable
+      llvm::StringRef executable_path = m_nt_file_entries[0].path;
+      lldb_private::UUID executable_uuid = m_nt_file_entries[0].uuid;
+      // Prefer the NT_FILE entry matching m_executable_name as main executable.
+      for (const NT_FILE_Entry &file_entry : m_nt_file_entries)
+        if (llvm::StringRef(file_entry.path)
+                .ends_with("/" + m_executable_name)) {
+          executable_path = file_entry.path;
+          executable_uuid = file_entry.uuid;
+          break;
+        }
+
       ModuleSpec exe_module_spec;
       exe_module_spec.GetArchitecture() = arch;
-      exe_module_spec.GetUUID() = m_nt_file_entries[0].uuid;
-      exe_module_spec.GetFileSpec().SetFile(m_nt_file_entries[0].path,
+      exe_module_spec.GetUUID() = executable_uuid;
+      exe_module_spec.GetFileSpec().SetFile(executable_path,
                                             FileSpec::Style::native);
       if (exe_module_spec.GetFileSpec()) {
         exe_module_sp =
@@ -1060,6 +1071,7 @@ llvm::Error ProcessElfCore::parseLinuxNotes(llvm::ArrayRef<CoreNote> notes) {
           prpsinfo.pr_fname,
           strnlen(prpsinfo.pr_fname, sizeof(prpsinfo.pr_fname)));
       SetID(prpsinfo.pr_pid);
+      m_executable_name = prpsinfo.pr_fname;
       break;
     }
     case ELF::NT_SIGINFO: {

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

@@ -153,6 +153,8 @@ class ProcessElfCore : public lldb_private::PostMortemProcess {
   // Memory tag ranges found in the core
   VMRangeToFileOffset m_core_tag_ranges;
 
+  std::string m_executable_name;
+
   // NT_FILE entries found from the NOTE segment
   std::vector<NT_FILE_Entry> m_nt_file_entries;
 

lldb/source/Plugins/Process/elf-core/ThreadElfCore.h

@@ -105,8 +105,8 @@ struct ELFLinuxPrPsInfo {
   int32_t pr_ppid;
   int32_t pr_pgrp;
   int32_t pr_sid;
-  char pr_fname[16];
-  char pr_psargs[80];
+  char pr_fname[16];  // Filename of executable
+  char pr_psargs[80]; // Initial part of arg list
 
   ELFLinuxPrPsInfo();