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

186–193

How is this related to the rest of the patch?

196

revert whitespace

767

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

116–119

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

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

85

Return llvm::Expected<addr_t> perhaps?

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

380

Any reason to not use the PtraceWrapper function?

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

2123–2124

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

lldb/source/Target/Thread.cpp

1627–1629

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

116–119

Thanks, it can be removed.

lldb/source/Target/Thread.cpp

1627–1629

Yes, Thanks moved it.

[kkcode0]

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

186–193

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();
 
+  /// Retrieves the per-thread data area.
+  /// Most OSs maintain a per-thread pointer (e.g. the FS register on
+  /// x64), which we return the value of here.
+  ///
+  /// \return
+  ///     LLDB_INVALID_ADDRESS if not supported, otherwise the thread
+  ///     pointer value.
+  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/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, "Using reg index %" PRIu32 " (default %" PRIu64 ")", reg,
             fail_value);
 

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) {
   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);
DynamicLoaderPOSIXDYLD::GetThreadLocalData(const lldb::ModuleSP module_sp,
 
   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>
 #include <optional>
 
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.
   std::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);
 
   std::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);
+  (void) offset;
+  (void) lm;
+  NativeThreadProtocol *ntp = m_current_process->GetThreadByID(tid);
+  NativeRegisterContext &reg_ctx = ntp->GetRegisterContext();
+  lldb::addr_t tp = LLDB_INVALID_ADDRESS;
+  StreamGDBRemote response;
+  if(!reg_ctx.ReadThreadPointer(tp).Fail()) {
+    response.PutHex64(tp, 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':

lldb/test/API/lang/c/tls_globals/TestTlsGlobals.py

def setUp(self):
                     + self.getBuildDir()
                 )
             self.addTearDownHook(
                 lambda: self.runCmd("settings remove target.env-vars " + self.dylibPath)
             )
 
     # TLS works differently on Windows, this would need to be implemented
     # separately.
-    @skipIfWindows
-    @expectedFailureAll(
-        bugnumber="llvm.org/pr28392",
-        oslist=no_match(lldbplatformutil.getDarwinOSTriples()),
-    )
+    @skipIf(archs=no_match(['x86_64']), oslist=no_match(['linux']))
     def test(self):
         """Test thread-local storage."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         if self.platformIsDarwin():
             self.registerSharedLibrariesWithTarget(target, ["liba.dylib"])