Move the TLS code to the DYLD

Author: Jlalond

lldb/include/lldb/Target/DynamicLoader.h

@@ -18,6 +18,7 @@
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-types.h"
+#include "lldb/Target/CoreFileMemoryRanges.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -337,6 +338,13 @@ class DynamicLoader : public PluginInterface {
     return std::nullopt;
   }
 
+  /// Returns a list of memory ranges that should be saved in the core file, 
+  /// specific for this dßynamic loader.
+  ///
+  /// By default, this returns an empty list, but for POSIX/ELF it will return
+  /// the link map, and the TLS data.
+  virtual void CalculateDynamicSaveCoreRanges(lldb_private::Process &process, std::vector<lldb_private::MemoryRegionInfo> &ranges, std::function<bool(const lldb_private::Thread&)> save_thread_predicate) {};
+
 protected:
   // Utility methods for derived classes
 

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

@@ -18,6 +18,7 @@
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
+#include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
@@ -866,3 +867,77 @@ bool DynamicLoaderPOSIXDYLD::AlwaysRelyOnEHUnwindInfo(
 bool DynamicLoaderPOSIXDYLD::IsCoreFile() const {
   return !m_process->IsLiveDebugSession();
 }
+
+// For our ELF/POSIX builds save off the fs_base/gs_base regions
+static void AddSegmentRegisterSections(Process &process, ThreadSP &thread_sp,
+                                       std::vector<MemoryRegionInfo> &ranges) {
+  lldb::RegisterContextSP reg_ctx = thread_sp->GetRegisterContext();
+  if (!reg_ctx)
+    return;
+
+  const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
+      lldb::RegisterKind::eRegisterKindGeneric, LLDB_REGNUM_GENERIC_TP);
+  if (!reg_info)
+    return;
+
+  lldb_private::RegisterValue thread_local_register_value;
+  bool success = reg_ctx->ReadRegister(reg_info, thread_local_register_value);
+  if (!success)
+    return;
+
+  const uint64_t fail_value = UINT64_MAX;
+  bool readSuccess = false;
+  const lldb::addr_t reg_value_addr =
+      thread_local_register_value.GetAsUInt64(fail_value, &readSuccess);
+  if (!readSuccess || reg_value_addr == fail_value)
+    return;
+
+  MemoryRegionInfo thread_local_region;
+  Status err = process.GetMemoryRegionInfo(reg_value_addr, thread_local_region);
+  if (err.Fail())
+    return;
+
+  ranges.push_back(thread_local_region);
+}
+
+// Save off the link map for core files.
+static void AddLinkMapSections(Process &process, std::vector<MemoryRegionInfo> &ranges) {
+  ModuleList &module_list = process.GetTarget().GetImages();
+  Target *target = &process.GetTarget();
+  for (size_t idx = 0; idx < module_list.GetSize(); idx++) {
+    ModuleSP module_sp = module_list.GetModuleAtIndex(idx);
+    if (!module_sp)
+      continue;
+
+    ObjectFile *obj = module_sp->GetObjectFile();
+    if (!obj)
+      continue;
+    Address addr = obj->GetImageInfoAddress(target);
+    addr_t load_addr = addr.GetLoadAddress(target);
+    if (load_addr == LLDB_INVALID_ADDRESS)
+      continue;
+
+    MemoryRegionInfo link_map_section;
+    Status err = process.GetMemoryRegionInfo(load_addr, link_map_section);
+    if (err.Fail())
+      continue;
+
+    ranges.push_back(link_map_section);
+  }
+}
+
+void DynamicLoaderPOSIXDYLD::CalculateDynamicSaveCoreRanges(lldb_private::Process &process, std::vector<lldb_private::MemoryRegionInfo> &ranges, std::function<bool(const lldb_private::Thread&)> save_thread_predicate) {
+  ThreadList &thread_list = process.GetThreadList();
+  for (size_t idx = 0; idx < thread_list.GetSize(); idx++) {
+    ThreadSP thread_sp = thread_list.GetThreadAtIndex(idx);
+    if (!thread_sp)
+      continue;
+
+    if (!save_thread_predicate(*thread_sp.get()))
+      continue;
+
+    AddSegmentRegisterSections(process, thread_sp, ranges);
+  }
+
+  AddLinkMapSections(process, ranges);
+}

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

@@ -60,6 +60,8 @@ class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader {
                                      lldb::addr_t base_addr,
                                      bool base_addr_is_offset) override;
 
+   void CalculateDynamicSaveCoreRanges(lldb_private::Process &process, std::vector<lldb_private::MemoryRegionInfo> &ranges, std::function<bool(const lldb_private::Thread&)> save_thread_predicate) override; 
+
 protected:
   /// Runtime linker rendezvous structure.
   DYLDRendezvous m_rendezvous;

lldb/source/Target/Process.cpp

@@ -6539,72 +6539,18 @@ static void AddRegion(const MemoryRegionInfo &region, bool try_dirty_pages,
                 CreateCoreFileMemoryRange(region));
 }
 
-static void AddSegmentRegisterSections(Process &process, ThreadSP &thread_sp,
-                                       CoreFileMemoryRanges &ranges,
-                                       lldb::addr_t range_end) {
-  lldb::RegisterContextSP reg_ctx = thread_sp->GetRegisterContext();
-  if (!reg_ctx)
+static void SaveDynamicLoaderSections(Process &process, const SaveCoreOptions &options, CoreFileMemoryRanges &ranges, std::set<addr_t> &stack_ends) {
+  DynamicLoader *dyld = process.GetDynamicLoader();
+  if (!dyld)
     return;
 
-  const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
-      lldb::RegisterKind::eRegisterKindGeneric, LLDB_REGNUM_GENERIC_TP);
-  if (!reg_info)
-    return;
-
-  lldb_private::RegisterValue thread_local_register_value;
-  bool success = reg_ctx->ReadRegister(reg_info, thread_local_register_value);
-  if (!success)
-    return;
-
-  const uint64_t fail_value = UINT64_MAX;
-  bool readSuccess = false;
-  const lldb::addr_t reg_value_addr =
-      thread_local_register_value.GetAsUInt64(fail_value, &readSuccess);
-  if (!readSuccess || reg_value_addr == fail_value)
-    return;
-
-  MemoryRegionInfo thread_local_region;
-  Status err = process.GetMemoryRegionInfo(reg_value_addr, thread_local_region);
-  if (err.Fail())
-    return;
-
-  // We already saved off this truncated stack range.
-  if (thread_local_region.GetRange().GetRangeEnd() == range_end)
-    return;
-
-  // We don't need to worry about duplication because the CoreFileMemoryRanges
-  // will unique them
-  AddRegion(thread_local_region, true, ranges);
-}
-
-static void AddLinkMapSections(Process &process, CoreFileMemoryRanges &ranges,
-                               std::set<addr_t> &stack_ends) {
-  ModuleList &module_list = process.GetTarget().GetImages();
-  Target *target = &process.GetTarget();
-  for (size_t idx = 0; idx < module_list.GetSize(); idx++) {
-    ModuleSP module_sp = module_list.GetModuleAtIndex(idx);
-    if (!module_sp)
-      continue;
-
-    ObjectFile *obj = module_sp->GetObjectFile();
-    if (!obj)
-      continue;
-    Address addr = obj->GetImageInfoAddress(target);
-    addr_t load_addr = addr.GetLoadAddress(target);
-    if (load_addr == LLDB_INVALID_ADDRESS)
-      continue;
-
-    MemoryRegionInfo link_map_section;
-    Status err = process.GetMemoryRegionInfo(load_addr, link_map_section);
-    if (err.Fail())
-      continue;
-
-    // Sometimes, the link map section is included in one of the stack memory
-    // ranges. In that case, we already saved a truncated version of that range
-    if (stack_ends.count(link_map_section.GetRange().GetRangeEnd()) == 0)
-      continue;
-
-    AddRegion(link_map_section, true, ranges);
+  std::vector<MemoryRegionInfo> dynamic_loader_mem_regions;
+  std::function<bool(const lldb_private::Thread&)> save_thread_predicate = [&](const lldb_private::Thread &t) -> bool { return options.ShouldThreadBeSaved(t.GetID()); };
+  dyld->CalculateDynamicSaveCoreRanges(process, dynamic_loader_mem_regions, save_thread_predicate);
+  for (const auto &region : dynamic_loader_mem_regions) {
+    // The Dynamic Loader can give us regions that could include a truncated stack
+    if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0)
+      AddRegion(region, true, ranges);
   }
 }
 
@@ -6645,7 +6591,6 @@ static void SaveOffRegionsWithStackPointers(Process &process,
       // or contains the thread id from thread_sp.
       if (core_options.ShouldThreadBeSaved(thread_sp->GetID())) {
         AddRegion(sp_region, try_dirty_pages, ranges);
-        AddSegmentRegisterSections(process, thread_sp, ranges, range_end);
       }
     }
   }
@@ -6759,8 +6704,9 @@ Status Process::CalculateCoreFileSaveRanges(const SaveCoreOptions &options,
       options.HasSpecifiedThreads()) {
     SaveOffRegionsWithStackPointers(*this, options, regions, ranges,
                                     stack_ends);
-    // We need the link map for TLS data.
-    AddLinkMapSections(*this, ranges, stack_ends);
+    // Save off the dynamic loader sections, so if we are on an architecture that supports
+    // Thread Locals, that we include those as well.
+    SaveDynamicLoaderSections(*this, options, ranges, stack_ends);
   }
 
   switch (core_style) {