Change DYLD To support TLS for minidump

Author: Jlalond

lldb/source/Expression/DWARFExpression.cpp

@@ -2168,8 +2168,6 @@ llvm::Expected<Value> DWARFExpression::Evaluate(
     // pushes it on the stack.
     case DW_OP_form_tls_address:
     case DW_OP_GNU_push_tls_address: {
-      bool debug = true;
-      while (debug) {}
       if (stack.size() < 1) {
         if (op == DW_OP_form_tls_address)
           return llvm::createStringError(

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

@@ -115,8 +115,11 @@ void DynamicLoaderPOSIXDYLD::DidAttach() {
       // don't rebase if the module already has a load address
       Target &target = m_process->GetTarget();
       Address addr = obj->GetImageInfoAddress(&target);
-      if (addr.GetLoadAddress(&target) != LLDB_INVALID_ADDRESS)
+      addr_t load_addr = addr.GetLoadAddress(&target);
+      if (load_addr != LLDB_INVALID_ADDRESS) {
         rebase_exec = false;
+        m_loaded_modules[executable_sp] = load_addr;
+      } 
     }
   } else {
     // no executable, nothing to re-base

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

@@ -336,18 +336,20 @@ ArchSpec ProcessMinidump::GetArchitecture() {
 }
 
 DynamicLoader* ProcessMinidump::GetDynamicLoader() {
-  if (m_dyld_up && m_dyld_up.get())
-    return m_dyld_up.get();
-
-  ArchSpec arch = GetArchitecture();
-  if (arch.GetTriple().getOS() == llvm::Triple::Linux) {
+  if (m_dyld_up.get() == nullptr)
     m_dyld_up.reset(DynamicLoader::FindPlugin(
         this, DynamicLoaderPOSIXDYLD::GetPluginNameStatic()));
-  }
-
   return m_dyld_up.get();
 }
 
+DataExtractor ProcessMinidump::GetAuxvData() {
+  std::optional<llvm::ArrayRef<uint8_t>> auxv = m_minidump_parser->GetStream(StreamType::LinuxAuxv);
+  if (!auxv)
+    return DataExtractor();
+
+  return DataExtractor(auxv->data(), auxv->size(), ByteOrder::eByteOrderLittle, GetAddressByteSize(), GetAddressByteSize()); 
+}
+
 void ProcessMinidump::BuildMemoryRegions() {
   if (m_memory_regions)
     return;

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

@@ -54,12 +54,13 @@ class ProcessMinidump : public PostMortemProcess {
 
   Status DoLoadCore() override;
 
+  // Returns AUXV structure found in the core file
+  lldb_private::DataExtractor GetAuxvData() override;
+
   DynamicLoader *GetDynamicLoader() override;
 
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
-  SystemRuntime *GetSystemRuntime() override { return nullptr; }
-
   Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;

lldb/source/Target/Process.cpp

@@ -6543,7 +6543,7 @@ static void AddRegisterSections(Process &process, ThreadSP &thread_sp, CoreFileM
     return;
 
   const uint64_t fail_value = UINT64_MAX;
-  bool readSuccess = true;
+  bool readSuccess = false;
   const lldb::addr_t reg_value_addr = reg_value.GetAsUInt64(fail_value, &readSuccess);
   if (!readSuccess || reg_value_addr == fail_value)
     return;
@@ -6562,23 +6562,29 @@ static void AddRegisterSections(Process &process, ThreadSP &thread_sp, CoreFileM
   AddRegion(register_region, true, ranges);
 }
 
-static void AddModuleThreadLocalSections(Process &process, ThreadSP &thread_sp, CoreFileMemoryRanges &ranges, lldb::addr_t range_end) {
+static void AddModuleSections(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;
-    // We want the entire section, so the offset is 0.
-    const lldb::addr_t tls_storage_addr = thread_sp->GetThreadLocalData(module_sp, 0);
-    if (tls_storage_addr == LLDB_INVALID_ADDRESS)
+
+    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 tls_storage_region;
-    Status err = process.GetMemoryRegionInfo(tls_storage_addr, tls_storage_region);
+    Status err = process.GetMemoryRegionInfo(load_addr, tls_storage_region);
     if (err.Fail())
       continue;
 
     // We already saved off this truncated stack range.
-    if (tls_storage_region.GetRange().GetRangeEnd() == range_end)
+    if (stack_ends.count(tls_storage_region.GetRange().GetRangeEnd()) > 0)
       continue;
 
     AddRegion(tls_storage_region, true, ranges);
@@ -6625,7 +6631,6 @@ static void SaveOffRegionsWithStackPointers(Process &process,
         // Add the register section if x86_64 and add the module tls data
         // only if the range isn't the same as this truncated stack range.
         AddRegisterSections(process, thread_sp, ranges, range_end);
-        AddModuleThreadLocalSections(process, thread_sp, ranges, range_end);
       }
     }
   }
@@ -6735,9 +6740,12 @@ Status Process::CalculateCoreFileSaveRanges(const SaveCoreOptions &options,
   std::set<addr_t> stack_ends;
   // For fully custom set ups, we don't want to even look at threads if there
   // are no threads specified.
-  if (core_style != lldb::eSaveCoreCustomOnly || options.HasSpecifiedThreads())
+  if (core_style != lldb::eSaveCoreCustomOnly || options.HasSpecifiedThreads()) {
     SaveOffRegionsWithStackPointers(*this, options, regions, ranges,
-                                    stack_ends);
+                                stack_ends);
+    AddModuleSections(*this, ranges, stack_ends);
+  }
+
 
   switch (core_style) {
   case eSaveCoreUnspecified: