/*

* 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.Tracer;

using SymbianUtils.BasicTypes;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Exceptions;

using SymbianStructuresLib.Arm.SecurityMode;

using SymbianETMLib.Common.Types;

using SymbianETMLib.Common.State;

using SymbianETMLib.Common.Config;

namespace SymbianETMLib.Common.BranchDecoder

{

    internal abstract class ETMBranchDecoder : ITracer

    {

        #region Factory

        public static ETMBranchDecoder New( ETMStateData aStateData )

        {

            ETMBranchDecoder ret = null;

            //

            switch ( aStateData.Config.BranchCompressionScheme )

            {

            default:

            case TETMBranchCompressionScheme.EOriginal:

                ret = new ETMBranchDecoderOriginal( aStateData );

                break;

            case TETMBranchCompressionScheme.EAlternative:

                ret = new ETMBranchDecoderAlternative( aStateData );

                break;

            }

            //

            return ret;

        }

        #endregion

        #region Constructors

        protected ETMBranchDecoder( ETMStateData aStateData )

        {

            iStateData = aStateData;

            iInstructionSet = aStateData.CurrentInstructionSet;

        }

        #endregion

        #region API

        public void FlushChanges()

        {

            TArmInstructionSet originalInstructionSet = iStateData.CurrentInstructionSet;

            SymAddress originalAddress = new SymAddress( iStateData.CurrentAddress.Address );

            //if ( !IsLastInstructionCancelled )

            {

                // Set known address

                iStateData.SetKnownAddressBits( iBranchAddress.Address,

                                              iBranchAddress.KnownBits,

                                              TETMBranchType.EBranchExplicit );

                // Handle a change in security mode

                if ( iSecurityMode != TArmSecurityMode.EUnknown )

                {

                    iStateData.CurrentSecurityMode = iSecurityMode;

                }

                if ( iExceptionType != TArmExceptionType.EUnknown )

                {

                    iStateData.CurrentException = iExceptionType;

                }

                // Handle a change in instruction set

                if ( iStateData.CurrentInstructionSet != iInstructionSet )

                {

                    iStateData.CurrentInstructionSet = iInstructionSet;

                }

            }

            DbgTrace( originalAddress, originalInstructionSet );

        }

        public void DecodeBranch()

        {

            System.Diagnostics.Debug.Assert( IsBranchAddressAvailable );

            System.Diagnostics.Debug.Assert( Count > 0 && Count <= 5 );

            //

            if ( Count == 5 )

            {

                DecodeFull();

            }

            else

            {

                DecodePartial();

            }

        }

        #endregion

        #region Framework API

        public abstract void Offer( SymByte aByte );

        public abstract void DecodeException( SymByte aByte );

        protected abstract void DecodeFull();

        protected abstract void DecodePartial();

        public virtual bool IsPacketComplete

        {

            get

            {

                // If the 7th bit is clear, then this might be

                // the last byte.

                //

                // If:

                //

                // a) the number of bytes forming the branch packet

                //    is less than 5, then this is the last byte.

                //

                // b) the number of bytes forming the branch packet

                //    is 5, and

                //    i)  bit 6 is clear => normal branch, this is the last byte

                //    ii) bit 7 is set => inline exception, but this is still the last byte.

                //

                bool ret = false;

                bool bit7 = LastByte[ 7 ];

                //

                switch ( iBytes.Count )

                {

                default:

                case 0:

                    ret = false;

                    break;

                case 1:

                case 2:

                case 3:

                case 4:

                    ret = ( bit7 == false ); // (a)

                    break;

                case 5:

                    if ( bit7 )

                    {

                        // (b), part (ii)

                        ret = true;

                    }

                    else

                    {

                        // (b), part (i) - i.e. bit 6 and 7 are both clear => normal branch byte

                        ret = ( LastByte[ 6 ] == false );

                    }

                    break;

                }

                return ret;

            }

        }

        public virtual bool IsBranchAddressAvailable

        {

            get

            {

                // The branch address is only available once 

                // bit seven is clear, or then once we've reached

                // an entire run of 5 bytes.

                bool ret = false;

                //

                if ( Count == 5 )

                {

                    ret = true;

                }

                else

                {

                    ret = ( LastByte[ 7 ] == false );

                }

                //

                return ret;

            }

        }

        #endregion

        #region Internal API

        protected void Save( SymByte aByte )

        {

            iBytes.Add( aByte );

        }

        #endregion

        #region Properties

        public int Count

        {

            get { return iBytes.Count; }

        }

        public bool IsLastInstructionCancelled

        {

            get { return iLastInstructionCancelled; }

            protected set { iLastInstructionCancelled = value; }

        }

        public SymByte this[ int aIndex ]

        {

            get { return iBytes[ aIndex ]; }

        }

        public ETConfigBase Config

        {

            get { return iStateData.Config; }

        }

        public TArmExceptionType ExceptionType

        {

            get { return iExceptionType; }

            protected set { iExceptionType = value; }

        }

        public TArmSecurityMode SecurityMode

        {

            get { return iSecurityMode; }

            protected set { iSecurityMode = value; }

        }

        public TArmInstructionSet InstructionSet

        {

            get { return iInstructionSet; }

            protected set { iInstructionSet = value; }

        }

        public SymAddressWithKnownBits BranchAddress

        {

            get { return iBranchAddress; }

            protected set { iBranchAddress = value; }

        }

        #endregion

        #region Internal methods

        protected SymByte LastByte

        {

            get

            {

                SymByte ret = new SymByte( 0 );

                //

                int count = iBytes.Count;

                if ( count > 0 )

                {

                    ret = iBytes[ count - 1 ];

                }

                //

                return ret;

            }

        }

        protected static int CompressionLeftShiftCount( TArmInstructionSet aIS )

        {

            int ret = 2;

            // Interpret the bytes to form an address based upon current

            // instruction set.

            switch ( aIS )

            {

            default:

            case TArmInstructionSet.EARM:

                break;

            case TArmInstructionSet.ETHUMB:

                ret = 1;

                break;

            case TArmInstructionSet.EJAZELLE:

                ret = 0;

                break;

            }

            //

            return ret;

        }

        private void DbgTrace( SymAddress aOriginalAddress, TArmInstructionSet aOriginalISet )

        {

            if ( Count == 5 )

            {

                DbgTrace( "BRANCH-F", aOriginalAddress, aOriginalISet );

            }

            else

            {

                DbgTrace( "BRANCH-P", aOriginalAddress, aOriginalISet );

            }

        }

        private void DbgTrace( string aType, SymAddress aOriginalAddress, TArmInstructionSet aOriginalISet )

        {

            StringBuilder lines = new StringBuilder();

            lines.AppendLine( "   " + aType );

            //

            if ( iStateData.LastBranch.IsKnown )

            {

                lines.AppendLine( string.Format( "      using: {0} 0x{1} to go...",

                    iBranchAddress.AddressBinary,

                    iBranchAddress.AddressHex )

                    );

                lines.AppendLine( string.Format( "       from: {0} 0x{1} {2} 0x{3:x8} {4}", 

                    aOriginalAddress.AddressBinary,

                    aOriginalAddress.AddressHex,

                    ETMDecodeState.MakeInstructionSetPrefix( aOriginalISet ),

                    aOriginalAddress,

                    iStateData.Engine.LookUpSymbol( aOriginalAddress ) ) 

                    );

                lines.AppendLine( string.Format( "         to: {0} 0x{1} {2} 0x{3:x8} {4}", 

                    iStateData.CurrentAddress.AddressBinary,

                    iStateData.CurrentAddress.AddressHex,

                    ETMDecodeState.MakeInstructionSetPrefix( iStateData.CurrentInstructionSet ),

                    iStateData.CurrentAddress, 

                    iStateData.Engine.LookUpSymbol( iStateData.CurrentAddress ) ) 

                    );

            }

            //

            Trace( lines.ToString() );

        }

        #endregion

        #region From ITracer

        public void Trace( string aText )

        {

            iStateData.Trace( aText );

        }

        public void Trace( string aFormat, params object[] aParams )

        {

            iStateData.Trace( aFormat, aParams );

        }

        #endregion

        #region Data members

        private readonly ETMStateData iStateData;

        private bool iLastInstructionCancelled = false;

        private List<SymByte> iBytes = new List<SymByte>();

        private TArmExceptionType iExceptionType = TArmExceptionType.EUnknown;

        private TArmSecurityMode iSecurityMode = TArmSecurityMode.EUnknown;

        private TArmInstructionSet iInstructionSet = TArmInstructionSet.EARM;

        private SymAddressWithKnownBits iBranchAddress = new SymAddressWithKnownBits();

        #endregion

    }

}