mirror of
https://github.com/opnsense/src.git
synced 2026-02-28 12:20:54 -05:00
c940aad3f6
This uses the new layout of the upstream repository, which was recently migrated to GitHub, and converted into a "monorepo". That is, most of the earlier separate sub-projects with their own branches and tags were consolidated into one top-level directory, and are now branched and tagged together.
103 lines
3.2 KiB
C++
103 lines
3.2 KiB
C++
//===-- ThreadMemory.cpp ----------------------------------------------*- C++
|
|
//-*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Plugins/Process/Utility/ThreadMemory.h"
|
|
|
|
#include "Plugins/Process/Utility/RegisterContextThreadMemory.h"
|
|
#include "lldb/Target/OperatingSystem.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/StopInfo.h"
|
|
#include "lldb/Target/Unwind.h"
|
|
|
|
#include <memory>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ThreadMemory::ThreadMemory(Process &process, tid_t tid,
|
|
const ValueObjectSP &thread_info_valobj_sp)
|
|
: Thread(process, tid), m_backing_thread_sp(),
|
|
m_thread_info_valobj_sp(thread_info_valobj_sp), m_name(), m_queue() {}
|
|
|
|
ThreadMemory::ThreadMemory(Process &process, lldb::tid_t tid,
|
|
llvm::StringRef name, llvm::StringRef queue,
|
|
lldb::addr_t register_data_addr)
|
|
: Thread(process, tid), m_backing_thread_sp(), m_thread_info_valobj_sp(),
|
|
m_name(name), m_queue(queue), m_register_data_addr(register_data_addr) {}
|
|
|
|
ThreadMemory::~ThreadMemory() { DestroyThread(); }
|
|
|
|
void ThreadMemory::WillResume(StateType resume_state) {
|
|
if (m_backing_thread_sp)
|
|
m_backing_thread_sp->WillResume(resume_state);
|
|
}
|
|
|
|
void ThreadMemory::ClearStackFrames() {
|
|
if (m_backing_thread_sp)
|
|
m_backing_thread_sp->ClearStackFrames();
|
|
Thread::ClearStackFrames();
|
|
}
|
|
|
|
RegisterContextSP ThreadMemory::GetRegisterContext() {
|
|
if (!m_reg_context_sp)
|
|
m_reg_context_sp = std::make_shared<RegisterContextThreadMemory>(
|
|
*this, m_register_data_addr);
|
|
return m_reg_context_sp;
|
|
}
|
|
|
|
RegisterContextSP
|
|
ThreadMemory::CreateRegisterContextForFrame(StackFrame *frame) {
|
|
RegisterContextSP reg_ctx_sp;
|
|
uint32_t concrete_frame_idx = 0;
|
|
|
|
if (frame)
|
|
concrete_frame_idx = frame->GetConcreteFrameIndex();
|
|
|
|
if (concrete_frame_idx == 0) {
|
|
reg_ctx_sp = GetRegisterContext();
|
|
} else {
|
|
Unwind *unwinder = GetUnwinder();
|
|
if (unwinder != nullptr)
|
|
reg_ctx_sp = unwinder->CreateRegisterContextForFrame(frame);
|
|
}
|
|
return reg_ctx_sp;
|
|
}
|
|
|
|
bool ThreadMemory::CalculateStopInfo() {
|
|
if (m_backing_thread_sp) {
|
|
lldb::StopInfoSP backing_stop_info_sp(
|
|
m_backing_thread_sp->GetPrivateStopInfo());
|
|
if (backing_stop_info_sp &&
|
|
backing_stop_info_sp->IsValidForOperatingSystemThread(*this)) {
|
|
backing_stop_info_sp->SetThread(shared_from_this());
|
|
SetStopInfo(backing_stop_info_sp);
|
|
return true;
|
|
}
|
|
} else {
|
|
ProcessSP process_sp(GetProcess());
|
|
|
|
if (process_sp) {
|
|
OperatingSystem *os = process_sp->GetOperatingSystem();
|
|
if (os) {
|
|
SetStopInfo(os->CreateThreadStopReason(this));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ThreadMemory::RefreshStateAfterStop() {
|
|
if (m_backing_thread_sp)
|
|
return m_backing_thread_sp->RefreshStateAfterStop();
|
|
|
|
if (m_reg_context_sp)
|
|
m_reg_context_sp->InvalidateAllRegisters();
|
|
}
|