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