maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

841 lines
34 KiB
C++
Raw Blame History

//===-- SystemRuntimeMacOSX.cpp ---------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Section.h"
#include "lldb/Expression/ClangFunction.h"
#include "lldb/Expression/ClangUtilityFunction.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h"
#include "Plugins/Process/Utility/HistoryThread.h"
#include "lldb/Target/Queue.h"
#include "lldb/Target/QueueList.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/Process.h"
#include "SystemRuntimeMacOSX.h"
using namespace lldb;
using namespace lldb_private;
//----------------------------------------------------------------------
// Create an instance of this class. This function is filled into
// the plugin info class that gets handed out by the plugin factory and
// allows the lldb to instantiate an instance of this class.
//----------------------------------------------------------------------
SystemRuntime *
SystemRuntimeMacOSX::CreateInstance (Process* process)
{
bool create = false;
if (!create)
{
create = true;
Module* exe_module = process->GetTarget().GetExecutableModulePointer();
if (exe_module)
{
ObjectFile *object_file = exe_module->GetObjectFile();
if (object_file)
{
create = (object_file->GetStrata() == ObjectFile::eStrataUser);
}
}
if (create)
{
const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
switch (triple_ref.getOS())
{
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
case llvm::Triple::IOS:
create = triple_ref.getVendor() == llvm::Triple::Apple;
break;
default:
create = false;
break;
}
}
}
if (create)
return new SystemRuntimeMacOSX (process);
return NULL;
}
//----------------------------------------------------------------------
// Constructor
//----------------------------------------------------------------------
SystemRuntimeMacOSX::SystemRuntimeMacOSX (Process* process) :
SystemRuntime(process),
m_break_id(LLDB_INVALID_BREAK_ID),
m_mutex(Mutex::eMutexTypeRecursive),
m_get_queues_handler(process),
m_get_pending_items_handler(process),
m_get_item_info_handler(process),
m_get_thread_item_info_handler(process),
m_page_to_free(LLDB_INVALID_ADDRESS),
m_page_to_free_size(0),
m_lib_backtrace_recording_info(),
m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS),
m_libdispatch_offsets()
{
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
SystemRuntimeMacOSX::~SystemRuntimeMacOSX()
{
Clear (true);
}
void
SystemRuntimeMacOSX::Detach ()
{
m_get_queues_handler.Detach();
m_get_pending_items_handler.Detach();
m_get_item_info_handler.Detach();
m_get_thread_item_info_handler.Detach();
}
//----------------------------------------------------------------------
// Clear out the state of this class.
//----------------------------------------------------------------------
void
SystemRuntimeMacOSX::Clear (bool clear_process)
{
Mutex::Locker locker(m_mutex);
if (m_process->IsAlive() && LLDB_BREAK_ID_IS_VALID(m_break_id))
m_process->ClearBreakpointSiteByID(m_break_id);
if (clear_process)
m_process = NULL;
m_break_id = LLDB_INVALID_BREAK_ID;
}
std::string
SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress (addr_t dispatch_qaddr)
{
std::string dispatch_queue_name;
if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
return "";
ReadLibdispatchOffsets ();
if (m_libdispatch_offsets.IsValid ())
{
// dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a thread -
// deref it to get the address of the dispatch_queue_t structure for this thread's
// queue.
Error error;
addr_t dispatch_queue_addr = m_process->ReadPointerFromMemory (dispatch_qaddr, error);
if (error.Success())
{
if (m_libdispatch_offsets.dqo_version >= 4)
{
// libdispatch versions 4+, pointer to dispatch name is in the
// queue structure.
addr_t pointer_to_label_address = dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
addr_t label_addr = m_process->ReadPointerFromMemory (pointer_to_label_address, error);
if (error.Success())
{
m_process->ReadCStringFromMemory (label_addr, dispatch_queue_name, error);
}
}
else
{
// libdispatch versions 1-3, dispatch name is a fixed width char array
// in the queue structure.
addr_t label_addr = dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
dispatch_queue_name.resize (m_libdispatch_offsets.dqo_label_size, '\0');
size_t bytes_read = m_process->ReadMemory (label_addr, &dispatch_queue_name[0], m_libdispatch_offsets.dqo_label_size, error);
if (bytes_read < m_libdispatch_offsets.dqo_label_size)
dispatch_queue_name.erase (bytes_read);
}
}
}
return dispatch_queue_name;
}
lldb::addr_t
SystemRuntimeMacOSX::GetLibdispatchQueueAddressFromThreadQAddress (addr_t dispatch_qaddr)
{
addr_t libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
Error error;
libdispatch_queue_t_address = m_process->ReadPointerFromMemory (dispatch_qaddr, error);
if (!error.Success())
{
libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
}
return libdispatch_queue_t_address;
}
lldb::QueueKind
SystemRuntimeMacOSX::GetQueueKind (addr_t dispatch_queue_addr)
{
if (dispatch_queue_addr == LLDB_INVALID_ADDRESS || dispatch_queue_addr == 0)
return eQueueKindUnknown;
QueueKind kind = eQueueKindUnknown;
ReadLibdispatchOffsets ();
if (m_libdispatch_offsets.IsValid () && m_libdispatch_offsets.dqo_version >= 4)
{
Error error;
uint64_t width = m_process->ReadUnsignedIntegerFromMemory (dispatch_queue_addr + m_libdispatch_offsets.dqo_width, m_libdispatch_offsets.dqo_width_size, 0, error);
if (error.Success())
{
if (width == 1)
{
kind = eQueueKindSerial;
}
if (width > 1)
{
kind = eQueueKindConcurrent;
}
}
}
return kind;
}
lldb::queue_id_t
SystemRuntimeMacOSX::GetQueueIDFromThreadQAddress (lldb::addr_t dispatch_qaddr)
{
queue_id_t queue_id = LLDB_INVALID_QUEUE_ID;
if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
return queue_id;
ReadLibdispatchOffsets ();
if (m_libdispatch_offsets.IsValid ())
{
// dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a thread -
// deref it to get the address of the dispatch_queue_t structure for this thread's
// queue.
Error error;
uint64_t dispatch_queue_addr = m_process->ReadPointerFromMemory (dispatch_qaddr, error);
if (error.Success())
{
addr_t serialnum_address = dispatch_queue_addr + m_libdispatch_offsets.dqo_serialnum;
queue_id_t serialnum = m_process->ReadUnsignedIntegerFromMemory (serialnum_address, m_libdispatch_offsets.dqo_serialnum_size, LLDB_INVALID_QUEUE_ID, error);
if (error.Success())
{
queue_id = serialnum;
}
}
}
return queue_id;
}
void
SystemRuntimeMacOSX::ReadLibdispatchOffsetsAddress ()
{
if (m_dispatch_queue_offsets_addr != LLDB_INVALID_ADDRESS)
return;
static ConstString g_dispatch_queue_offsets_symbol_name ("dispatch_queue_offsets");
const Symbol *dispatch_queue_offsets_symbol = NULL;
// libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6 ("Snow Leopard")
ModuleSpec libSystem_module_spec (FileSpec("libSystem.B.dylib", false));
ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule (libSystem_module_spec));
if (module_sp)
dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
// libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion") and later
if (dispatch_queue_offsets_symbol == NULL)
{
ModuleSpec libdispatch_module_spec (FileSpec("libdispatch.dylib", false));
module_sp = m_process->GetTarget().GetImages().FindFirstModule (libdispatch_module_spec);
if (module_sp)
dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
}
if (dispatch_queue_offsets_symbol)
m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetAddress().GetLoadAddress(&m_process->GetTarget());
}
void
SystemRuntimeMacOSX::ReadLibdispatchOffsets ()
{
if (m_libdispatch_offsets.IsValid())
return;
ReadLibdispatchOffsetsAddress ();
uint8_t memory_buffer[sizeof (struct LibdispatchOffsets)];
DataExtractor data (memory_buffer,
sizeof(memory_buffer),
m_process->GetByteOrder(),
m_process->GetAddressByteSize());
Error error;
if (m_process->ReadMemory (m_dispatch_queue_offsets_addr, memory_buffer, sizeof(memory_buffer), error) == sizeof(memory_buffer))
{
lldb::offset_t data_offset = 0;
// The struct LibdispatchOffsets is a series of uint16_t's - extract them all
// in one big go.
data.GetU16 (&data_offset, &m_libdispatch_offsets.dqo_version, sizeof (struct LibdispatchOffsets) / sizeof (uint16_t));
}
}
ThreadSP
SystemRuntimeMacOSX::GetExtendedBacktraceThread (ThreadSP real_thread, ConstString type)
{
ThreadSP originating_thread_sp;
if (BacktraceRecordingHeadersInitialized() && type == ConstString ("libdispatch"))
{
Error error;
// real_thread is either an actual, live thread (in which case we need to call into
// libBacktraceRecording to find its originator) or it is an extended backtrace itself,
// in which case we get the token from it and call into libBacktraceRecording to find
// the originator of that token.
if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS)
{
originating_thread_sp = GetExtendedBacktraceFromItemRef (real_thread->GetExtendedBacktraceToken());
}
else
{
ThreadSP cur_thread_sp (m_process->GetThreadList().GetSelectedThread());
AppleGetThreadItemInfoHandler::GetThreadItemInfoReturnInfo ret = m_get_thread_item_info_handler.GetThreadItemInfo (*cur_thread_sp.get(), real_thread->GetID(), m_page_to_free, m_page_to_free_size, error);
m_page_to_free = LLDB_INVALID_ADDRESS;
m_page_to_free_size = 0;
if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && ret.item_buffer_size > 0)
{
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.reset (new HistoryThread (*m_process,
item.enqueuing_thread_id,
item.enqueuing_callstack,
item.stop_id,
stop_id_is_valid));
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());
}
m_page_to_free = ret.item_buffer_ptr;
m_page_to_free_size = ret.item_buffer_size;
}
}
}
return originating_thread_sp;
}
ThreadSP
SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef (lldb::addr_t item_ref)
{
ThreadSP return_thread_sp;
AppleGetItemInfoHandler::GetItemInfoReturnInfo ret;
ThreadSP cur_thread_sp (m_process->GetThreadList().GetSelectedThread());
Error error;
ret = m_get_item_info_handler.GetItemInfo (*cur_thread_sp.get(), item_ref, m_page_to_free, m_page_to_free_size, error);
m_page_to_free = LLDB_INVALID_ADDRESS;
m_page_to_free_size = 0;
if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && ret.item_buffer_size > 0)
{
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.reset (new HistoryThread (*m_process,
item.enqueuing_thread_id,
item.enqueuing_callstack,
item.stop_id,
stop_id_is_valid));
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 != ConstString("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.reset (new HistoryThread (*m_process,
queue_item_sp->GetEnqueueingThreadID(),
queue_item_sp->GetEnqueueingBacktrace(),
queue_item_sp->GetStopID(),
stop_id_is_valid));
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;
}
/* Returns true if we were able to get the version / offset information
* out of libBacktraceRecording. false means we were unable to retrieve
* this; the queue_info_version field will be 0.
*/
bool
SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized ()
{
if (m_lib_backtrace_recording_info.queue_info_version != 0)
return true;
addr_t queue_info_version_address = LLDB_INVALID_ADDRESS;
addr_t queue_info_data_offset_address = LLDB_INVALID_ADDRESS;
addr_t item_info_version_address = LLDB_INVALID_ADDRESS;
addr_t item_info_data_offset_address = LLDB_INVALID_ADDRESS;
Target &target = m_process->GetTarget();
static ConstString introspection_dispatch_queue_info_version ("__introspection_dispatch_queue_info_version");
SymbolContextList sc_list;
if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list) > 0)
{
SymbolContext sc;
sc_list.GetContextAtIndex (0, sc);
AddressRange addr_range;
sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
queue_info_version_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
}
sc_list.Clear();
static ConstString introspection_dispatch_queue_info_data_offset ("__introspection_dispatch_queue_info_data_offset");
if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_data_offset, eSymbolTypeData, sc_list) > 0)
{
SymbolContext sc;
sc_list.GetContextAtIndex (0, sc);
AddressRange addr_range;
sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
queue_info_data_offset_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
}
sc_list.Clear();
static ConstString introspection_dispatch_item_info_version ("__introspection_dispatch_item_info_version");
if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_version, eSymbolTypeData, sc_list) > 0)
{
SymbolContext sc;
sc_list.GetContextAtIndex (0, sc);
AddressRange addr_range;
sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
item_info_version_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
}
sc_list.Clear();
static ConstString introspection_dispatch_item_info_data_offset ("__introspection_dispatch_item_info_data_offset");
if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_data_offset, eSymbolTypeData, sc_list) > 0)
{
SymbolContext sc;
sc_list.GetContextAtIndex (0, sc);
AddressRange addr_range;
sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
item_info_data_offset_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
}
if (queue_info_version_address != LLDB_INVALID_ADDRESS
&& queue_info_data_offset_address != LLDB_INVALID_ADDRESS
&& item_info_version_address != LLDB_INVALID_ADDRESS
&& item_info_data_offset_address != LLDB_INVALID_ADDRESS)
{
Error error;
m_lib_backtrace_recording_info.queue_info_version = m_process->ReadUnsignedIntegerFromMemory (queue_info_version_address, 2, 0, error);
if (error.Success())
{
m_lib_backtrace_recording_info.queue_info_data_offset = m_process->ReadUnsignedIntegerFromMemory (queue_info_data_offset_address, 2, 0, error);
if (error.Success())
{
m_lib_backtrace_recording_info.item_info_version = m_process->ReadUnsignedIntegerFromMemory (item_info_version_address, 2, 0, error);
if (error.Success())
{
m_lib_backtrace_recording_info.item_info_data_offset = m_process->ReadUnsignedIntegerFromMemory (item_info_data_offset_address, 2, 0, error);
if (!error.Success())
{
m_lib_backtrace_recording_info.queue_info_version = 0;
}
}
else
{
m_lib_backtrace_recording_info.queue_info_version = 0;
}
}
else
{
m_lib_backtrace_recording_info.queue_info_version = 0;
}
}
}
return m_lib_backtrace_recording_info.queue_info_version != 0;
}
const std::vector<ConstString> &
SystemRuntimeMacOSX::GetExtendedBacktraceTypes ()
{
if (m_types.size () == 0)
{
m_types.push_back(ConstString("libdispatch"));
// We could have pthread as another type in the future if we have a way of
// gathering that information & it's useful to distinguish between them.
}
return m_types;
}
void
SystemRuntimeMacOSX::PopulateQueueList (lldb_private::QueueList &queue_list)
{
if (!BacktraceRecordingHeadersInitialized())
{
// We don't have libBacktraceRecording -- build the list of queues by looking at
// all extant threads, and the queues that they currently belong to.
for (ThreadSP thread_sp : m_process->Threads())
{
if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID)
{
if (queue_list.FindQueueByID (thread_sp->GetQueueID()).get() == NULL)
{
QueueSP queue_sp (new Queue(m_process->shared_from_this(), thread_sp->GetQueueID(), thread_sp->GetQueueName()));
queue_sp->SetKind (GetQueueKind (thread_sp->GetQueueLibdispatchQueueAddress()));
queue_sp->SetLibdispatchQueueAddress (thread_sp->GetQueueLibdispatchQueueAddress());
queue_list.AddQueue (queue_sp);
}
}
}
}
else
{
AppleGetQueuesHandler::GetQueuesReturnInfo queue_info_pointer;
ThreadSP cur_thread_sp (m_process->GetThreadList().GetSelectedThread());
if (cur_thread_sp)
{
Error error;
queue_info_pointer = m_get_queues_handler.GetCurrentQueues (*cur_thread_sp.get(), m_page_to_free, m_page_to_free_size, error);
m_page_to_free = LLDB_INVALID_ADDRESS;
m_page_to_free_size = 0;
if (error.Success())
{
if (queue_info_pointer.count > 0
&& queue_info_pointer.queues_buffer_size > 0
&& queue_info_pointer.queues_buffer_ptr != 0
&& queue_info_pointer.queues_buffer_ptr != LLDB_INVALID_ADDRESS)
{
PopulateQueuesUsingLibBTR (queue_info_pointer.queues_buffer_ptr, queue_info_pointer.queues_buffer_size, queue_info_pointer.count, queue_list);
}
}
}
}
}
// Returns either an array of introspection_dispatch_item_info_ref's for the pending items on
// a queue or an array introspection_dispatch_item_info_ref's and code addresses for the
// pending items on a queue. The information about each of these pending items then needs to
// be fetched individually by passing the ref to libBacktraceRecording.
SystemRuntimeMacOSX::PendingItemsForQueue
SystemRuntimeMacOSX::GetPendingItemRefsForQueue (lldb::addr_t queue)
{
PendingItemsForQueue pending_item_refs;
AppleGetPendingItemsHandler::GetPendingItemsReturnInfo pending_items_pointer;
ThreadSP cur_thread_sp (m_process->GetThreadList().GetSelectedThread());
if (cur_thread_sp)
{
Error error;
pending_items_pointer = m_get_pending_items_handler.GetPendingItems (*cur_thread_sp.get(), queue, m_page_to_free, m_page_to_free_size, error);
m_page_to_free = LLDB_INVALID_ADDRESS;
m_page_to_free_size = 0;
if (error.Success())
{
if (pending_items_pointer.count > 0
&& pending_items_pointer.items_buffer_size > 0
&& pending_items_pointer.items_buffer_ptr != 0
&& pending_items_pointer.items_buffer_ptr != LLDB_INVALID_ADDRESS)
{
DataBufferHeap data (pending_items_pointer.items_buffer_size, 0);
if (m_process->ReadMemory (pending_items_pointer.items_buffer_ptr, data.GetBytes(), pending_items_pointer.items_buffer_size, error))
{
DataExtractor extractor (data.GetBytes(), data.GetByteSize(), m_process->GetByteOrder(), m_process->GetAddressByteSize());
// We either have an array of
// void* item_ref
// (old style) or we have a structure returned which looks like
//
// struct introspection_dispatch_pending_item_info_s {
// void *item_ref;
// void *function_or_block;
// };
//
// struct introspection_dispatch_pending_items_array_s {
// uint32_t version;
// uint32_t size_of_item_info;
// introspection_dispatch_pending_item_info_s items[];
// }
offset_t offset = 0;
int i = 0;
uint32_t version = extractor.GetU32(&offset);
if (version == 1)
{
pending_item_refs.new_style = true;
uint32_t item_size = extractor.GetU32(&offset);
uint32_t start_of_array_offset = offset;
while (offset < pending_items_pointer.items_buffer_size &&
static_cast<size_t>(i) < pending_items_pointer.count)
{
offset = start_of_array_offset + (i * item_size);
ItemRefAndCodeAddress item;
item.item_ref = extractor.GetPointer (&offset);
item.code_address = extractor.GetPointer (&offset);
pending_item_refs.item_refs_and_code_addresses.push_back (item);
i++;
}
}
else
{
offset = 0;
pending_item_refs.new_style = false;
while (offset < pending_items_pointer.items_buffer_size &&
static_cast<size_t>(i) < pending_items_pointer.count)
{
ItemRefAndCodeAddress item;
item.item_ref = extractor.GetPointer (&offset);
item.code_address = LLDB_INVALID_ADDRESS;
pending_item_refs.item_refs_and_code_addresses.push_back (item);
i++;
}
}
}
m_page_to_free = pending_items_pointer.items_buffer_ptr;
m_page_to_free_size = pending_items_pointer.items_buffer_size;
}
}
}
return pending_item_refs;
}
void
SystemRuntimeMacOSX::PopulatePendingItemsForQueue (Queue *queue)
{
if (BacktraceRecordingHeadersInitialized())
{
PendingItemsForQueue pending_item_refs = GetPendingItemRefsForQueue (queue->GetLibdispatchQueueAddress());
for (ItemRefAndCodeAddress pending_item : pending_item_refs.item_refs_and_code_addresses)
{
Address addr;
m_process->GetTarget().ResolveLoadAddress (pending_item.code_address, addr);
QueueItemSP queue_item_sp (new QueueItem (queue->shared_from_this(), m_process->shared_from_this(), pending_item.item_ref, addr));
queue->PushPendingQueueItem (queue_item_sp);
}
}
}
void
SystemRuntimeMacOSX::CompleteQueueItem (QueueItem *queue_item, addr_t item_ref)
{
AppleGetItemInfoHandler::GetItemInfoReturnInfo ret;
ThreadSP cur_thread_sp (m_process->GetThreadList().GetSelectedThread());
Error error;
ret = m_get_item_info_handler.GetItemInfo (*cur_thread_sp.get(), item_ref, m_page_to_free, m_page_to_free_size, error);
m_page_to_free = LLDB_INVALID_ADDRESS;
m_page_to_free_size = 0;
if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS && ret.item_buffer_size > 0)
{
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);
queue_item->SetItemThatEnqueuedThis (item.item_that_enqueued_this);
queue_item->SetEnqueueingThreadID (item.enqueuing_thread_id);
queue_item->SetEnqueueingQueueID (item.enqueuing_queue_serialnum);
queue_item->SetStopID (item.stop_id);
queue_item->SetEnqueueingBacktrace (item.enqueuing_callstack);
queue_item->SetThreadLabel (item.enqueuing_thread_label);
queue_item->SetQueueLabel (item.enqueuing_queue_label);
queue_item->SetTargetQueueLabel (item.target_queue_label);
}
m_page_to_free = ret.item_buffer_ptr;
m_page_to_free_size = ret.item_buffer_size;
}
}
void
SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR (lldb::addr_t queues_buffer, uint64_t queues_buffer_size,
uint64_t count, lldb_private::QueueList &queue_list)
{
Error error;
DataBufferHeap data (queues_buffer_size, 0);
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYSTEM_RUNTIME));
if (m_process->ReadMemory (queues_buffer, data.GetBytes(), queues_buffer_size, error) == queues_buffer_size && error.Success())
{
// We've read the information out of inferior memory; free it on the next call we make
m_page_to_free = queues_buffer;
m_page_to_free_size = queues_buffer_size;
DataExtractor extractor (data.GetBytes(), data.GetByteSize(), m_process->GetByteOrder(), m_process->GetAddressByteSize());
offset_t offset = 0;
uint64_t queues_read = 0;
// The information about the queues is stored in this format (v1):
// typedef struct introspection_dispatch_queue_info_s {
// uint32_t offset_to_next;
// dispatch_queue_t queue;
// uint64_t serialnum; // queue's serialnum in the process, as provided by libdispatch
// uint32_t running_work_items_count;
// uint32_t pending_work_items_count;
//
// char data[]; // Starting here, we have variable-length data:
// // char queue_label[];
// } introspection_dispatch_queue_info_s;
while (queues_read < count && offset < queues_buffer_size)
{
offset_t start_of_this_item = offset;
uint32_t offset_to_next = extractor.GetU32 (&offset);
offset += 4; // Skip over the 4 bytes of reserved space
addr_t queue = extractor.GetPointer (&offset);
uint64_t serialnum = extractor.GetU64 (&offset);
uint32_t running_work_items_count = extractor.GetU32 (&offset);
uint32_t pending_work_items_count = extractor.GetU32 (&offset);
// Read the first field of the variable length data
offset = start_of_this_item + m_lib_backtrace_recording_info.queue_info_data_offset;
const char *queue_label = extractor.GetCStr (&offset);
if (queue_label == NULL)
queue_label = "";
offset_t start_of_next_item = start_of_this_item + offset_to_next;
offset = start_of_next_item;
if (log)
log->Printf ("SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR added queue with dispatch_queue_t 0x%" PRIx64 ", serial number 0x%" PRIx64 ", running items %d, pending items %d, name '%s'", queue, serialnum, running_work_items_count, pending_work_items_count, queue_label);
QueueSP queue_sp (new Queue (m_process->shared_from_this(), serialnum, queue_label));
queue_sp->SetNumRunningWorkItems (running_work_items_count);
queue_sp->SetNumPendingWorkItems (pending_work_items_count);
queue_sp->SetLibdispatchQueueAddress (queue);
queue_sp->SetKind (GetQueueKind (queue));
queue_list.AddQueue (queue_sp);
queues_read++;
}
}
}
SystemRuntimeMacOSX::ItemInfo
SystemRuntimeMacOSX::ExtractItemInfoFromBuffer (lldb_private::DataExtractor &extractor)
{
ItemInfo item;
offset_t offset = 0;
item.item_that_enqueued_this = extractor.GetPointer (&offset);
item.function_or_block = extractor.GetPointer (&offset);
item.enqueuing_thread_id = extractor.GetU64 (&offset);
item.enqueuing_queue_serialnum = extractor.GetU64 (&offset);
item.target_queue_serialnum = extractor.GetU64 (&offset);
item.enqueuing_callstack_frame_count = extractor.GetU32 (&offset);
item.stop_id = extractor.GetU32 (&offset);
offset = m_lib_backtrace_recording_info.item_info_data_offset;
for (uint32_t i = 0; i < item.enqueuing_callstack_frame_count; i++)
{
item.enqueuing_callstack.push_back (extractor.GetPointer (&offset));
}
item.enqueuing_thread_label = extractor.GetCStr (&offset);
item.enqueuing_queue_label = extractor.GetCStr (&offset);
item.target_queue_label = extractor.GetCStr (&offset);
return item;
}
void
SystemRuntimeMacOSX::Initialize()
{
PluginManager::RegisterPlugin (GetPluginNameStatic(),
GetPluginDescriptionStatic(),
CreateInstance);
}
void
SystemRuntimeMacOSX::Terminate()
{
PluginManager::UnregisterPlugin (CreateInstance);
}
lldb_private::ConstString
SystemRuntimeMacOSX::GetPluginNameStatic()
{
static ConstString g_name("systemruntime-macosx");
return g_name;
}
const char *
SystemRuntimeMacOSX::GetPluginDescriptionStatic()
{
return "System runtime plugin for Mac OS X native libraries.";
}
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
lldb_private::ConstString
SystemRuntimeMacOSX::GetPluginName()
{
return GetPluginNameStatic();
}
uint32_t
SystemRuntimeMacOSX::GetPluginVersion()
{
return 1;
}
Reference in New Issue View Git Blame Copy Permalink