bf9a77305f
This moves the following classes from Core -> Utility. ConstString Error RegularExpression Stream StreamString The goal here is to get lldbUtility into a state where it has no dependendencies except on itself and LLVM, so it can be the starting point at which to start untangling LLDB's dependencies. These are all low level and very widely used classes, and previously lldbUtility had dependencies up to lldbCore in order to use these classes. So moving then down to lldbUtility makes sense from both the short term and long term perspective in solving this problem. Differential Revision: https://reviews.llvm.org/D29427 llvm-svn: 293941
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();
|
|
}
|
|
|
|
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());
|
|
}
|