* 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;
}
