public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = new ETMDecodeStateSynchronized(base.StateData);
ETMPcktCycleCount cycle = new ETMPcktCycleCount(aByte);
// Always save the byte
iPreviousBytes.Add(aByte);
// Is the top bit set? if so, then another branch packet follows.
// If not, we're done.
if (iPreviousBytes.Count == 5)
{
// Have obtained 5 bytes or then last byte of smaller run.
Flush();
}
else if (cycle.MoreToCome)
{
nextState = this;
}
else
{
// Have obtained last byte of smaller run.
Flush();
}
// Done.
return(nextState);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = this;
//
if (aByte == 0)
{
++iASyncConsecutiveNullByteCount;
}
else if (aByte == 0x80 && iASyncConsecutiveNullByteCount == 5)
{
// That's the start of the a-sync packet
iASyncConsecutiveNullByteCount = 0;
base.StateData.SetSynchronized();
nextState = new ETMDecodeStateSynchronized(base.StateData);
Trace();
}
else
{
// Invalid byte
throw new ETMException("ERROR - data is corrupt - expected null byte or end marker during A-SYNC");
}
//
return(nextState);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = new ETMDecodeStateSynchronized(base.StateData);
Trace();
return(nextState);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = this;
//
ETMPcktBase packet = Packets.Factory.ETMPacketFactory.Create(aByte);
if (packet != null)
{
if (packet is ETMPcktBranch)
{
nextState = new ETMDecodeStateBranch(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktIgnore)
{
nextState = new ETMDecodeStateIgnore(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktISync)
{
nextState = new ETMDecodeStateISync(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktPHeaderFormat1 || packet is ETMPcktPHeaderFormat2)
{
nextState = new ETMDecodeStatePHeader(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktASync)
{
nextState = new ETMDecodeStateASync(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktOutOfOrderData)
{
nextState = new ETMDecodeStateOutOfOrderData(base.StateData);
base.StateData.PushBack(aByte);
}
else if (packet is ETMPcktCycleCount)
{
nextState = new ETMDecodeStateCycleCount(base.StateData);
}
else if (packet is ETMPcktContextID)
{
nextState = new ETMDecodeStateContextID(base.StateData);
}
else
{
base.Trace(string.Format("OP NOT HANDLED: {0:x2}", aByte));
System.Diagnostics.Debug.Assert(false);
}
}
else
{
base.Trace(string.Format("WARNING: OP NOT RECOGNISED: {0:x2}", aByte));
System.Diagnostics.Debug.Assert(false);
}
//
return(nextState);
}
private void OnAddress(SymByte aByte)
{
int byteNumber = 4 - iBytesRemaining;
uint val = aByte.LShift(byteNumber * 8);
iAddress |= val;
if (--iBytesRemaining == 0)
{
// Save for tracing purposes
SymAddress originalAddress = new SymAddress(base.StateData.CurrentAddress.Address);
TArmInstructionSet originalInstructionSet = base.StateData.CurrentInstructionSet;
// Set new branch address
TArmInstructionSet newInstructionSet = iInformationByte.InstructionSet;
uint address = iAddress;
if ((address & 0x1) == 0x1)
{
// We branched to THUMB, hence change of instruction set...
address &= 0xFFFFFFFE;
newInstructionSet = TArmInstructionSet.ETHUMB;
}
// Store address etc - always 32 bit full address during I-SYNC
base.StateData.CurrentInstructionSet = newInstructionSet;
base.StateData.SetKnownAddressBits(address, 32, TETMBranchType.EBranchExplicit);
// And output debug trace...
Trace(originalAddress, originalInstructionSet, base.StateData.CurrentAddress, newInstructionSet);
// We're done
iState = TState.EStateIdle;
}
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = this;
if (iSeenHeader == false)
{
ETMPcktOutOfOrderData cycle = new ETMPcktOutOfOrderData(aByte);
cycle.Matches(aByte);
iDataByteCount = cycle.Size;
iSeenHeader = true;
}
else
{
iBytes.Add(aByte);
//
if (iBytes.Count == iDataByteCount)
{
// Done
nextState = new ETMDecodeStateSynchronized(base.StateData);
}
}
// Done.
return(nextState);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = this;
//
if (aByte == 0)
{
++iASyncConsecutiveNullByteCount;
}
else if (aByte == 0x80 && iASyncConsecutiveNullByteCount == 5)
{
// That's the start of the a-sync packet
iASyncConsecutiveNullByteCount = 0;
base.StateData.SetSynchronized();
nextState = new ETMDecodeStateSynchronized(base.StateData);
Trace();
}
else
{
iASyncConsecutiveNullByteCount = 0;
base.StateData.SetUnsynchronized();
}
//
return(nextState);
}
public virtual ETMDecodeState PrepareToHandleByte(SymByte aByte)
{
iCurrentRawByte = aByte;
//
ETMDecodeState ret = HandleByte(aByte);
return(ret);
}
private void OnInformationByte(SymByte aByte)
{
iInformationByte = new ETMPcktISyncInformation(aByte);
iState = TState.EStateAddress;
// We're expecting 4 address bytes to follow.
iBytesRemaining = 4;
}
internal void PrepareToHandleByte(SymByte aByte)
{
iLastRawByte = iCurrentRawByte;
iCurrentRawByte = aByte;
//
iCurrentState = iCurrentState.PrepareToHandleByte(aByte);
System.Diagnostics.Debug.Assert(iCurrentState != null);
//
++iPacketNumber;
}
public virtual bool Matches(SymByte aOpCode)
{
uint masked = (byte)(aOpCode & BitMask);
if (masked == BitValue)
{
return(true);
}
return(false);
}
private void OnContextByte(SymByte aByte)
{
int byteNumber = iContextIdBytesRequired - iBytesRemaining;
uint val = aByte.LShift(byteNumber * 8);
iContextId |= val;
if (--iBytesRemaining == 0)
{
base.StateData.SetContextID(iContextId);
iState = TState.EStateInformation;
}
}
public override bool Matches(SymByte aOpCode)
{
bool ret = base.Matches(aOpCode);
if (ret)
{
// Tag has to be > 0
SymMask mask = new SymMask("1100000", SymMask.TShiftDirection.ERight, 5);
uint tag = mask.Apply(aOpCode);
ret = (tag > 0 && tag < 4);
}
//
return(ret);
}
public static ETMPcktBase Create(SymByte aByte)
{
ETMPcktBase ret = null;
//
if (iPackets.Count == 0)
{
CreatePackets();
}
//
ret = FindPacket(aByte);
//
return(ret);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
// Handle the byte
PerformStateOperation(aByte);
// Decide what to return based upon current state
ETMDecodeState nextState = this;
if (iState == TState.EStateFinished)
{
iDecoder.FlushChanges();
nextState = new ETMDecodeStateSynchronized(base.StateData);
}
// Done.
return(nextState);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = this;
//
switch (iState)
{
case TState.EStateHeader:
if (base.StateData.Config.ContextIDSize != 0)
{
iState = TState.EStateContextId;
}
else
{
iState = TState.EStateInformation;
}
break;
case TState.EStateContextId:
OnContextByte(aByte);
break;
case TState.EStateInformation:
OnInformationByte(aByte);
break;
case TState.EStateAddress:
OnAddress(aByte);
break;
default:
case TState.EStateIdle:
System.Diagnostics.Debug.Assert(false);
break;
}
//
if (iState == TState.EStateIdle)
{
nextState = new ETMDecodeStateSynchronized(base.StateData);
}
//
return(nextState);
}
private static ETMPcktBase FindPacket(SymByte aByte)
{
ETMPcktBase ret = new ETMPcktUnknown();
//
int count = iPackets.Count;
for (int i = 0; i < count; i++)
{
ETMPcktBase packet = iPackets[i];
if (packet.Matches(aByte))
{
ret = packet;
ret.RawByte = aByte;
break;
}
}
//
return(ret);
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
// TODO: test this
ETMDecodeState nextState = this;
//
int byteNumber = iContextIdBytesRequired - iBytesRemaining;
uint val = aByte.LShift(byteNumber * 8);
iContextId |= val;
//
if (--iBytesRemaining == 0)
{
// Got everything
base.StateData.SetContextID(iContextId);
nextState = new ETMDecodeStateSynchronized(base.StateData);
}
//
return(nextState);
}
private void PerformStateOperation(SymByte aByte)
{
switch (iState)
{
case TState.EStateBranch:
{
iDecoder.Offer(aByte);
// Decode the branch if we have all the info we need
if (iDecoder.IsBranchAddressAvailable)
{
iDecoder.DecodeBranch();
// Check if we expect an exception byte
if (iDecoder.IsPacketComplete)
{
// Nope, we're done
iState = TState.EStateFinished;
}
else
{
iState = TState.EStateExceptionContinuation;
}
}
break;
}
case TState.EStateExceptionContinuation:
{
iDecoder.DecodeException(aByte);
iState = TState.EStateFinished;
break;
}
default:
case TState.EStateFinished:
System.Diagnostics.Debug.Assert(false);
break;
}
}
public override ETMDecodeState HandleByte(SymByte aByte)
{
ETMDecodeState nextState = new ETMDecodeStateSynchronized(base.StateData);
//
ETMPcktBase packet = Packets.Factory.ETMPacketFactory.Create(aByte);
if (packet is ETMPcktPHeaderFormat1)
{
ETMPcktPHeaderFormat1 pHeader1 = (ETMPcktPHeaderFormat1)packet;
ProcessFormat1Conditions(pHeader1);
}
else if (packet is ETMPcktPHeaderFormat2)
{
ETMPcktPHeaderFormat2 pHeader2 = (ETMPcktPHeaderFormat2)packet;
ProcessFormat2Conditions(pHeader2);
}
else
{
throw new ETMException("ERROR: P-HEADER is not supported");
}
//
return(nextState);
}
public override void DecodeException(SymByte aByte)
{
// In a continuation exception byte, bit 7 is always supposed
// to be clear, irrespective of whether original or alternative
// compression schemes are in use.
System.Diagnostics.Debug.Assert(aByte[7] == false);
// Instruction cancellation
base.IsLastInstructionCancelled = aByte[5];
// Security
base.SecurityMode = TArmSecurityMode.ESecure;
if (aByte[0])
{
base.SecurityMode = TArmSecurityMode.ENotSecure;
}
// Exception type
TArmExceptionType exceptionType = TArmExceptionType.EUnknown;
aByte = (byte)(((byte)(aByte & 0x1E)) >> 1);
switch (aByte)
{
case 0:
exceptionType = TArmExceptionType.ENone;
break;
case 1:
exceptionType = TArmExceptionType.EHaltingDebug;
break;
case 2:
exceptionType = TArmExceptionType.ESecureMonitorCall;
break;
default:
case 3:
throw new ETMException("ERROR - reserved exception code during continuation byte");
case 4:
exceptionType = TArmExceptionType.EAsyncDataAbort;
break;
case 5:
exceptionType = TArmExceptionType.EJazelle;
break;
case 6:
case 7:
throw new ETMException("ERROR - reserved exception code during continuation byte");
case 8:
exceptionType = TArmExceptionType.EProcessorReset;
break;
case 9:
exceptionType = TArmExceptionType.EUndefinedInstruction;
break;
case 10:
exceptionType = TArmExceptionType.ESVC;
break;
case 11:
exceptionType = TArmExceptionType.EPrefetchAbortOrSWBreakpoint;
break;
case 12:
exceptionType = TArmExceptionType.ESyncDataAbortOrSWWatchpoint;
break;
case 13:
exceptionType = TArmExceptionType.EGeneric;
break;
case 14:
exceptionType = TArmExceptionType.EIRQ;
break;
case 15:
exceptionType = TArmExceptionType.EFIQ;
break;
}
base.ExceptionType = exceptionType;
}
public abstract ETMDecodeState HandleByte(SymByte aByte);
public abstract void Offer(SymByte aByte);
public abstract void DecodeException(SymByte aByte);
public ETMPcktNormalData(SymByte aByte)
: base(aByte)
{
}
protected void Save(SymByte aByte)
{
iBytes.Add(aByte);
}
private void DecodeInlineException(SymByte aByte)
{
// b1CEEExxx Exception executed in ARM state.
//
// The C bit is set to 1 if the exception cancels the last traced instruction.
// The EEE bits, bits [5:3], indicate the type of exception as shown in Table 7-9.
// Use of this format is deprecated in favor of using an Exception information byte.
// Inline exception packets always indicate ARM mode
base.InstructionSet = TArmInstructionSet.EARM;
// Was it a cancelling branch?
base.IsLastInstructionCancelled = aByte[6];
// Set back to no exception unless changed explicitly below.
base.ExceptionType = TArmExceptionType.ENone;
// Get exception type
SymMask mask = new SymMask("## 111 ###", SymMask.TShiftDirection.ERight, 3);
SymByte exceptionInfo = (byte)mask.Apply(aByte);
if (exceptionInfo == 0)
{
// Have to work this out from the branch address
TArmExceptionVector vector = base.Config.MapToExceptionVector(base.BranchAddress.Address);
switch (vector)
{
case TArmExceptionVector.EReset:
base.ExceptionType = TArmExceptionType.EProcessorReset;
break;
case TArmExceptionVector.EUndefinedInstruction:
base.ExceptionType = TArmExceptionType.EUndefinedInstruction;
break;
case TArmExceptionVector.ESVC:
base.ExceptionType = TArmExceptionType.ESVC;
break;
case TArmExceptionVector.EPrefetchAbort:
base.ExceptionType = TArmExceptionType.EPrefetchAbortOrSWBreakpoint;
break;
case TArmExceptionVector.EDataAbort:
base.ExceptionType = TArmExceptionType.ESyncDataAbortOrSWWatchpoint;
break;
default:
throw new ETMException("ERROR - unable to extract exception type from branch address: 0x" + base.BranchAddress);
}
}
else
{
switch (exceptionInfo)
{
case 1:
base.ExceptionType = TArmExceptionType.EIRQ;
break;
default:
case 2:
case 3:
throw new NotSupportedException("Reserved exception type");
case 4:
base.ExceptionType = TArmExceptionType.EJazelle;
break;
case 5:
base.ExceptionType = TArmExceptionType.EFIQ;
break;
case 6:
base.ExceptionType = TArmExceptionType.EAsyncDataAbort;
break;
case 7:
base.ExceptionType = TArmExceptionType.EHaltingDebug;
break;
}
}
}
public ETMPcktOutOfOrderData(SymByte aByte)
: base(aByte)
{
}
public override void Offer(SymByte aByte)
{
base.Save(aByte);
}
internal void PushBack(SymByte aByte)
{
Buffer.PushBack(aByte);
iCurrentRawByte = iLastRawByte;
--iPacketNumber;
}
