/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

using System;

using System.Collections.Generic;

using System.Text;

using SymbianUtils.BasicTypes;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Exceptions;

using SymbianStructuresLib.Arm.SecurityMode;

using SymbianETMLib.Common.Types;

using SymbianETMLib.Common.Config;

using SymbianETMLib.Common.State;

using SymbianETMLib.Common.Exception;

namespace SymbianETMLib.Common.BranchDecoder

{

    internal class ETMBranchDecoderOriginal : ETMBranchDecoder

    {

        #region Constructors

        public ETMBranchDecoderOriginal( ETMStateData aManager )

            : base( aManager )

        {

        }

        static ETMBranchDecoderOriginal()

        {

            iMaskByte5_ARM = new SymMask( KMaskByte5_ARM );

            iMaskByte5_THUMB = new SymMask( KMaskByte5_THUMB );

            iMaskByte5_JAZELLE = new SymMask( KMaskByte5_JAZELLE );

        }

        #endregion

        #region From ETBBranchDecoder

        public override void Offer( SymByte aByte )

        {

            base.Save( aByte );

        }

        protected override void DecodeFull()

        {

            // We have full 5 bytes of address info.

            SymMask maskFirst = new SymMask( 0x7E, SymMask.TShiftDirection.ERight, 1 );

            SymMask maskMiddle = new SymMask( 0x7F );

            SymByte b;

            SymAddressWithKnownBits address = new SymAddressWithKnownBits();

            uint masked = 0;

            // First byte

            b = base[ 0 ];

            address.KnownBits += 6;

            address.Address |= maskFirst.Apply( b );

            // Bytes 1, 2, 3

            for ( int i = 1; i <= 3; i++ )

            {

                b = base[ i ];

                b = (byte) maskMiddle.Apply( b );

                masked = (uint) ( b << address.KnownBits );

                address.KnownBits += 7;

                address.Address |= masked;

            }

            // Last byte - mask depends on instruction set.

            b = base[ 4 ];

            int lastByteAddressBits = 0;

            if ( this.ContainsInlineException || iMaskByte5_ARM.IsMatch( b ) )

            {

                // Inline exception indicates ARM.

                base.InstructionSet = TArmInstructionSet.EARM;

                lastByteAddressBits = 3;

            }

            else if ( iMaskByte5_THUMB.IsMatch( b ) )

            {

                base.InstructionSet = TArmInstructionSet.ETHUMB;

                lastByteAddressBits = 4;

            }

            else if ( iMaskByte5_JAZELLE.IsMatch( b ) )

            {

                base.InstructionSet = TArmInstructionSet.EJAZELLE;

                lastByteAddressBits = 5;

            }

            else

            {

                throw new ETMException( "ERROR: branch type unknown" );

            }

            // Now we can process the last byte

            masked = b.LowestBits( lastByteAddressBits );

            masked <<= address.KnownBits;

            address.KnownBits += lastByteAddressBits;

            address.Address |= masked;

            // Shift entire address by shift count based upon current instruction set.

            int isShift = ETMBranchDecoder.CompressionLeftShiftCount( base.InstructionSet );

            System.Diagnostics.Debug.Assert( address.KnownBits + isShift == 32 );

            address.KnownBits = 32;

            address.Address <<= isShift;

            // Save address

            base.BranchAddress = address;

            // We may also need to decode the inline exception

            if ( ContainsInlineException )

            {

                // Yup, line exception...

                DecodeInlineException( base.LastByte );

            }

        }

        protected override void DecodePartial()

        {

            // According to Table 7-13, "Missing components of exception Branch address packets"

            // then after a partial branch, we're always in "no exception" state

            base.ExceptionType = TArmExceptionType.ENone;

            // We have full 5 bytes of address info.

            SymMask maskFirst = new SymMask( 0x7E, SymMask.TShiftDirection.ERight, 1 );

            SymMask maskMiddle = new SymMask( 0x7F );

            SymByte b;

            SymAddressWithKnownBits address = new SymAddressWithKnownBits();

            uint masked = 0;

            int count = base.Count;

            // First byte

            b = base[ 0 ];

            address.KnownBits += 6;

            address.Address |= maskFirst.Apply( b );

            // Bytes 1, 2, 3

            for ( int i = 1; i < count; i++ )

            {

                b = base[ i ];

                b = (byte) maskMiddle.Apply( b );

                masked = (uint) ( b << address.KnownBits );

                address.KnownBits += 7;

                address.Address |= masked;

            }

            // Shift entire address by shift count based upon current instruction set.

            int isShift = ETMBranchDecoder.CompressionLeftShiftCount( base.InstructionSet );

            address.KnownBits += isShift;

            address.Address <<= isShift;

            // Save address

            base.BranchAddress = address;

        }

        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;

        }

        #endregion

        #region Properties

        protected virtual bool ContainsInlineException

        {

            get

            {

                bool ret = false;

                //

                bool completeBranch = IsBranchAddressAvailable;

                if ( completeBranch )

                {

                    ret = ( LastByte[ 7 ] );

                }

                //

                return ret;

            }

        }

        #endregion

        #region Internal constants

        protected const string KMaskByte5_ARM       = "0#001###";

        protected const string KMaskByte5_THUMB     = "0#01####";

        protected const string KMaskByte5_JAZELLE   = "0#1#####";

        #endregion

        #region Internal methods

        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;

                }

            }

        }

        #endregion

        #region Data members

        private static readonly SymMask iMaskByte5_ARM;

        private static readonly SymMask iMaskByte5_THUMB;

        private static readonly SymMask iMaskByte5_JAZELLE;

        #endregion

    }

}