Support Debugging TLS variable with lldb

[kkcode0]

Summary

Implement qGetTLSAddr for accessing thread pointer and utilises existing facility to calculate TLS variable address (GetThreadLocalData in DYLD).

[kkcode0]

rebase all changes

[kkcode0]

mark some vars used

[kkcode0]

rebased with main

[kkcode0]

enabled the tls test

[jingham]

A tiny quibble: GetThreadPointer seems like it should return a pointer to the thread that has this register set. I would not guess it's a pointer to the Thread's local storage. Maybe GetThreadLSPointer + a doc string saying what it does would clear this up?

[kkcode0]

added comments

[kkcode0]

added comments

[kkcode0]

ping?

[labath]

There's one thing that's not clear to me about this patch. What is the relationship between qGetTLSAddr, as implemented here, and its implementation in GDB? I guess they're not compatible since we're not sending or using the offset and link map fields, but it's not clear to me whether we're at least implementing some subset of gdb functionality (e.g., what would gdbserver do if it received one of the packets that we're sending here). If we're not, then I don't think we should be using the same packet for this purpose.

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

185–192

How is this related to the rest of the patch?

195

revert whitespace

730–771

I'm not sure what these marks are (tabs maybe), but could you figure out how to revert them?

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

114–117

Is this necessary, given that the function is already stubbed out in NativeRegisterContext?

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.h

84

Return llvm::Expected<addr_t> perhaps?

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

378

Any reason to not use the PtraceWrapper function?

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

2125–2126

Might as well not bother parsing them, if they're going to be thrown away anyway.

lldb/source/Target/Thread.cpp

1650–1652

Could this be implemented in ThreadGDBRemote directly (without going through the GDBRemoteRegisterContext)?

[kkcode0]

formatting

[kkcode0]

formatting

[kkcode0]

formatting

[kkcode0]

formatting

[kkcode0]

address review comments

[kkcode0]

spacing

[kkcode0]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

114–117

Thanks, it can be removed.

lldb/source/Target/Thread.cpp

1650–1652

Yes, Thanks moved it.

[kkcode0]

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

185–192

LoadVDSO is redundant , it is called via ProbeEntry->EntryBreakpointHit->LoadAllCurrentModules->LoadVDSO

[kkcode0]

use ptracewrapper

lldb/include/lldb/Host/common/NativeRegisterContext.h

public:
 
   virtual uint32_t GetRegisterSetCount() const = 0;
 
   virtual const RegisterSet *GetRegisterSet(uint32_t set_index) const = 0;
 
   virtual Status ReadRegister(const RegisterInfo *reg_info,
                               RegisterValue &reg_value) = 0;
 
+  virtual Status ReadThreadPointer(uint64_t &tp);
+
   virtual Status WriteRegister(const RegisterInfo *reg_info,
                                const RegisterValue &reg_value) = 0;
 
   virtual Status ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) = 0;
 
   virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0;
 
   uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind,

lldb/include/lldb/Target/RegisterContext.h

public:
   virtual const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) = 0;
 
   virtual size_t GetRegisterSetCount() = 0;
 
   virtual const RegisterSet *GetRegisterSet(size_t reg_set) = 0;
 
   virtual lldb::ByteOrder GetByteOrder();
 
+  virtual uint64_t GetThreadPointer();
+
   virtual bool ReadRegister(const RegisterInfo *reg_info,
                             RegisterValue &reg_value) = 0;
 
   virtual bool WriteRegister(const RegisterInfo *reg_info,
                              const RegisterValue &reg_value) = 0;
 
   virtual bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) {
     return false;

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

enum ServerPacketType {
     eServerPacketType_QSetMaxPayloadSize,
     eServerPacketType_QSetEnableAsyncProfiling,
     eServerPacketType_QSyncThreadState,
     eServerPacketType_QThreadSuffixSupported,
 
     eServerPacketType_jThreadsInfo,
     eServerPacketType_qsThreadInfo,
     eServerPacketType_qfThreadInfo,
+    eServerPacketType_qGetTLSAddr,
     eServerPacketType_qGetPid,
     eServerPacketType_qGetProfileData,
     eServerPacketType_qGDBServerVersion,
     eServerPacketType_qMemoryRegionInfo,
     eServerPacketType_qMemoryRegionInfoSupported,
     eServerPacketType_qProcessInfo,
     eServerPacketType_qRcmd,
     eServerPacketType_qRegisterInfo,

lldb/source/Expression/DWARFExpression.cpp

case DW_OP_GNU_push_tls_address: {
       }
 
       Thread *thread = exe_ctx->GetThreadPtr();
       if (!thread) {
         if (error_ptr)
           error_ptr->SetErrorString("No thread to evaluate TLS within.");
         return false;
       }
       
       // Lookup the TLS block address for this thread and module.
       const addr_t tls_file_addr =
           stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
       const addr_t tls_load_addr =
           thread->GetThreadLocalData(module_sp, tls_file_addr);
 
       if (tls_load_addr == LLDB_INVALID_ADDRESS) {
         if (error_ptr)

lldb/source/Host/common/NativeRegisterContext.cpp

for (uint32_t reg_num_index = 0; reg_num_index < reg_set->num_registers;
       }
     }
   }
 
   // Didn't find it.
   return nullptr;
 }
 
+Status NativeRegisterContext::ReadThreadPointer(uint64_t& tp) {
+  tp = LLDB_INVALID_ADDRESS;
+  Status error;
+  return error;
+}
+
 lldb::addr_t NativeRegisterContext::GetPC(lldb::addr_t fail_value) {
   Log *log = GetLog(LLDBLog::Thread);
 
   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_PC);
   LLDB_LOGF(log,
             "NativeRegisterContext::%s using reg index %" PRIu32
             " (default %" PRIu64 ")",

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

void DynamicLoaderPOSIXDYLD::DidLaunch() {
 
   if (executable.get() && load_offset != LLDB_INVALID_ADDRESS) {
     ModuleList module_list;
     module_list.Append(executable);
     UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
 
     LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s about to call ProbeEntry()",
               __FUNCTION__);
-
-    if (!SetRendezvousBreakpoint()) {
-      // If we cannot establish rendezvous breakpoint right now we'll try again
-      // at entry point.
-      ProbeEntry();
-    }
-
-    LoadVDSO();
     m_process->GetTarget().ModulesDidLoad(module_list);
   }
 }
 
 Status DynamicLoaderPOSIXDYLD::CanLoadImage() { return Status(); }
 
 void DynamicLoaderPOSIXDYLD::UpdateLoadedSections(ModuleSP module,
                                                   addr_t link_map_addr,
                                                   addr_t base_addr,
-                                                  bool base_addr_is_offset) {
+                                                  bool base_addr_is_offset) {             
   m_loaded_modules[module] = link_map_addr;
   UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 }
 
 void DynamicLoaderPOSIXDYLD::UnloadSections(const ModuleSP module) {
   m_loaded_modules.erase(module);
 
   UnloadSectionsCommon(module);

 lldb::addr_t
 DynamicLoaderPOSIXDYLD::GetThreadLocalData(const lldb::ModuleSP module_sp,
                                            const lldb::ThreadSP thread,
                                            lldb::addr_t tls_file_addr) {
   auto it = m_loaded_modules.find(module_sp);
   if (it == m_loaded_modules.end())
     return LLDB_INVALID_ADDRESS;
 
    addr_t link_map = it->second;
    if (link_map == LLDB_INVALID_ADDRESS)
      return LLDB_INVALID_ADDRESS;
 
    const DYLDRendezvous::ThreadInfo &metadata = m_rendezvous.GetThreadInfo();
    if (!metadata.valid)
      return LLDB_INVALID_ADDRESS;
 
    // Get the thread pointer.
    addr_t tp = thread->GetThreadPointer();
    if (tp == LLDB_INVALID_ADDRESS)
      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)
      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)
      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);
 
    Log *log = GetLog(LLDBLog::DynamicLoader);
    LLDB_LOGF(log,
              "DynamicLoaderPOSIXDYLD::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)
      return LLDB_INVALID_ADDRESS;
    else
      return tls_block + tls_file_addr;
 }
 
 void DynamicLoaderPOSIXDYLD::ResolveExecutableModule(
     lldb::ModuleSP &module_sp) {
   Log *log = GetLog(LLDBLog::DynamicLoader);
 
   if (m_process == nullptr)
     return;

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.h

public:
   /// if they are supported.
   virtual llvm::Expected<MemoryTaggingDetails>
   GetMemoryTaggingDetails(int32_t type) {
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "Architecture does not support memory tagging");
   }
 
+  virtual Status ReadThreadPointer(uint64_t &tp) override;
+
 protected:
   // NB: This constructor is here only because gcc<=6.5 requires a virtual base
   // class initializer on abstract class (even though it is never used). It can
   // be deleted once we move to gcc>=7.0.
   NativeRegisterContextLinux(NativeThreadProtocol &thread)
       : NativeRegisterContextRegisterInfo(thread, nullptr) {}
 
   lldb::ByteOrder GetByteOrder() const;
 
   virtual Status ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value);
 
   virtual Status WriteRegisterRaw(uint32_t reg_index,
                                   const RegisterValue &reg_value);
 
   virtual Status ReadRegisterSet(void *buf, size_t buf_size,
                                  unsigned int regset);
 
   virtual Status WriteRegisterSet(void *buf, size_t buf_size,
                                   unsigned int regset);
 
   virtual Status ReadGPR();
 
   virtual Status WriteGPR();
-
   virtual Status ReadFPR();
 
   virtual Status WriteFPR();
 
   virtual void *GetGPRBuffer() = 0;
 
   virtual size_t GetGPRSize() const {
     return GetRegisterInfoInterface().GetGPRSize();

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 }
 
 Status NativeRegisterContextLinux::ReadFPR() {
   return NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_thread.GetID(),
                                            nullptr, GetFPRBuffer(),
                                            GetFPRSize());
 }
 
+Status NativeRegisterContextLinux::ReadThreadPointer(uint64_t &tp) {
+  tp = LLDB_INVALID_ADDRESS;
+  Status error;
+  return error;
+}
+
 Status NativeRegisterContextLinux::WriteFPR() {
   return NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_thread.GetID(),
                                            nullptr, GetFPRBuffer(),
                                            GetFPRSize());
 }
 
 Status NativeRegisterContextLinux::ReadRegisterSet(void *buf, size_t buf_size,
                                                    unsigned int regset) {

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

NativeRegisterContextLinux_x86_64(const ArchSpec &target_arch,
                                     NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   uint32_t GetUserRegisterCount() const override;
 
+  Status ReadThreadPointer(uint64_t &tp) override;
+
   Status ReadRegister(const RegisterInfo *reg_info,
                       RegisterValue &reg_value) override;
 
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override;
 

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

 //===-- NativeRegisterContextLinux_x86_64.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #include "NativeRegisterContextLinux_x86_64.h"
 #include "Plugins/Process/Linux/NativeThreadLinux.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include <cpuid.h>
 #include <linux/elf.h>
 
 // Newer toolchains define __get_cpuid_count in cpuid.h, but some
NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64(
   // Clear out the FPR state.
   ::memset(m_xstate.get(), 0, xstate_size);
 
   // Store byte offset of fctrl (i.e. first register of FPR)
   const RegisterInfo *reg_info_fctrl = GetRegisterInfoByName("fctrl");
   m_fctrl_offset_in_userarea = reg_info_fctrl->byte_offset;
 }
 
+Status NativeRegisterContextLinux_x86_64::ReadThreadPointer(uint64_t& tp) {
+  Status error;
+  errno = 0;
+  auto ret= ptrace(static_cast<__ptrace_request>(PTRACE_ARCH_PRCTL), m_thread.GetID(),
+                   &tp, (void *)ARCH_GET_FS, 0);
+  if (ret == -1)
+    error.SetErrorToErrno();
+    return error;
+}
+
 // CONSIDER after local and llgs debugging are merged, register set support can
 // be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
 uint32_t NativeRegisterContextLinux_x86_64::GetRegisterSetCount() const {
   uint32_t sets = 0;
   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {
     if (IsRegisterSetAvailable(set_index))
       ++sets;
   }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
 
   Status WriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
                          const std::vector<uint8_t> &tags);
 
   /// Use qOffsets to query the offset used when relocating the target
   /// executable. If successful, the returned structure will contain at least
   /// one value in the offsets field.
   llvm::Optional<QOffsets> GetQOffsets();
   
+  lldb::addr_t GetQGetTLSAddr(lldb::tid_t tid, lldb::addr_t offset, lldb::addr_t lms);
+  
   bool GetModuleInfo(const FileSpec &module_file_spec,
                      const ArchSpec &arch_spec, ModuleSpec &module_spec);
 
   llvm::Optional<std::vector<ModuleSpec>>
   GetModulesInfo(llvm::ArrayRef<FileSpec> module_file_specs,
                  const llvm::Triple &triple);
 
   llvm::Expected<std::string> ReadExtFeature(llvm::StringRef object,

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

if (ref.consume_front("Text=")) {
     if (ref.empty())
       return result;
     if (ref.consume_front(";DataSeg=") && GetOffset() && ref.empty())
       return result;
   }
   return std::nullopt;
 }
 
+lldb::addr_t GDBRemoteCommunicationClient::GetQGetTLSAddr(lldb::tid_t tid, lldb::addr_t offset, lldb::addr_t lm) {
+  StreamString packet;
+  packet.PutCString("qGetTLSAddr:");
+  packet.PutHex64(tid, lldb::eByteOrderBig);
+  packet.PutCString(",");
+  packet.PutHex64(offset, lldb::eByteOrderBig);
+  packet.PutCString(",");
+  packet.PutHex64(lm, lldb::eByteOrderBig);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
+      PacketResult::Success)
+    return LLDB_INVALID_ADDRESS;
+  if (response.IsErrorResponse())
+    return LLDB_INVALID_ADDRESS;
+  if (response.IsUnsupportedResponse())
+    return LLDB_INVALID_ADDRESS;
+  llvm::StringRef ref = response.GetStringRef();
+  uint64_t addr = LLDB_INVALID_ADDRESS;
+  ref.consumeInteger(16, addr);
+  return addr;
+}
+
 bool GDBRemoteCommunicationClient::GetModuleInfo(
     const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
     ModuleSpec &module_spec) {
   if (!m_supports_qModuleInfo)
     return false;
 
   std::string module_path = module_file_spec.GetPath(false);
   if (module_path.empty())

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
 
   void AddProcessThreads(StreamGDBRemote &response,
                          NativeProcessProtocol &process, bool &had_any);
 
   PacketResult Handle_qfThreadInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qsThreadInfo(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_qGetTLSAddr(StringExtractorGDBRemote &packet);
+  
   PacketResult Handle_p(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_P(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_H(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_I(StringExtractorGDBRemote &packet);
 

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

RegisterMemberFunctionHandler(
       &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
       &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
       &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
   RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_qGetTLSAddr,
+      &GDBRemoteCommunicationServerLLGS::Handle_qGetTLSAddr);
+  RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
       &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
       &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
       &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);

 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
     StringExtractorGDBRemote &packet) {
   // FIXME for now we return the full thread list in the initial packet and
   // always do nothing here.
   return SendPacketNoLock("l");
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_qGetTLSAddr(
+    StringExtractorGDBRemote &packet) {
+  llvm::StringRef s = packet.GetStringRef();
+  if (!s.consume_front("qGetTLSAddr:"))
+    return SendErrorResponse(8);
+  llvm::SmallVector<llvm::StringRef, 16> argv;
+  s.split(argv, ',');
+  lldb::tid_t tid =  StringExtractor(argv[0]).GetU64(LLDB_INVALID_ADDRESS, 16);
+  lldb::addr_t offset = StringExtractor(argv[1]).GetU64(LLDB_INVALID_ADDRESS, 16);
+  lldb::addr_t lm = StringExtractor(argv[2]).GetU64(LLDB_INVALID_ADDRESS, 16);
+  NativeThreadProtocol *ntp = m_current_process->GetThreadByID(tid);
+  NativeRegisterContext &reg_ctx = ntp->GetRegisterContext();
+  lldb::addr_t tls_addr = LLDB_INVALID_ADDRESS;
+  StreamGDBRemote response;
+  if(!reg_ctx.ReadThreadPointer(tls_addr).Fail()) {
+    response.PutHex64(tls_addr, lldb::eByteOrderBig);
+    return SendPacketNoLock(response.GetString());
+  } else
+    return SendErrorResponse(8);
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_g(StringExtractorGDBRemote &packet) {
   Log *log = GetLog(LLDBLog::Thread);
 
   // Move past packet name.
   packet.SetFilePos(strlen("g"));
 
   // Get the thread to use.
   NativeThreadProtocol *thread = GetThreadFromSuffix(packet);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

public:
   ~GDBRemoteRegisterContext() override;
 
   void InvalidateAllRegisters() override;
 
   size_t GetRegisterCount() override;
 
   const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
 
+  uint64_t GetThreadPointer() override;
+
   size_t GetRegisterSetCount() override;
 
   const RegisterSet *GetRegisterSet(size_t reg_set) override;
 
   bool ReadRegister(const RegisterInfo *reg_info,
                     RegisterValue &value) override;
 
   bool WriteRegister(const RegisterInfo *reg_info,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

 size_t GDBRemoteRegisterContext::GetRegisterSetCount() {
   return m_reg_info_sp->GetNumRegisterSets();
 }
 
 const RegisterSet *GDBRemoteRegisterContext::GetRegisterSet(size_t reg_set) {
   return m_reg_info_sp->GetRegisterSet(reg_set);
 }
 
+uint64_t GDBRemoteRegisterContext::GetThreadPointer() {
+  ExecutionContext exe_ctx(CalculateThread());
+  Process *process = exe_ctx.GetProcessPtr();
+  Thread *thread = exe_ctx.GetThreadPtr();
+  if (process == nullptr || thread == nullptr)
+    return LLDB_INVALID_ADDRESS;
+  GDBRemoteCommunicationClient &gdb_comm(
+      ((ProcessGDBRemote *)process)->GetGDBRemote());
+  uint64_t tid = thread->GetProtocolID();
+  // Return thread pointer here, offset and link_map will be filled by GetThreadLocalData in DYLD
+  return gdb_comm.GetQGetTLSAddr(tid, LLDB_INVALID_ADDRESS /* offset */, LLDB_INVALID_ADDRESS /* lm */);
+}
+
 bool GDBRemoteRegisterContext::ReadRegister(const RegisterInfo *reg_info,
                                             RegisterValue &value) {
   // Read the register
   if (ReadRegisterBytes(reg_info)) {
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
     if (m_reg_valid[reg] == false)
       return false;
     if (reg_info->value_regs &&

lldb/source/Target/RegisterContext.cpp

 using namespace lldb_private;
 
 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx)
     : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx),
       m_stop_id(thread.GetProcess()->GetStopID()) {}
 
 RegisterContext::~RegisterContext() = default;
 
+uint64_t RegisterContext::GetThreadPointer() {
+  return UINT64_MAX;
+}
+
 void RegisterContext::InvalidateIfNeeded(bool force) {
   ProcessSP process_sp(m_thread.GetProcess());
   bool invalidate = force;
   uint32_t process_stop_id = UINT32_MAX;
 
   if (process_sp)
     process_stop_id = process_sp->GetStopID();
   else

lldb/source/Target/Thread.cpp

void Thread::DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx,
   FormatEntity::Format(*thread_format, strm, frame_sp ? &frame_sc : nullptr,
                        &exe_ctx, nullptr, nullptr, false, false);
 }
 
 void Thread::SettingsInitialize() {}
 
 void Thread::SettingsTerminate() {}
 
-lldb::addr_t Thread::GetThreadPointer() { return LLDB_INVALID_ADDRESS; }
+lldb::addr_t Thread::GetThreadPointer() {
+  RegisterContext *reg_ctx = this->GetRegisterContext().get();
+  auto tp = reg_ctx->GetThreadPointer();
+  return tp;
+}
 
 addr_t Thread::GetThreadLocalData(const ModuleSP module,
                                   lldb::addr_t tls_file_addr) {
   // The default implementation is to ask the dynamic loader for it. This can
   // be overridden for specific platforms.
   DynamicLoader *loader = GetProcess()->GetDynamicLoader();
   if (loader)
     return loader->GetThreadLocalData(module, shared_from_this(),

lldb/source/Utility/StringExtractorGDBRemote.cpp

case 'G':
       if (PACKET_MATCHES("qGetWorkingDir"))
         return eServerPacketType_qGetWorkingDir;
       if (PACKET_MATCHES("qGetPid"))
         return eServerPacketType_qGetPid;
       if (PACKET_STARTS_WITH("qGetProfileData;"))
         return eServerPacketType_qGetProfileData;
       if (PACKET_MATCHES("qGDBServerVersion"))
         return eServerPacketType_qGDBServerVersion;
+      if (PACKET_STARTS_WITH("qGetTLSAddr"))
+        return eServerPacketType_qGetTLSAddr;
       break;
 
     case 'H':
       if (PACKET_MATCHES("qHostInfo"))
         return eServerPacketType_qHostInfo;
       break;
 
     case 'K':