LLDB process controller. More...

#include <src/tooling/query/lldb_controller.h>

Public Member Functions
	LLDBController ()

	~LLDBController ()

	LLDBController (const LLDBController &)=delete

LLDBController &	operator= (const LLDBController &)=delete

	LLDBController (LLDBController &&)=delete

LLDBController &	operator= (LLDBController &&)=delete

bool	initialize ()
	Initialize LLDB. Must be called before any other methods.

void	shutdown ()
	Shutdown LLDB and release resources.

bool	attach (pid_t pid)
	Attach to a process by PID.

bool	attachByName (const std::string &process_name, bool wait_for=false)
	Attach to a process by name.

void	detach ()
	Detach from the current process.

bool	isAttached () const
	Check if attached to a process.

pid_t	targetPid () const
	Get the PID of the attached process.

std::string	targetName () const
	Get the name of the attached process.

bool	stop ()
	Stop the target process.

bool	resume ()
	Resume the target process.

bool	stepInto ()
	Single step the current thread (step into)

bool	stepOver ()
	Step over the current line.

bool	stepOut ()
	Step out of the current function.

ProcessState	state () const
	Get the current process state.

const std::string &	lastError () const
	Get the last error message.

std::vector< ThreadInfo >	getThreads () const
	Get list of all threads.

std::optional< ThreadInfo >	getSelectedThread () const
	Get the currently selected thread.

bool	selectThread (uint64_t thread_id)
	Select a thread by ID.

std::vector< FrameInfo >	getFrames (uint32_t max_frames=0) const
	Get stack frames for the selected thread.

std::optional< FrameInfo >	getFrame (uint32_t frame_index) const
	Get a specific frame by index.

std::optional< VariableInfo >	readVariable (const std::string &name, uint32_t frame_index=0, uint32_t expand_depth=0) const
	Read a variable from the current frame.

std::vector< VariableInfo >	listVariables (uint32_t frame_index=0, bool include_args=true, bool include_locals=true, bool include_statics=false) const
	List all variables in scope at a frame.

int32_t	setBreakpoint (const std::string &file, uint32_t line, const std::string &condition="")
	Set a breakpoint at file:line.

bool	removeBreakpoint (int32_t breakpoint_id)
	Remove a breakpoint.

std::vector< BreakpointInfo >	getBreakpoints () const
	Get all breakpoints.

std::optional< BreakpointInfo >	getBreakpoint (int32_t breakpoint_id) const
	Get information about a specific breakpoint.

bool	waitForBreakpoint (uint32_t timeout_ms=0)
	Wait for any breakpoint to be hit.

std::optional< VariableInfo >	evaluateExpression (const std::string &expression, uint32_t frame_index=0) const
	Evaluate an expression in the current context.

Detailed Description

LLDB process controller.

Wraps LLDB's SB API to provide process attachment, breakpoint management, and variable inspection for the query tool.

Definition at line 106 of file lldb_controller.h.

Constructor & Destructor Documentation

◆ LLDBController() [1/3]

ascii_query::LLDBController::LLDBController ( )

default

◆ ~LLDBController()

ascii_query::LLDBController::~LLDBController ( )

Definition at line 36 of file lldb_controller.cpp.

36{ shutdown(); }

ascii_query::LLDBController::shutdown

void shutdown()

Shutdown LLDB and release resources.

Definition lldb_controller.cpp:73

References shutdown().

◆ LLDBController() [2/3]

ascii_query::LLDBController::LLDBController ( const LLDBController & )

delete

◆ LLDBController() [3/3]

ascii_query::LLDBController::LLDBController ( LLDBController && )

delete

Member Function Documentation

◆ attach()

bool ascii_query::LLDBController::attach ( pid_t pid )

Attach to a process by PID.

Parameters

pid	Process ID to attach to

Returns: true on success, false on failure

On success, the target process is stopped.

Definition at line 103 of file lldb_controller.cpp.

                                     {
    if (!initialized_) {
        setError("LLDB not initialized");
        return false;
    }
 
    // Create an empty target - LLDB will fill it in when we attach
    lldb::SBError error;
    target_ = debugger_.CreateTarget("", "", "", false, error);
    if (!target_.IsValid()) {
        setError("Failed to create target: " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        return false;
    }
 
    // Attach to process
    lldb::SBAttachInfo attach_info(pid);
    attach_info.SetListener(listener_);
 
    process_ = target_.Attach(attach_info, error);
    if (!process_.IsValid() || error.Fail()) {
        setError("Failed to attach to PID " + std::to_string(pid) + ": " +
                 std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        debugger_.DeleteTarget(target_);
        return false;
    }
 
    clearError();
    return true;
}

Referenced by main().

◆ attachByName()

bool ascii_query::LLDBController::attachByName	(	const std::string &	process_name,
		bool	wait_for = `false`
	)

Attach to a process by name.

Parameters

process_name	Name of process to attach to
wait_for	If true, wait for process to start

Returns: true on success, false on failure

Definition at line 133 of file lldb_controller.cpp.

                                                                              {
    if (!initialized_) {
        setError("LLDB not initialized");
        return false;
    }
 
    // Create an empty target
    lldb::SBError error;
    target_ = debugger_.CreateTarget("", "", "", false, error);
    if (!target_.IsValid()) {
        setError("Failed to create target: " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        return false;
    }
 
    // Attach by name
    lldb::SBAttachInfo attach_info;
    attach_info.SetExecutable(process_name.c_str());
    attach_info.SetWaitForLaunch(wait_for, false); // false = don't async
    attach_info.SetListener(listener_);
 
    process_ = target_.Attach(attach_info, error);
    if (!process_.IsValid() || error.Fail()) {
        setError("Failed to attach to process '" + process_name +
                 "': " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        debugger_.DeleteTarget(target_);
        return false;
    }
 
    clearError();
    return true;
}

Referenced by main().

◆ detach()

void ascii_query::LLDBController::detach ( )

Detach from the current process.

The target process continues running after detach.

Definition at line 165 of file lldb_controller.cpp.

                            {
    if (!isAttached()) {
        return;
    }
 
    lldb::SBError error = process_.Detach();
    if (error.Fail()) {
        setError("Detach failed: " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
    } else {
        clearError();
    }
}

References isAttached().

Referenced by main(), and shutdown().

◆ evaluateExpression()

std::optional< VariableInfo > ascii_query::LLDBController::evaluateExpression	(	const std::string &	expression,
		uint32_t	frame_index = `0`
	)		const

Evaluate an expression in the current context.

Parameters

expression	Expression to evaluate
frame_index	Which frame context (0 = current)

Returns: VariableInfo with result, or nullopt on failure

Definition at line 611 of file lldb_controller.cpp.

                                                                                            {
    lldb::SBFrame frame = getFrameInternal(frame_index);
    if (!frame.IsValid()) {
        return std::nullopt;
    }
 
    lldb::SBExpressionOptions options;
    options.SetIgnoreBreakpoints(true);
    options.SetFetchDynamicValue(lldb::eDynamicDontRunTarget);
 
    lldb::SBValue result = frame.EvaluateExpression(expression.c_str(), options);
    if (!result.IsValid()) {
        return std::nullopt;
    }
 
    lldb::SBError error = result.GetError();
    if (error.Fail()) {
        return std::nullopt;
    }
 
    return valueToInfo(result, 0);
}

◆ getBreakpoint()

std::optional< BreakpointInfo > ascii_query::LLDBController::getBreakpoint ( int32_t breakpoint_id ) const

Get information about a specific breakpoint.

Parameters

breakpoint_id Breakpoint ID

Returns: BreakpointInfo or nullopt if not found

Definition at line 558 of file lldb_controller.cpp.

                                                                                     {
    if (!target_.IsValid()) {
        return std::nullopt;
    }
 
    lldb::SBBreakpoint bp = target_.FindBreakpointByID(static_cast<lldb::break_id_t>(breakpoint_id));
    if (!bp.IsValid()) {
        return std::nullopt;
    }
 
    return breakpointToInfo(bp);
}

◆ getBreakpoints()

std::vector< BreakpointInfo > ascii_query::LLDBController::getBreakpoints ( ) const

Get all breakpoints.

Returns: Vector of BreakpointInfo structs

Definition at line 538 of file lldb_controller.cpp.

                                                               {
    std::vector<BreakpointInfo> result;
 
    if (!target_.IsValid()) {
        return result;
    }
 
    uint32_t num_breakpoints = target_.GetNumBreakpoints();
    result.reserve(num_breakpoints);
 
    for (uint32_t i = 0; i < num_breakpoints; i++) {
        lldb::SBBreakpoint bp = target_.GetBreakpointAtIndex(i);
        if (bp.IsValid()) {
            result.push_back(breakpointToInfo(bp));
        }
    }
 
    return result;
}

◆ getFrame()

std::optional< FrameInfo > ascii_query::LLDBController::getFrame ( uint32_t frame_index ) const

Get a specific frame by index.

Parameters

frame_index Frame index (0 = innermost)

Returns: FrameInfo or nullopt if index out of range

Definition at line 431 of file lldb_controller.cpp.

                                                                          {
    lldb::SBFrame frame = getFrameInternal(frame_index);
    if (!frame.IsValid()) {
        return std::nullopt;
    }
    return frameToInfo(frame);
}

◆ getFrames()

std::vector< FrameInfo > ascii_query::LLDBController::getFrames ( uint32_t max_frames = 0 ) const

Get stack frames for the selected thread.

Parameters

max_frames Maximum number of frames to return (0 = all)

Returns: Vector of FrameInfo structs

Definition at line 407 of file lldb_controller.cpp.

                                                                        {
    std::vector<FrameInfo> result;
 
    lldb::SBThread thread = getSelectedThreadInternal();
    if (!thread.IsValid()) {
        return result;
    }
 
    uint32_t num_frames = thread.GetNumFrames();
    if (max_frames > 0 && num_frames > max_frames) {
        num_frames = max_frames;
    }
 
    result.reserve(num_frames);
    for (uint32_t i = 0; i < num_frames; i++) {
        lldb::SBFrame frame = thread.GetFrameAtIndex(i);
        if (frame.IsValid()) {
            result.push_back(frameToInfo(frame));
        }
    }
 
    return result;
}

◆ getSelectedThread()

std::optional< ThreadInfo > ascii_query::LLDBController::getSelectedThread ( ) const

Get the currently selected thread.

Returns: ThreadInfo or nullopt if no thread selected

Definition at line 375 of file lldb_controller.cpp.

                                                                {
    lldb::SBThread thread = getSelectedThreadInternal();
    if (!thread.IsValid()) {
        return std::nullopt;
    }
    return threadToInfo(thread, true);
}

◆ getThreads()

std::vector< ThreadInfo > ascii_query::LLDBController::getThreads ( ) const

Get list of all threads.

Returns: Vector of ThreadInfo structs

Definition at line 348 of file lldb_controller.cpp.

                                                       {
    std::vector<ThreadInfo> result;
 
    if (!process_.IsValid()) {
        return result;
    }
 
    // Sync state to ensure we have fresh thread info
    syncProcessState();
 
    lldb::SBThread selected = process_.GetSelectedThread();
    uint64_t selected_id = selected.IsValid() ? selected.GetThreadID() : 0;
 
    uint32_t num_threads = process_.GetNumThreads();
    result.reserve(num_threads);
 
    for (uint32_t i = 0; i < num_threads; i++) {
        lldb::SBThread thread = process_.GetThreadAtIndex(i);
        if (thread.IsValid()) {
            bool is_selected = (thread.GetThreadID() == selected_id);
            result.push_back(threadToInfo(thread, is_selected));
        }
    }
 
    return result;
}

◆ initialize()

bool ascii_query::LLDBController::initialize ( )

Initialize LLDB. Must be called before any other methods.

Returns: true on success, false on failure

Definition at line 42 of file lldb_controller.cpp.

                                {
    if (initialized_) {
        return true;
    }
 
    // Initialize LLDB
    lldb::SBDebugger::Initialize();
 
    // Create debugger instance
    debugger_ = lldb::SBDebugger::Create(false); // false = no source manager
    if (!debugger_.IsValid()) {
        setError("Failed to create LLDB debugger instance");
        return false;
    }
 
    // Don't echo commands
    debugger_.SetAsync(true);
 
    // Create a listener for process events
    listener_ = debugger_.GetListener();
    if (!listener_.IsValid()) {
        setError("Failed to create LLDB listener");
        lldb::SBDebugger::Destroy(debugger_);
        return false;
    }
 
    initialized_ = true;
    clearError();
    return true;
}

Referenced by main().

◆ isAttached()

bool ascii_query::LLDBController::isAttached ( ) const

Check if attached to a process.

Returns: true if attached, false otherwise

Definition at line 178 of file lldb_controller.cpp.

                                      {
    if (!process_.IsValid()) {
        return false;
    }
 
    lldb::StateType state = process_.GetState();
    return state != lldb::eStateInvalid && state != lldb::eStateDetached && state != lldb::eStateExited;
}

References state().

Referenced by detach(), main(), resume(), shutdown(), and stop().

◆ lastError()

const std::string & ascii_query::LLDBController::lastError ( ) const

Get the last error message.

Returns: Error message string

Definition at line 342 of file lldb_controller.cpp.

342{ return last_error_; }

Referenced by main().

◆ listVariables()

std::vector< VariableInfo > ascii_query::LLDBController::listVariables	(	uint32_t	frame_index = `0`,
		bool	include_args = `true`,
		bool	include_locals = `true`,
		bool	include_statics = `false`
	)		const

List all variables in scope at a frame.

Parameters

frame_index	Which frame (0 = current)
include_args	Include function arguments
include_locals	Include local variables
include_statics	Include static variables

Returns: Vector of VariableInfo structs

Definition at line 474 of file lldb_controller.cpp.

                                                                                     {
    std::vector<VariableInfo> result;
 
    lldb::SBFrame frame = getFrameInternal(frame_index);
    if (!frame.IsValid()) {
        return result;
    }
 
    lldb::SBValueList vars = frame.GetVariables(include_args, include_locals, include_statics,
                                                 true); // true = in_scope_only
 
    uint32_t num_vars = vars.GetSize();
    result.reserve(num_vars);
 
    for (uint32_t i = 0; i < num_vars; i++) {
        lldb::SBValue value = vars.GetValueAtIndex(i);
        if (value.IsValid()) {
            result.push_back(valueToInfo(value, 0)); // Don't expand by default
        }
    }
 
    return result;
}

◆ operator=() [1/2]

LLDBController & ascii_query::LLDBController::operator= ( const LLDBController & )

delete

◆ operator=() [2/2]

LLDBController & ascii_query::LLDBController::operator= ( LLDBController && )

delete

◆ readVariable()

std::optional< VariableInfo > ascii_query::LLDBController::readVariable	(	const std::string &	name,
		uint32_t	frame_index = `0`,
		uint32_t	expand_depth = `0`
	)		const

Read a variable from the current frame.

Parameters

name	Variable name (supports dot notation for members)
frame_index	Which frame to read from (0 = current)
expand_depth	How deep to expand struct members (0 = don't expand)

Returns: VariableInfo or nullopt if not found

Definition at line 443 of file lldb_controller.cpp.

                                                                                       {
    lldb::SBFrame frame = getFrameInternal(frame_index);
    if (!frame.IsValid()) {
        return std::nullopt;
    }
 
    // Try to find the variable
    // First, check if it's a path expression (has dots or arrows)
    lldb::SBValue value;
 
    if (name.find('.') != std::string::npos || name.find("->") != std::string::npos || name.find('[') != std::string::npos) {
        // Path expression - use GetValueForVariablePath
        value = frame.GetValueForVariablePath(name.c_str());
    } else {
        // Simple name - try FindVariable first
        value = frame.FindVariable(name.c_str());
 
        // If not found, try as a register
        if (!value.IsValid()) {
            value = frame.FindRegister(name.c_str());
        }
    }
 
    if (!value.IsValid()) {
        return std::nullopt;
    }
 
    return valueToInfo(value, expand_depth);
}

◆ removeBreakpoint()

bool ascii_query::LLDBController::removeBreakpoint ( int32_t breakpoint_id )

Remove a breakpoint.

Parameters

breakpoint_id Breakpoint ID to remove

Returns: true if breakpoint was found and removed

Definition at line 523 of file lldb_controller.cpp.

                                                           {
    if (!target_.IsValid()) {
        setError("No valid target");
        return false;
    }
 
    bool result = target_.BreakpointDelete(static_cast<lldb::break_id_t>(breakpoint_id));
    if (!result) {
        setError("Failed to delete breakpoint " + std::to_string(breakpoint_id));
    } else {
        clearError();
    }
    return result;
}

◆ resume()

bool ascii_query::LLDBController::resume ( )

Resume the target process.

Returns: true if resumed successfully

Definition at line 250 of file lldb_controller.cpp.

                            {
    if (!isAttached()) {
        setError("Not attached to a process");
        return false;
    }
 
    // Sync state first
    syncProcessState();
 
    // Check if already running
    lldb::StateType current = process_.GetState();
    if (current == lldb::eStateRunning || current == lldb::eStateStepping) {
        clearError();
        return true;
    }
 
    lldb::SBError error = process_.Continue();
    if (error.Fail()) {
        setError("Failed to resume process: " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        return false;
    }
 
    // Wait briefly for process to start running (async mode)
    // Note: We don't wait long because running is the target state
    waitForState(lldb::eStateRunning, 2);
 
    clearError();
    return true;
}

References isAttached().

Referenced by main(), and waitForBreakpoint().

◆ selectThread()

bool ascii_query::LLDBController::selectThread ( uint64_t thread_id )

Select a thread by ID.

Parameters

thread_id Thread ID to select

Returns: true if thread was found and selected

Definition at line 383 of file lldb_controller.cpp.

                                                    {
    if (!process_.IsValid()) {
        setError("No valid process");
        return false;
    }
 
    uint32_t num_threads = process_.GetNumThreads();
    for (uint32_t i = 0; i < num_threads; i++) {
        lldb::SBThread thread = process_.GetThreadAtIndex(i);
        if (thread.IsValid() && thread.GetThreadID() == thread_id) {
            process_.SetSelectedThread(thread);
            clearError();
            return true;
        }
    }
 
    setError("Thread ID " + std::to_string(thread_id) + " not found");
    return false;
}

References thread_id.

◆ setBreakpoint()

int32_t ascii_query::LLDBController::setBreakpoint	(	const std::string &	file,
		uint32_t	line,
		const std::string &	condition = `""`
	)

Set a breakpoint at file:line.

Parameters

file	Source file path
line	Line number
condition	Optional condition expression

Returns: Breakpoint ID, or -1 on failure

Definition at line 503 of file lldb_controller.cpp.

                                                                                                      {
    if (!target_.IsValid()) {
        setError("No valid target");
        return -1;
    }
 
    lldb::SBBreakpoint bp = target_.BreakpointCreateByLocation(file.c_str(), line);
    if (!bp.IsValid()) {
        setError("Failed to create breakpoint at " + file + ":" + std::to_string(line));
        return -1;
    }
 
    if (!condition.empty()) {
        bp.SetCondition(condition.c_str());
    }
 
    clearError();
    return static_cast<int32_t>(bp.GetID());
}

◆ shutdown()

void ascii_query::LLDBController::shutdown ( )

Shutdown LLDB and release resources.

Definition at line 73 of file lldb_controller.cpp.

                              {
    if (!initialized_) {
        return;
    }
 
    // Detach if still attached
    if (isAttached()) {
        detach();
    }
 
    // Delete target if valid
    if (target_.IsValid()) {
        debugger_.DeleteTarget(target_);
    }
 
    // Destroy debugger
    if (debugger_.IsValid()) {
        lldb::SBDebugger::Destroy(debugger_);
    }
 
    // Terminate LLDB
    lldb::SBDebugger::Terminate();
 
    initialized_ = false;
}

References detach(), and isAttached().

Referenced by main(), and ~LLDBController().

◆ state()

ProcessState ascii_query::LLDBController::state ( ) const

Get the current process state.

Returns: ProcessState enum value

Definition at line 316 of file lldb_controller.cpp.

                                         {
    if (!process_.IsValid()) {
        return ProcessState::Invalid;
    }
 
    lldb::StateType lldb_state = process_.GetState();
    switch (lldb_state) {
    case lldb::eStateInvalid:
        return ProcessState::Invalid;
    case lldb::eStateRunning:
    case lldb::eStateStepping:
        return ProcessState::Running;
    case lldb::eStateStopped:
    case lldb::eStateSuspended:
        return ProcessState::Stopped;
    case lldb::eStateExited:
        return ProcessState::Exited;
    case lldb::eStateCrashed:
        return ProcessState::Crashed;
    case lldb::eStateDetached:
        return ProcessState::Detached;
    default:
        return ProcessState::Invalid;
    }
}

References ascii_query::Crashed, ascii_query::Detached, ascii_query::Exited, ascii_query::Invalid, ascii_query::Running, and ascii_query::Stopped.

Referenced by isAttached(), main(), and waitForBreakpoint().

◆ stepInto()

bool ascii_query::LLDBController::stepInto ( )

Single step the current thread (step into)

Returns: true if step completed

Definition at line 280 of file lldb_controller.cpp.

                              {
    lldb::SBThread thread = getSelectedThreadInternal();
    if (!thread.IsValid()) {
        setError("No valid thread selected");
        return false;
    }
 
    thread.StepInto();
    clearError();
    return true;
}

◆ stepOut()

bool ascii_query::LLDBController::stepOut ( )

Step out of the current function.

Returns: true if step completed

Definition at line 304 of file lldb_controller.cpp.

                             {
    lldb::SBThread thread = getSelectedThreadInternal();
    if (!thread.IsValid()) {
        setError("No valid thread selected");
        return false;
    }
 
    thread.StepOut();
    clearError();
    return true;
}

◆ stepOver()

bool ascii_query::LLDBController::stepOver ( )

Step over the current line.

Returns: true if step completed

Definition at line 292 of file lldb_controller.cpp.

                              {
    lldb::SBThread thread = getSelectedThreadInternal();
    if (!thread.IsValid()) {
        setError("No valid thread selected");
        return false;
    }
 
    thread.StepOver();
    clearError();
    return true;
}

◆ stop()

bool ascii_query::LLDBController::stop ( )

Stop the target process.

Returns: true if stopped successfully

Definition at line 212 of file lldb_controller.cpp.

                          {
    if (!isAttached()) {
        setError("Not attached to a process");
        return false;
    }
 
    // Sync state first to ensure we have the current process state
    syncProcessState();
 
    // Check if already stopped
    lldb::StateType current = process_.GetState();
    if (current == lldb::eStateStopped || current == lldb::eStateSuspended) {
        clearError();
        return true;
    }
 
    // Only try to stop if running
    if (current != lldb::eStateRunning && current != lldb::eStateStepping) {
        setError("Process is not running (state: " + std::to_string(static_cast<int>(current)) + ")");
        return false;
    }
 
    lldb::SBError error = process_.Stop();
    if (error.Fail()) {
        setError("Failed to stop process: " + std::string(error.GetCString() ? error.GetCString() : "unknown error"));
        return false;
    }
 
    // Wait for process to actually stop (async mode)
    if (!waitForState(lldb::eStateStopped, 5)) {
        setError("Timeout waiting for process to stop");
        return false;
    }
 
    clearError();
    return true;
}

References isAttached().

◆ targetName()

std::string ascii_query::LLDBController::targetName ( ) const

Get the name of the attached process.

Returns: Process name, or empty string if not attached

Definition at line 194 of file lldb_controller.cpp.

                                           {
    if (!target_.IsValid()) {
        return "";
    }
 
    lldb::SBFileSpec exe = target_.GetExecutable();
    if (!exe.IsValid()) {
        return "";
    }
 
    const char *filename = exe.GetFilename();
    return filename ? filename : "";
}

Referenced by main().

◆ targetPid()

pid_t ascii_query::LLDBController::targetPid ( ) const

Get the PID of the attached process.

Returns: PID, or 0 if not attached

Definition at line 187 of file lldb_controller.cpp.

                                      {
    if (!process_.IsValid()) {
        return 0;
    }
    return static_cast<pid_t>(process_.GetProcessID());
}

Referenced by main().

◆ waitForBreakpoint()

bool ascii_query::LLDBController::waitForBreakpoint ( uint32_t timeout_ms = 0 )

Wait for any breakpoint to be hit.

Parameters

timeout_ms Timeout in milliseconds (0 = no timeout)

Returns: true if breakpoint was hit, false on timeout

Definition at line 571 of file lldb_controller.cpp.

                                                          {
    if (!process_.IsValid()) {
        setError("No valid process");
        return false;
    }
 
    // First, resume the process if it's stopped
    if (state() == ProcessState::Stopped) {
        if (!resume()) {
            return false;
        }
    }
 
    // Wait for process to stop
    lldb::SBEvent event;
    uint32_t timeout_sec = (timeout_ms + 999) / 1000; // Round up to seconds
 
    while (true) {
        bool got_event = listener_.WaitForEvent(timeout_sec, event);
        if (!got_event) {
            setError("Timeout waiting for breakpoint");
            return false;
        }
 
        lldb::StateType new_state = lldb::SBProcess::GetStateFromEvent(event);
        if (new_state == lldb::eStateStopped) {
            clearError();
            return true;
        } else if (new_state == lldb::eStateExited || new_state == lldb::eStateCrashed ||
                   new_state == lldb::eStateDetached) {
            setError("Process exited/crashed while waiting for breakpoint");
            return false;
        }
    }
}

References resume(), state(), and ascii_query::Stopped.

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ LLDBController() [1/3]

◆ ~LLDBController()

◆ LLDBController() [2/3]

◆ LLDBController() [3/3]

Member Function Documentation

◆ attach()

◆ attachByName()

◆ detach()

◆ evaluateExpression()

◆ getBreakpoint()

◆ getBreakpoints()

◆ getFrame()

◆ getFrames()

◆ getSelectedThread()

◆ getThreads()

◆ initialize()

◆ isAttached()

◆ lastError()

◆ listVariables()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ readVariable()

◆ removeBreakpoint()

◆ resume()

◆ selectThread()

◆ setBreakpoint()

◆ shutdown()

◆ state()

◆ stepInto()

◆ stepOut()

◆ stepOver()

◆ stop()

◆ targetName()

◆ targetPid()

◆ waitForBreakpoint()