285 lines
9.0 KiB
C++
285 lines
9.0 KiB
C++
|
//===-- 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/Utility/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();
|
||
|
|
}
|
||
|
|
|
||
|
|
Status NativeThreadDarwin::SetWatchpoint(lldb::addr_t addr, size_t size,
|
||
|
|
uint32_t watch_flags, bool hardware) {
|
||
|
|
Status error;
|
||
|
|
error.SetErrorString("not yet implemented");
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
|
||
|
|
Status NativeThreadDarwin::RemoveWatchpoint(lldb::addr_t addr) {
|
||
|
|
Status 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());
|
||
|
|
}
|