haiku.git

/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <DebugContext.h>


BDebugContext::BDebugContext()
{
	fContext.team = -1;
}


BDebugContext::~BDebugContext()
{
	Uninit();
}


status_t
BDebugContext::Init(team_id team, port_id nubPort)
{
	Uninit();

	status_t error = init_debug_context(&fContext, team, nubPort);
	if (error != B_OK) {
		fContext.team = -1;
		return error;
	}

	return B_OK;
}


void
BDebugContext::Uninit()
{
	if (fContext.team >= 0) {
		destroy_debug_context(&fContext);
		fContext.team = -1;
	}
}


status_t
BDebugContext::SendDebugMessage(int32 messageCode, const void *message,
	size_t messageSize, void* reply, size_t replySize)
{
	return send_debug_message(&fContext, messageCode, message, messageSize,
		reply, replySize);
}


status_t
BDebugContext::SetTeamDebuggingFlags(int32 flags)
{
	debug_nub_set_team_flags message;
	message.flags = flags;

	return SendDebugMessage(B_DEBUG_MESSAGE_SET_TEAM_FLAGS, &message,
		sizeof(message), NULL, 0);
}


ssize_t
BDebugContext::ReadMemoryPartial(const void* address, void* buffer, size_t size)
{
	return debug_read_memory_partial(&fContext, address, buffer, size);
}


ssize_t
BDebugContext::ReadMemory(const void* address, void* buffer, size_t size)
{
	return debug_read_memory(&fContext, address, buffer, size);
}


ssize_t
BDebugContext::ReadString(const void* address, char* buffer, size_t size)
{
	return debug_read_string(&fContext, address, buffer, size);
}


status_t
BDebugContext::SetBreakpoint(void* address)
{
	debug_nub_set_breakpoint message;
	message.reply_port = fContext.reply_port;
	message.address = address;

	debug_nub_set_breakpoint_reply reply;
	status_t error = SendDebugMessage(B_DEBUG_MESSAGE_SET_BREAKPOINT, &message,
		sizeof(message), &reply, sizeof(reply));

	return error == B_OK ? reply.error : error;
}


status_t
BDebugContext::ClearBreakpoint(void* address)
{
	debug_nub_clear_breakpoint message;
	message.address = address;

	return SendDebugMessage(B_DEBUG_MESSAGE_CLEAR_BREAKPOINT, &message,
		sizeof(message), NULL, 0);
}


status_t
BDebugContext::SetWatchpoint(void* address, uint32 type, int32 length)
{
	debug_nub_set_watchpoint message;
	message.reply_port = fContext.reply_port;
	message.address = address;
	message.type = type;
	message.length = length;

	debug_nub_set_watchpoint_reply reply;
	status_t error = SendDebugMessage(B_DEBUG_MESSAGE_SET_WATCHPOINT, &message,
		sizeof(message), &reply, sizeof(reply));

	return error == B_OK ? reply.error : error;
}


status_t
BDebugContext::ClearWatchpoint(void* address)
{
	debug_nub_clear_watchpoint message;
	message.address = address;

	return SendDebugMessage(B_DEBUG_MESSAGE_CLEAR_WATCHPOINT, &message,
		sizeof(message), NULL, 0);
}


status_t
BDebugContext::ContinueThread(thread_id thread, bool singleStep)
{
	debug_nub_continue_thread message;
	message.thread = thread;
	message.handle_event = B_THREAD_DEBUG_HANDLE_EVENT;
	message.single_step = singleStep;

	return SendDebugMessage(B_DEBUG_MESSAGE_CONTINUE_THREAD, &message,
		sizeof(message), NULL, 0);
}


status_t
BDebugContext::SetThreadDebuggingFlags(thread_id thread, int32 flags)
{
	debug_nub_set_thread_flags message;
	message.thread = thread;
	message.flags = flags;

	return SendDebugMessage(B_DEBUG_MESSAGE_SET_THREAD_FLAGS, &message,
		sizeof(message), NULL, 0);
}


status_t
BDebugContext::GetThreadCpuState(thread_id thread,
	debug_debugger_message* _messageCode, debug_cpu_state* cpuState)
{
	return debug_get_cpu_state(&fContext, thread, _messageCode, cpuState);
}