lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp - llvm-project - Git at Google

 //===-- NativeThreadDarwin.cpp -------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "NativeThreadDarwin.h"

 // C includes
 #include <libproc.h>

 // LLDB includes
 #include "lldb/Core/Stream.h"

 #include "NativeProcessDarwin.h"

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_darwin;

 uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID(
     ::thread_t mach_port_id) {
   thread_identifier_info_data_t tident;
   mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT;

   auto mach_err = ::thread_info(mach_port_id, THREAD_IDENTIFIER_INFO,
                                 (thread_info_t)&tident, &tident_count);
   if (mach_err != KERN_SUCCESS) {
     // When we fail to get thread info for the supposed port, assume it is
     // really a globally unique thread id already, or return the best thing
     // we can, which is the thread port.
     return mach_port_id;
   }
   return tident.thread_id;
 }

 NativeThreadDarwin::NativeThreadDarwin(NativeProcessDarwin *process,
                                        bool is_64_bit,
                                        lldb::tid_t unique_thread_id,
                                        ::thread_t mach_thread_port)
     : NativeThreadProtocol(process, unique_thread_id),
       m_mach_thread_port(mach_thread_port), m_basic_info(),
       m_proc_threadinfo() {}

 bool NativeThreadDarwin::GetIdentifierInfo() {
   // Don't try to get the thread info once and cache it for the life of the
   // thread.  It changes over time, for instance
   // if the thread name changes, then the thread_handle also changes...  So you
   // have to refetch it every time.
   mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
   kern_return_t kret = ::thread_info(m_mach_thread_port, THREAD_IDENTIFIER_INFO,
                                      (thread_info_t)&m_ident_info, &count);
   return kret == KERN_SUCCESS;

   return false;
 }

 std::string NativeThreadDarwin::GetName() {
   std::string name;

   if (GetIdentifierInfo()) {
     auto process_sp = GetProcess();
     if (!process_sp) {
       name = "<unavailable>";
       return name;
     }

     int len = ::proc_pidinfo(process_sp->GetID(), PROC_PIDTHREADINFO,
                              m_ident_info.thread_handle, &m_proc_threadinfo,
                              sizeof(m_proc_threadinfo));

     if (len && m_proc_threadinfo.pth_name[0])
       name = m_proc_threadinfo.pth_name;
   }
   return name;
 }

 lldb::StateType NativeThreadDarwin::GetState() {
   // TODO implement
   return eStateInvalid;
 }

 bool NativeThreadDarwin::GetStopReason(ThreadStopInfo &stop_info,
                                        std::string &description) {
   // TODO implement
   return false;
 }

 NativeRegisterContextSP NativeThreadDarwin::GetRegisterContext() {
   // TODO implement
   return NativeRegisterContextSP();
 }

 Error NativeThreadDarwin::SetWatchpoint(lldb::addr_t addr, size_t size,
                                         uint32_t watch_flags, bool hardware) {
   Error error;
   error.SetErrorString("not yet implemented");
   return error;
 }

 Error NativeThreadDarwin::RemoveWatchpoint(lldb::addr_t addr) {
   Error error;
   error.SetErrorString("not yet implemented");
   return error;
 }

 void NativeThreadDarwin::Dump(Stream &stream) const {
 // This is what we really want once we have the thread class wired up.
 #if 0
     DNBLogThreaded("[%3u] #%3u tid: 0x%8.8" PRIx64 ", pc: 0x%16.16" PRIx64 ", sp: 0x%16.16" PRIx64 ", user: %d.%6.6d, system: %d.%6.6d, cpu: %2d, policy: %2d, run_state: %2d (%s), flags: %2d, suspend_count: %2d (current %2d), sleep_time: %d",
                    index,
                    m_seq_id,
                    m_unique_id,
                    GetPC(INVALID_NUB_ADDRESS),
                    GetSP(INVALID_NUB_ADDRESS),
                    m_basic_info.user_time.seconds,      m_basic_info.user_time.microseconds,
                    m_basic_info.system_time.seconds,    m_basic_info.system_time.microseconds,
                    m_basic_info.cpu_usage,
                    m_basic_info.policy,
                    m_basic_info.run_state,
                    thread_run_state,
                    m_basic_info.flags,
                    m_basic_info.suspend_count, m_suspend_count,
                    m_basic_info.sleep_time);

 #else
   // Here's all we have right now.
   stream.Printf("tid: 0x%8.8" PRIx64 ", thread port: 0x%4.4x", GetID(),
                 m_mach_thread_port);
 #endif
 }

 bool NativeThreadDarwin::NotifyException(MachException::Data &exc) {
 // TODO implement this.
 #if 0
     // Allow the arch specific protocol to process (MachException::Data &)exc
     // first before possible reassignment of m_stop_exception with exc.
     // See also MachThread::GetStopException().
     bool handled = m_arch_ap->NotifyException(exc);

     if (m_stop_exception.IsValid())
     {
         // We may have more than one exception for a thread, but we need to
         // only remember the one that we will say is the reason we stopped.
         // We may have been single stepping and also gotten a signal exception,
         // so just remember the most pertinent one.
         if (m_stop_exception.IsBreakpoint())
             m_stop_exception = exc;
     }
     else
     {
         m_stop_exception = exc;
     }

     return handled;
 #else
   // Pretend we handled it.
   return true;
 #endif
 }

 bool NativeThreadDarwin::ShouldStop(bool &step_more) const {
 // TODO: implement this
 #if 0
     // See if this thread is at a breakpoint?
     DNBBreakpoint *bp = CurrentBreakpoint();

     if (bp)
     {
         // This thread is sitting at a breakpoint, ask the breakpoint
         // if we should be stopping here.
         return true;
     }
     else
     {
         if (m_arch_ap->StepNotComplete())
         {
             step_more = true;
             return false;
         }
         // The thread state is used to let us know what the thread was
         // trying to do. MachThread::ThreadWillResume() will set the
         // thread state to various values depending if the thread was
         // the current thread and if it was to be single stepped, or
         // resumed.
         if (GetState() == eStateRunning)
         {
             // If our state is running, then we should continue as we are in
             // the process of stepping over a breakpoint.
             return false;
         }
         else
         {
             // Stop if we have any kind of valid exception for this
             // thread.
             if (GetStopException().IsValid())
                 return true;
         }
     }
     return false;
 #else
   return false;
 #endif
 }

 void NativeThreadDarwin::ThreadDidStop() {
 // TODO implement this.
 #if 0
     // This thread has existed prior to resuming under debug nub control,
     // and has just been stopped. Do any cleanup that needs to be done
     // after running.

     // The thread state and breakpoint will still have the same values
     // as they had prior to resuming the thread, so it makes it easy to check
     // if we were trying to step a thread, or we tried to resume while being
     // at a breakpoint.

     // When this method gets called, the process state is still in the
     // state it was in while running so we can act accordingly.
     m_arch_ap->ThreadDidStop();


     // We may have suspended this thread so the primary thread could step
     // without worrying about race conditions, so lets restore our suspend
     // count.
     RestoreSuspendCountAfterStop();

     // Update the basic information for a thread
     MachThread::GetBasicInfo(m_mach_port_number, &m_basic_info);

     if (m_basic_info.suspend_count > 0)
         SetState(eStateSuspended);
     else
         SetState(eStateStopped);
 #endif
 }

 bool NativeThreadDarwin::MachPortNumberIsValid(::thread_t thread) {
   return thread != (::thread_t)(0);
 }

 const struct thread_basic_info *NativeThreadDarwin::GetBasicInfo() const {
   if (GetBasicInfo(m_mach_thread_port, &m_basic_info))
     return &m_basic_info;
   return NULL;
 }

 bool NativeThreadDarwin::GetBasicInfo(::thread_t thread,
                                       struct thread_basic_info *basicInfoPtr) {
   if (MachPortNumberIsValid(thread)) {
     unsigned int info_count = THREAD_BASIC_INFO_COUNT;
     kern_return_t err = ::thread_info(thread, THREAD_BASIC_INFO,
                                       (thread_info_t)basicInfoPtr, &info_count);
     if (err == KERN_SUCCESS)
       return true;
   }
   ::memset(basicInfoPtr, 0, sizeof(struct thread_basic_info));
   return false;
 }

 bool NativeThreadDarwin::IsUserReady() const {
   if (m_basic_info.run_state == 0)
     GetBasicInfo();

   switch (m_basic_info.run_state) {
   default:
   case TH_STATE_UNINTERRUPTIBLE:
     break;

   case TH_STATE_RUNNING:
   case TH_STATE_STOPPED:
   case TH_STATE_WAITING:
   case TH_STATE_HALTED:
     return true;
   }
   return false;
 }

 NativeProcessDarwinSP NativeThreadDarwin::GetNativeProcessDarwinSP() {
   return std::static_pointer_cast<NativeProcessDarwin>(GetProcess());
 }
	//===-- NativeThreadDarwin.cpp -------------------------------- -- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "NativeThreadDarwin.h"

	// C includes
	#include <libproc.h>

	// LLDB includes
	#include "lldb/Core/Stream.h"

	#include "NativeProcessDarwin.h"

	using namespace lldb;
	using namespace lldb_private;
	using namespace lldb_private::process_darwin;

	uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID(
	::thread_t mach_port_id) {
	thread_identifier_info_data_t tident;
	mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT;

	auto mach_err = ::thread_info(mach_port_id, THREAD_IDENTIFIER_INFO,
	(thread_info_t)&tident, &tident_count);
	if (mach_err != KERN_SUCCESS) {
	// When we fail to get thread info for the supposed port, assume it is
	// really a globally unique thread id already, or return the best thing
	// we can, which is the thread port.
	return mach_port_id;
	}
	return tident.thread_id;
	}

	NativeThreadDarwin::NativeThreadDarwin(NativeProcessDarwin *process,
	bool is_64_bit,
	lldb::tid_t unique_thread_id,
	::thread_t mach_thread_port)
	: NativeThreadProtocol(process, unique_thread_id),
	m_mach_thread_port(mach_thread_port), m_basic_info(),
	m_proc_threadinfo() {}

	bool NativeThreadDarwin::GetIdentifierInfo() {
	// Don't try to get the thread info once and cache it for the life of the
	// thread. It changes over time, for instance
	// if the thread name changes, then the thread_handle also changes... So you
	// have to refetch it every time.
	mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
	kern_return_t kret = ::thread_info(m_mach_thread_port, THREAD_IDENTIFIER_INFO,
	(thread_info_t)&m_ident_info, &count);
	return kret == KERN_SUCCESS;

	return false;
	}

	std::string NativeThreadDarwin::GetName() {
	std::string name;

	if (GetIdentifierInfo()) {
	auto process_sp = GetProcess();
	if (!process_sp) {
	name = "<unavailable>";
	return name;
	}

	int len = ::proc_pidinfo(process_sp->GetID(), PROC_PIDTHREADINFO,
	m_ident_info.thread_handle, &m_proc_threadinfo,
	sizeof(m_proc_threadinfo));

	if (len && m_proc_threadinfo.pth_name[0])
	name = m_proc_threadinfo.pth_name;
	}
	return name;
	}

	lldb::StateType NativeThreadDarwin::GetState() {
	// TODO implement
	return eStateInvalid;
	}

	bool NativeThreadDarwin::GetStopReason(ThreadStopInfo &stop_info,
	std::string &description) {
	// TODO implement
	return false;
	}

	NativeRegisterContextSP NativeThreadDarwin::GetRegisterContext() {
	// TODO implement
	return NativeRegisterContextSP();
	}

	Error NativeThreadDarwin::SetWatchpoint(lldb::addr_t addr, size_t size,
	uint32_t watch_flags, bool hardware) {
	Error error;
	error.SetErrorString("not yet implemented");
	return error;
	}

	Error NativeThreadDarwin::RemoveWatchpoint(lldb::addr_t addr) {
	Error error;
	error.SetErrorString("not yet implemented");
	return error;
	}

	void NativeThreadDarwin::Dump(Stream &stream) const {
	// This is what we really want once we have the thread class wired up.
	#if 0
	DNBLogThreaded("[%3u] #%3u tid: 0x%8.8" PRIx64 ", pc: 0x%16.16" PRIx64 ", sp: 0x%16.16" PRIx64 ", user: %d.%6.6d, system: %d.%6.6d, cpu: %2d, policy: %2d, run_state: %2d (%s), flags: %2d, suspend_count: %2d (current %2d), sleep_time: %d",
	index,
	m_seq_id,
	m_unique_id,
	GetPC(INVALID_NUB_ADDRESS),
	GetSP(INVALID_NUB_ADDRESS),
	m_basic_info.user_time.seconds, m_basic_info.user_time.microseconds,
	m_basic_info.system_time.seconds, m_basic_info.system_time.microseconds,
	m_basic_info.cpu_usage,
	m_basic_info.policy,
	m_basic_info.run_state,
	thread_run_state,
	m_basic_info.flags,
	m_basic_info.suspend_count, m_suspend_count,
	m_basic_info.sleep_time);

	#else
	// Here's all we have right now.
	stream.Printf("tid: 0x%8.8" PRIx64 ", thread port: 0x%4.4x", GetID(),
	m_mach_thread_port);
	#endif
	}

	bool NativeThreadDarwin::NotifyException(MachException::Data &exc) {
	// TODO implement this.
	#if 0
	// Allow the arch specific protocol to process (MachException::Data &)exc
	// first before possible reassignment of m_stop_exception with exc.
	// See also MachThread::GetStopException().
	bool handled = m_arch_ap->NotifyException(exc);

	if (m_stop_exception.IsValid())
	{
	// We may have more than one exception for a thread, but we need to
	// only remember the one that we will say is the reason we stopped.
	// We may have been single stepping and also gotten a signal exception,
	// so just remember the most pertinent one.
	if (m_stop_exception.IsBreakpoint())
	m_stop_exception = exc;
	}
	else
	{
	m_stop_exception = exc;
	}

	return handled;
	#else
	// Pretend we handled it.
	return true;
	#endif
	}

	bool NativeThreadDarwin::ShouldStop(bool &step_more) const {
	// TODO: implement this
	#if 0
	// See if this thread is at a breakpoint?
	DNBBreakpoint *bp = CurrentBreakpoint();

	if (bp)
	{
	// This thread is sitting at a breakpoint, ask the breakpoint
	// if we should be stopping here.
	return true;
	}
	else
	{
	if (m_arch_ap->StepNotComplete())
	{
	step_more = true;
	return false;
	}
	// The thread state is used to let us know what the thread was
	// trying to do. MachThread::ThreadWillResume() will set the
	// thread state to various values depending if the thread was
	// the current thread and if it was to be single stepped, or
	// resumed.
	if (GetState() == eStateRunning)
	{
	// If our state is running, then we should continue as we are in
	// the process of stepping over a breakpoint.
	return false;
	}
	else
	{
	// Stop if we have any kind of valid exception for this
	// thread.
	if (GetStopException().IsValid())
	return true;
	}
	}
	return false;
	#else
	return false;
	#endif
	}

	void NativeThreadDarwin::ThreadDidStop() {
	// TODO implement this.
	#if 0
	// This thread has existed prior to resuming under debug nub control,
	// and has just been stopped. Do any cleanup that needs to be done
	// after running.

	// The thread state and breakpoint will still have the same values
	// as they had prior to resuming the thread, so it makes it easy to check
	// if we were trying to step a thread, or we tried to resume while being
	// at a breakpoint.

	// When this method gets called, the process state is still in the
	// state it was in while running so we can act accordingly.
	m_arch_ap->ThreadDidStop();


	// We may have suspended this thread so the primary thread could step
	// without worrying about race conditions, so lets restore our suspend
	// count.
	RestoreSuspendCountAfterStop();

	// Update the basic information for a thread
	MachThread::GetBasicInfo(m_mach_port_number, &m_basic_info);

	if (m_basic_info.suspend_count > 0)
	SetState(eStateSuspended);
	else
	SetState(eStateStopped);
	#endif
	}

	bool NativeThreadDarwin::MachPortNumberIsValid(::thread_t thread) {
	return thread != (::thread_t)(0);
	}

	const struct thread_basic_info *NativeThreadDarwin::GetBasicInfo() const {
	if (GetBasicInfo(m_mach_thread_port, &m_basic_info))
	return &m_basic_info;
	return NULL;
	}

	bool NativeThreadDarwin::GetBasicInfo(::thread_t thread,
	struct thread_basic_info *basicInfoPtr) {
	if (MachPortNumberIsValid(thread)) {
	unsigned int info_count = THREAD_BASIC_INFO_COUNT;
	kern_return_t err = ::thread_info(thread, THREAD_BASIC_INFO,
	(thread_info_t)basicInfoPtr, &info_count);
	if (err == KERN_SUCCESS)
	return true;
	}
	::memset(basicInfoPtr, 0, sizeof(struct thread_basic_info));
	return false;
	}

	bool NativeThreadDarwin::IsUserReady() const {
	if (m_basic_info.run_state == 0)
	GetBasicInfo();

	switch (m_basic_info.run_state) {
	default:
	case TH_STATE_UNINTERRUPTIBLE:
	break;

	case TH_STATE_RUNNING:
	case TH_STATE_STOPPED:
	case TH_STATE_WAITING:
	case TH_STATE_HALTED:
	return true;
	}
	return false;
	}

	NativeProcessDarwinSP NativeThreadDarwin::GetNativeProcessDarwinSP() {
	return std::static_pointer_cast<NativeProcessDarwin>(GetProcess());
	}