[Process] Remove unused field from HistoryThread

[xiaobai]

Summary

These fields are unused and have been since their inception, from what
I can tell.

[clayborg]

Added Jason and Jim. Not sure if all libdispatch stuff is in llvm.org? Either Jim or Jason should ok this just in case they still use this in Apple specific repos.

lldb/trunk/source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp

MainThreadCheckerRuntime::GetBacktracesFromExtendedStopInfo(
   });
   
   if (PCs.empty())
     return threads;
   
   StructuredData::ObjectSP thread_id_obj =
       info->GetObjectForDotSeparatedPath("tid");
   tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
-  
-  uint32_t stop_id = 0;
-  bool stop_id_is_valid = false;
-  HistoryThread *history_thread =
-      new HistoryThread(*process_sp, tid, PCs, stop_id, stop_id_is_valid);
+  HistoryThread *history_thread = new HistoryThread(*process_sp, tid, PCs);
   ThreadSP new_thread_sp(history_thread);
   
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   threads->AddThread(new_thread_sp);
 
   return threads;
 }

lldb/trunk/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
 
         if (pcs.size() == 0)
           return true;
 
         StructuredData::ObjectSP thread_id_obj =
             o->GetObjectForDotSeparatedPath("thread_os_id");
         tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
 
-        uint32_t stop_id = 0;
-        bool stop_id_is_valid = false;
         HistoryThread *history_thread =
-            new HistoryThread(*process_sp, tid, pcs, stop_id, stop_id_is_valid);
+            new HistoryThread(*process_sp, tid, pcs);
         ThreadSP new_thread_sp(history_thread);
         new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
 
         // Save this in the Process' ExtendedThreadList so a strong pointer
         // retains the object
         process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
         threads->AddThread(new_thread_sp);
 

lldb/trunk/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

UndefinedBehaviorSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
 
   if (PCs.empty())
     return threads;
 
   StructuredData::ObjectSP thread_id_obj =
       info->GetObjectForDotSeparatedPath("tid");
   tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
 
-  uint32_t stop_id = 0;
-  bool stop_id_is_valid = false;
-  HistoryThread *history_thread =
-      new HistoryThread(*process_sp, tid, PCs, stop_id, stop_id_is_valid);
+  HistoryThread *history_thread = new HistoryThread(*process_sp, tid, PCs);
   ThreadSP new_thread_sp(history_thread);
   std::string stop_reason_description = GetStopReasonDescription(info);
   new_thread_sp->SetName(stop_reason_description.c_str());
 
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   threads->AddThread(new_thread_sp);
 
   return threads;
 }

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

for (size_t idx = 0; idx < count; idx++) {
     Status error;
     addr_t pc = m_process->ReadPointerFromMemory(
         frames_addr + (ignore + idx) * ptr_size, error);
     pcs.push_back(pc);
   }
 
   if (pcs.empty()) return ThreadSP();
 
-  ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs, 0, false));
+  ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs));
   m_process->GetExtendedThreadList().AddThread(new_thread_sp);
   return new_thread_sp;
 }
 
 std::tuple<FileSpec, ConstString>
 AppleObjCRuntime::GetExceptionThrowLocation() {
   return std::make_tuple(
       FileSpec("libobjc.A.dylib"), ConstString("objc_exception_throw"));

lldb/trunk/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

static void CreateHistoryThreadFromValueObject(ProcessSP process_sp,
   std::vector<lldb::addr_t> pcs;
   for (int i = 0; i < count; i++) {
     addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0);
     if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS)
       continue;
     pcs.push_back(pc);
   }
 
-  HistoryThread *history_thread =
-      new HistoryThread(*process_sp, tid, pcs, 0, false);
+  HistoryThread *history_thread = new HistoryThread(*process_sp, tid, pcs);
   ThreadSP new_thread_sp(history_thread);
   std::ostringstream thread_name_with_number;
   thread_name_with_number << thread_name << " Thread " << tid;
   history_thread->SetThreadName(thread_name_with_number.str().c_str());
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   result.push_back(new_thread_sp);

lldb/trunk/source/Plugins/Process/Utility/HistoryThread.h

 
 namespace lldb_private {
 
 /// \class HistoryThread HistoryThread.h "HistoryThread.h"
 /// A thread object representing a backtrace from a previous point in the
 /// process execution
 ///
 /// This subclass of Thread is used to provide a backtrace from earlier in
-/// process execution.  It is given a backtrace list of pc addresses and
-/// optionally a stop_id of when those pc addresses were collected, and it
+/// process execution.  It is given a backtrace list of pc addresses and it
 /// will create stack frames for them.
 
 class HistoryThread : public lldb_private::Thread {
 public:
   HistoryThread(lldb_private::Process &process, lldb::tid_t tid,
-                std::vector<lldb::addr_t> pcs, uint32_t stop_id,
-                bool stop_id_is_valid);
+                std::vector<lldb::addr_t> pcs);
 
   ~HistoryThread() override;
 
   lldb::RegisterContextSP GetRegisterContext() override;
 
   lldb::RegisterContextSP
   CreateRegisterContextForFrame(StackFrame *frame) override;
 
public:
   void SetName(const char *name) override { m_thread_name = name; }
 
 protected:
   virtual lldb::StackFrameListSP GetStackFrameList();
 
   mutable std::mutex m_framelist_mutex;
   lldb::StackFrameListSP m_framelist;
   std::vector<lldb::addr_t> m_pcs;
-  uint32_t m_stop_id;
-  bool m_stop_id_is_valid;
 
   uint64_t m_extended_unwind_token;
   std::string m_queue_name;
   std::string m_thread_name;
   lldb::tid_t m_originating_unique_thread_id;
   lldb::queue_id_t m_queue_id;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_HistoryThread_h_

lldb/trunk/source/Plugins/Process/Utility/HistoryThread.cpp

 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 //  Constructor
 
 HistoryThread::HistoryThread(lldb_private::Process &process, lldb::tid_t tid,
-                             std::vector<lldb::addr_t> pcs, uint32_t stop_id,
-                             bool stop_id_is_valid)
+                             std::vector<lldb::addr_t> pcs)
     : Thread(process, tid, true), m_framelist_mutex(), m_framelist(),
-      m_pcs(pcs), m_stop_id(stop_id), m_stop_id_is_valid(stop_id_is_valid),
-      m_extended_unwind_token(LLDB_INVALID_ADDRESS), m_queue_name(),
+      m_pcs(pcs), m_extended_unwind_token(LLDB_INVALID_ADDRESS), m_queue_name(),
       m_thread_name(), m_originating_unique_thread_id(tid),
       m_queue_id(LLDB_INVALID_QUEUE_ID) {
-  m_unwinder_up.reset(new HistoryUnwind(*this, pcs, stop_id_is_valid));
+  m_unwinder_up.reset(new HistoryUnwind(*this, pcs));
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p HistoryThread::HistoryThread", static_cast<void *>(this));
 }
 
 //  Destructor
 
 HistoryThread::~HistoryThread() {

lldb/trunk/source/Plugins/Process/Utility/HistoryUnwind.h

 
 #include "lldb/Target/Unwind.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class HistoryUnwind : public lldb_private::Unwind {
 public:
-  HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs,
-                bool stop_id_is_valid);
+  HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs);
 
   ~HistoryUnwind() override;
 
 protected:
   void DoClear() override;
 
   lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(StackFrame *frame) override;
 
   bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
                              lldb::addr_t &pc) override;
   uint32_t DoGetFrameCount() override;
 
 private:
   std::vector<lldb::addr_t> m_pcs;
-  bool m_stop_id_is_valid;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_HistoryUnwind_h_

lldb/trunk/source/Plugins/Process/Utility/HistoryUnwind.cpp

 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Constructor
 
-HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs,
-                             bool stop_id_is_valid)
-    : Unwind(thread), m_pcs(pcs), m_stop_id_is_valid(stop_id_is_valid) {}
+HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs)
+    : Unwind(thread), m_pcs(pcs) {}
 
 // Destructor
 
 HistoryUnwind::~HistoryUnwind() {}
 
 void HistoryUnwind::DoClear() {
   std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
   m_pcs.clear();
-  m_stop_id_is_valid = false;
 }
 
 lldb::RegisterContextSP
 HistoryUnwind::DoCreateRegisterContextForFrame(StackFrame *frame) {
   RegisterContextSP rctx;
   if (frame) {
     addr_t pc = frame->GetFrameCodeAddress().GetLoadAddress(
         &frame->GetThread()->GetProcess()->GetTarget());

lldb/trunk/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
         DataBufferHeap data(ret.item_buffer_size, 0);
         if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
                                   ret.item_buffer_size, error) &&
             error.Success()) {
           DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                                   m_process->GetByteOrder(),
                                   m_process->GetAddressByteSize());
           ItemInfo item = ExtractItemInfoFromBuffer(extractor);
-          bool stop_id_is_valid = true;
-          if (item.stop_id == 0)
-            stop_id_is_valid = false;
           originating_thread_sp = std::make_shared<HistoryThread>(
-              *m_process, item.enqueuing_thread_id, item.enqueuing_callstack,
-              item.stop_id, stop_id_is_valid);
+              *m_process, item.enqueuing_thread_id, item.enqueuing_callstack);
           originating_thread_sp->SetExtendedBacktraceToken(
               item.item_that_enqueued_this);
           originating_thread_sp->SetQueueName(
               item.enqueuing_queue_label.c_str());
           originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
           //                    originating_thread_sp->SetThreadName
           //                    (item.enqueuing_thread_label.c_str());
         }
if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS &&
     DataBufferHeap data(ret.item_buffer_size, 0);
     if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
                               ret.item_buffer_size, error) &&
         error.Success()) {
       DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                               m_process->GetByteOrder(),
                               m_process->GetAddressByteSize());
       ItemInfo item = ExtractItemInfoFromBuffer(extractor);
-      bool stop_id_is_valid = true;
-      if (item.stop_id == 0)
-        stop_id_is_valid = false;
       return_thread_sp = std::make_shared<HistoryThread>(
-          *m_process, item.enqueuing_thread_id, item.enqueuing_callstack,
-          item.stop_id, stop_id_is_valid);
+          *m_process, item.enqueuing_thread_id, item.enqueuing_callstack);
       return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this);
       return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str());
       return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
       //            return_thread_sp->SetThreadName
       //            (item.enqueuing_thread_label.c_str());
 
       m_page_to_free = ret.item_buffer_ptr;
       m_page_to_free_size = ret.item_buffer_size;
     }
   }
   return return_thread_sp;
 }
 
 ThreadSP
 SystemRuntimeMacOSX::GetExtendedBacktraceForQueueItem(QueueItemSP queue_item_sp,
                                                       ConstString type) {
   ThreadSP extended_thread_sp;
   if (type != "libdispatch")
     return extended_thread_sp;
 
-  bool stop_id_is_valid = true;
-  if (queue_item_sp->GetStopID() == 0)
-    stop_id_is_valid = false;
-
   extended_thread_sp = std::make_shared<HistoryThread>(
       *m_process, queue_item_sp->GetEnqueueingThreadID(),
-      queue_item_sp->GetEnqueueingBacktrace(), queue_item_sp->GetStopID(),
-      stop_id_is_valid);
+      queue_item_sp->GetEnqueueingBacktrace());
   extended_thread_sp->SetExtendedBacktraceToken(
       queue_item_sp->GetItemThatEnqueuedThis());
   extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
   extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
   //    extended_thread_sp->SetThreadName
   //    (queue_item_sp->GetThreadLabel().c_str());
 
   return extended_thread_sp;