/*
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2013-2015, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "ValueWriter.h"

#include "Architecture.h"
#include "BitBuffer.h"
#include "CpuState.h"
#include "DebuggerInterface.h"
#include "Register.h"
#include "TeamMemory.h"
#include "Tracing.h"
#include "ValueLocation.h"


ValueWriter::ValueWriter(Architecture* architecture,
	DebuggerInterface* interface, CpuState* cpuState, thread_id targetThread)
	:
	fArchitecture(architecture),
	fDebuggerInterface(interface),
	fCpuState(cpuState),
	fTargetThread(targetThread)
{
	fArchitecture->AcquireReference();
	fDebuggerInterface->AcquireReference();
	if (fCpuState != NULL)
		fCpuState->AcquireReference();
}


ValueWriter::~ValueWriter()
{
	fArchitecture->ReleaseReference();
	fDebuggerInterface->ReleaseReference();
	if (fCpuState != NULL)
		fCpuState->ReleaseReference();
}


status_t
ValueWriter::WriteValue(ValueLocation* location, BVariant& value)
{
	if (!location->IsWritable())
		return B_BAD_VALUE;

	int32 count = location->CountPieces();
	if (fCpuState == NULL) {
		for (int32 i = 0; i < count; i++) {
			const ValuePieceLocation piece = location->PieceAt(i);
			if (piece.type == VALUE_PIECE_LOCATION_REGISTER) {
				TRACE_LOCALS("  -> asked to write value with register piece, "
					"but no CPU state to write to.\n");
				return B_UNSUPPORTED;
			}
		}
	}

	bool cpuStateWriteNeeded = false;
	size_t byteOffset = 0;
	bool bigEndian = fArchitecture->IsBigEndian();
	const Register* registers = fArchitecture->Registers();
	for (int32 i = 0; i < count; i++) {
		ValuePieceLocation piece = location->PieceAt(
			bigEndian ? i : count - i - 1);
		uint32 bytesToWrite = piece.size;

		uint8* targetData = (uint8*)value.Bytes() + byteOffset;

		switch (piece.type) {
			case VALUE_PIECE_LOCATION_MEMORY:
			{
				target_addr_t address = piece.address;

				TRACE_LOCALS("  piece %" B_PRId32 ": memory address: %#"
					B_PRIx64 ", bits: %" B_PRIu32 "\n", i, address,
					bytesToWrite * 8);

				ssize_t bytesWritten = fDebuggerInterface->WriteMemory(address,
					targetData, bytesToWrite);

				if (bytesWritten < 0)
					return bytesWritten;
				if ((uint32)bytesWritten != bytesToWrite)
					return B_BAD_ADDRESS;

				break;
			}
			case VALUE_PIECE_LOCATION_REGISTER:
			{
				TRACE_LOCALS("  piece %" B_PRId32 ": register: %" B_PRIu32
					", bits: %" B_PRIu64 "\n", i, piece.reg, piece.bitSize);

				const Register* target = registers + piece.reg;
				BVariant pieceValue;
				switch (bytesToWrite) {
					case 1:
						pieceValue.SetTo(*(uint8*)targetData);
						break;
					case 2:
						pieceValue.SetTo(*(uint16*)targetData);
						break;
					case 4:
						pieceValue.SetTo(*(uint32*)targetData);
						break;
					case 8:
						pieceValue.SetTo(*(uint64*)targetData);
						break;
					default:
						TRACE_LOCALS("Asked to write unsupported piece size %"
							B_PRId32 " to register\n", bytesToWrite);
						return B_UNSUPPORTED;
				}

				if (!fCpuState->SetRegisterValue(target, pieceValue))
					return B_NO_MEMORY;

				cpuStateWriteNeeded = true;
				break;
			}
			default:
				return B_UNSUPPORTED;
		}

		byteOffset += bytesToWrite;
	}

	if (cpuStateWriteNeeded)
		return fDebuggerInterface->SetCpuState(fTargetThread, fCpuState);

	return B_OK;
}