Make ThreadPlanTracer use {Process,TID} rather than Thread to find it's underlying thread...

[jingham]

Summary

This is the next patch in the sequence started by:

https://reviews.llvm.org/D75711

though it isn't formally dependent on it.

See the summary of that patch for more details.

lldb/include/lldb/Target/ThreadPlanTracer.h

public:
 
   bool EnableSingleStep(bool value) {
     bool old_value = m_single_step;
     m_single_step = value;
     return old_value;
   }
 
   bool SingleStepEnabled() { return m_single_step; }
   
+  Thread &GetThread();
+
 protected:
-  Thread &m_thread;
+  Process &m_process;
+  lldb::tid_t m_tid;
 
   Stream *GetLogStream();
 
   virtual void Log();
 
 private:
   bool TracerExplainsStop();
 
   bool m_single_step;
   bool m_enabled;
   lldb::StreamSP m_stream_sp;
+  Thread *m_thread;
 };
 
 class ThreadPlanAssemblyTracer : public ThreadPlanTracer {
 public:
   ThreadPlanAssemblyTracer(Thread &thread, lldb::StreamSP &stream_sp);
   ThreadPlanAssemblyTracer(Thread &thread);
   ~ThreadPlanAssemblyTracer() override;
 

lldb/source/Target/ThreadPlanTracer.cpp

 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark ThreadPlanTracer
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp)
-    : m_thread(thread), m_single_step(true), m_enabled(false),
-      m_stream_sp(stream_sp) {}
+    : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
+      m_single_step(true), m_enabled(false), m_stream_sp(stream_sp) {}
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread)
-    : m_thread(thread), m_single_step(true), m_enabled(false), m_stream_sp() {}
+    : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
+      m_single_step(true), m_enabled(false), m_stream_sp() {}
 
 Stream *ThreadPlanTracer::GetLogStream() {
   if (m_stream_sp)
     return m_stream_sp.get();
   else {
-    TargetSP target_sp(m_thread.CalculateTarget());
+    TargetSP target_sp(GetThread().CalculateTarget());
     if (target_sp)
       return &(target_sp->GetDebugger().GetOutputStream());
   }
   return nullptr;
 }
 
+Thread &ThreadPlanTracer::GetThread() {
+  if (m_thread)
+    return *m_thread;
+    
+  ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(m_tid);
+  m_thread = thread_sp.get();
+  return *m_thread;
+}
 void ThreadPlanTracer::Log() {
   SymbolContext sc;
   bool show_frame_index = false;
   bool show_fullpaths = false;
 
   Stream *stream = GetLogStream();
   if (stream) {
-    m_thread.GetStackFrameAtIndex(0)->Dump(stream, show_frame_index,
+    GetThread().GetStackFrameAtIndex(0)->Dump(stream, show_frame_index,
                                               show_fullpaths);
     stream->Printf("\n");
     stream->Flush();
   }
 }
 
 bool ThreadPlanTracer::TracerExplainsStop() {
   if (m_enabled && m_single_step) {
-    lldb::StopInfoSP stop_info = m_thread.GetStopInfo();
+    lldb::StopInfoSP stop_info = GetThread().GetStopInfo();
     return (stop_info->GetStopReason() == eStopReasonTrace);
   } else
     return false;
 }
 
 #pragma mark ThreadPlanAssemblyTracer
 
 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread,
                                                    lldb::StreamSP &stream_sp)
     : ThreadPlanTracer(thread, stream_sp), m_disassembler_sp(), m_intptr_type(),
       m_register_values() {}
 
 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread)
     : ThreadPlanTracer(thread), m_disassembler_sp(), m_intptr_type(),
       m_register_values() {}
 
 Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() {
   if (!m_disassembler_sp)
     m_disassembler_sp = Disassembler::FindPlugin(
-        m_thread.GetProcess()->GetTarget().GetArchitecture(), nullptr, nullptr);
+        m_process.GetTarget().GetArchitecture(), nullptr, nullptr);
   return m_disassembler_sp.get();
 }
 
 TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() {
   if (!m_intptr_type.IsValid()) {
-    if (auto target_sp = m_thread.CalculateTarget()) {
+    if (auto target_sp = m_process.CalculateTarget()) {
       auto type_system_or_err =
           target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
       if (auto err = type_system_or_err.takeError()) {
         LLDB_LOG_ERROR(
             lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES),
             std::move(err),
             "Unable to get integer pointer type from TypeSystem");
       } else {

 void ThreadPlanAssemblyTracer::TracingEnded() { m_register_values.clear(); }
 
 void ThreadPlanAssemblyTracer::Log() {
   Stream *stream = GetLogStream();
 
   if (!stream)
     return;
 
-  RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
+  RegisterContext *reg_ctx = GetThread().GetRegisterContext().get();
 
   lldb::addr_t pc = reg_ctx->GetPC();
-  ProcessSP process_sp(m_thread.GetProcess());
   Address pc_addr;
   bool addr_valid = false;
   uint8_t buffer[16] = {0}; // Must be big enough for any single instruction
-  addr_valid = process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
+  addr_valid = m_process.GetTarget().GetSectionLoadList().ResolveLoadAddress(
       pc, pc_addr);
 
-  pc_addr.Dump(stream, &m_thread, Address::DumpStyleResolvedDescription,
+  pc_addr.Dump(stream, &GetThread(), Address::DumpStyleResolvedDescription,
                Address::DumpStyleModuleWithFileAddress);
   stream->PutCString(" ");
 
   Disassembler *disassembler = GetDisassembler();
   if (disassembler) {
     Status err;
-    process_sp->ReadMemory(pc, buffer, sizeof(buffer), err);
+    m_process.ReadMemory(pc, buffer, sizeof(buffer), err);
 
     if (err.Success()) {
-      DataExtractor extractor(buffer, sizeof(buffer),
-                              process_sp->GetByteOrder(),
-                              process_sp->GetAddressByteSize());
+      DataExtractor extractor(buffer, sizeof(buffer), m_process.GetByteOrder(),
+                              m_process.GetAddressByteSize());
 
       bool data_from_file = false;
       if (addr_valid)
         disassembler->DecodeInstructions(pc_addr, extractor, 0, 1, false,
                                          data_from_file);
       else
         disassembler->DecodeInstructions(Address(pc), extractor, 0, 1, false,
                                          data_from_file);
 
       InstructionList &instruction_list = disassembler->GetInstructionList();
       const uint32_t max_opcode_byte_size =
           instruction_list.GetMaxOpcocdeByteSize();
 
       if (instruction_list.GetSize()) {
         const bool show_bytes = true;
         const bool show_address = true;
         Instruction *instruction =
             instruction_list.GetInstructionAtIndex(0).get();
         const FormatEntity::Entry *disassemble_format =
-            m_thread.GetProcess()
-                ->GetTarget()
-                .GetDebugger()
-                .GetDisassemblyFormat();
+            m_process.GetTarget().GetDebugger().GetDisassemblyFormat();
         instruction->Dump(stream, max_opcode_byte_size, show_address,
                           show_bytes, nullptr, nullptr, nullptr,
                           disassemble_format, 0);
       }
     }
   }
 
-  const ABI *abi = process_sp->GetABI().get();
+  const ABI *abi = m_process.GetABI().get();
   TypeFromUser intptr_type = GetIntPointerType();
 
   if (abi && intptr_type.IsValid()) {
     ValueList value_list;
     const int num_args = 1;
 
     for (int arg_index = 0; arg_index < num_args; ++arg_index) {
       Value value;
       value.SetValueType(Value::eValueTypeScalar);
       value.SetCompilerType(intptr_type);
       value_list.PushValue(value);
     }
 
-    if (abi->GetArgumentValues(m_thread, value_list)) {
+    if (abi->GetArgumentValues(GetThread(), value_list)) {
       for (int arg_index = 0; arg_index < num_args; ++arg_index) {
         stream->Printf(
             "\n\targ[%d]=%llx", arg_index,
             value_list.GetValueAtIndex(arg_index)->GetScalar().ULongLong());
 
         if (arg_index + 1 < num_args)
           stream->PutCString(", ");
       }
     }
   }
 
   if (m_register_values.empty()) {
-    RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
+    RegisterContext *reg_ctx = GetThread().GetRegisterContext().get();
     m_register_values.resize(reg_ctx->GetRegisterCount());
   }
 
   RegisterValue reg_value;
   for (uint32_t reg_num = 0, num_registers = reg_ctx->GetRegisterCount();
        reg_num < num_registers; ++reg_num) {
     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
     if (reg_ctx->ReadRegister(reg_info, reg_value)) {