/*

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

using SymbianStackAlgorithmAccurate.Engine;

using SymbianStackAlgorithmAccurate.Interfaces;

using SymbianStackAlgorithmAccurate.Stack;

using SymbianStackLib.Algorithms;

using SymbianStackLib.Data.Output;

using SymbianStackLib.Data.Output.Entry;

using SymbianStackLib.Data.Source;

using SymbianStackLib.Interfaces;

using SymbianStructuresLib.Arm.Registers;

using SymbianStructuresLib.Debug.Symbols.Constants;

using SymbianUtils.DataBuffer.Entry;

using SymbianUtils.Range;

namespace SymbianStackAlgorithmAccurate.Algorithm

{

    internal class AccurateAlgorithm : StackAlgorithm, IArmStackInterface

    {

        #region Constructors

        public AccurateAlgorithm( IStackAlgorithmManager aManager, IStackAlgorithmObserver aObserver )

            : base( aManager, aObserver )

        {

        }

        #endregion

        #region API

        #endregion

        #region Properties

        #endregion

        #region From StackAlgorithm

        public override string Name

        {

            get { return "Accurate"; }

        }

        public override int Priority

        {

            get { return 0; }

        }

        public override bool IsAvailable()

        {

            bool ret = base.IsAvailable();

            //

            if ( ret )

            {

                // We need some registers

                ret = !base.Engine.Registers.IsEmpty;

                //

                if ( ret )

                {

                    // This algorithm can only work if we have code available 

                    // to work with...

                    ret = base.DebugEngineView.Code.IsReady;

                    //

                    if ( ret == false )

                    {

                        base.Trace( "[AccurateAlgorithm] IsAvailable() - code not provided" );

                    }

                }

                else

                {

                    base.Trace( "[AccurateAlgorithm] IsAvailable() - registers not provided" );

                }

            }

            else

            {

                base.Trace( "[AccurateAlgorithm] IsAvailable() - symbols not provided" );

            }

            //

            base.Trace( "[AccurateAlgorithm] IsAvailable() - ret: {0}", ret );

            return ret;

        }

        #endregion

        #region From IArmStackInterface

        uint IArmStackInterface.StackBase

        {

            get { return base.Engine.AddressInfo.Base; }

        }

        uint IArmStackInterface.StackTop

        {

            get { return base.Engine.AddressInfo.Top; }

        }

        uint IArmStackInterface.StackValueAtAddress( uint aAddress )

        {

            DataBufferUint entry = base.SourceData[ aAddress ];

            return entry.Uint;

        }

        #endregion

        #region From AsyncReaderBase

        protected override void HandleReadException( Exception aException )

        {

            // If an exception occurred during frame building or

            // stack reconstruction, then we are aborting the entire operation.

            //

            // However, HandleReadcompleted() is always called irrespective

            // of whether or not an operation succeeded or failed.

            //

            // Therefore, to ensure we do not generate a nested exception in

            // an abort scenario we toggle the 'accurate entry check required'

            // status flag to false so that we will not complain if the

            // algorithm did not locate any accurate frames.

            iAccurateEntryCheckRequired = false;

            base.Trace( "[AccurateAlgorithm] HandleReadException() - aException: {0}, stack: {1}", aException.Message, aException.StackTrace );

            // Now we can propagate the exception onwards.

            base.HandleReadException( aException );

        }

        protected override void HandleReadCompleted()

        {

            // If we didn't identify any accurate entries, then we bail out

            // and let the heuristic algorithm run instead.

            //

            // NB: we don't do this unless we succeeded to reconstruct

            // the entire stack.

            base.Trace( "[AccurateAlgorithm] HandleReadCompleted() - iAccurateEntryCheckRequired: {0}, iAccurateEntryCount: {1}", iAccurateEntryCheckRequired, iAccurateEntryCount );

            if ( iAccurateEntryCheckRequired )

            {

                if ( iAccurateEntryCount == 0 )

                {

                    throw new Exception( "Unable to locate any accurate entries" );

                }

            }

            // We're an accurate algorithm

            base.OutputData.IsAccurate = true;

            base.Trace( "[AccurateAlgorithm] HandleReadCompleted() - read ok!" );

            base.HandleReadCompleted();

        }

        protected override void HandleReadStarted()

        {

            try

            {

                base.Trace( "[AccurateAlgorithm] HandleReadStarted() - START" );

                // Indicate that we will throw an exception if we do not

                // find at least one accurate entry. This is the default behaviour

                // to ensure we don't result in stack data containing just ghost entries.

                // We toggle this to false if we abort stack walking due to an exception,

                // thereby preventing nested exception throwing.

                iAccurateEntryCheckRequired = true;

                // Create arm engine

                iArmEngine = new AccurateEngine( base.DebugEngineView, this, base.Manager.Engine );

                // Seed it with the registers

                iArmEngine.CPU.Registers = base.Engine.Registers;

                // Dump the registers in verbose mode

                base.Trace( "STACK ENGINE REGISTERS:" );

                foreach ( ArmRegister reg in base.Engine.Registers )

                {

                    string symbol = base.DebugEngineView.Symbols.PlainText[ reg.Value ];

                    base.Trace( reg.ToString() + " " + symbol );

                }

                //

                base.Trace( System.Environment.NewLine );

                base.Trace( "[AccurateAlgorithm] HandleReadStarted() - setup complete." );

            }

            finally

            {

                base.HandleReadStarted();

            }

            base.Trace( "[AccurateAlgorithm] HandleReadStarted() - END" );

        }

        protected override void PerformOperation()

        {

            System.Diagnostics.Debug.Assert( iArmEngine != null );

            // First step is to read as many valid stack frames as possible

            BuildStackFrames();

            // Second step is to try to fill any gaps in the stack data

            CreateStackOutput();

        }

        protected override long Size

        {

            get

            {

                int bytes = base.SourceData.Count;

                int dWords = bytes / 4;

                return dWords;

            }

        }

        protected override long Position

        {

            get

            {

                return iDWordIndex;

            }

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                base.CleanupManagedResources();

            }

            finally

            {

                if ( iArmEngine != null )

                {

                    iArmEngine.Dispose();

                    iArmEngine = null;

                }

            }

        }

        #endregion

        #region Internal methods

        private ArmStackFrame FrameByStackAddress( uint aAddress )

        {

            ArmStackFrame ret = null;

            //

            ArmStackFrame[] frames = iArmEngine.StackFrames;

            foreach ( ArmStackFrame frame in frames )

            {

                if ( frame.Address == aAddress )

                {

                    ret = frame;

                    break;

                }

            }

            //

            return ret;

        }

        private ArmStackFrame FrameByRegisterType( TArmRegisterType aRegister )

        {

            ArmStackFrame ret = null;

            //

            ArmStackFrame[] frames = iArmEngine.StackFrames;

            foreach ( ArmStackFrame frame in frames )

            {

                if ( frame.IsRegisterBasedEntry && frame.AssociatedRegister == aRegister )

                {

                    ret = frame;

                    break;

                }

            }

            //

            return ret;

        }

        private void BuildStackFrames()

        {

            bool success = iArmEngine.Process();

            while ( success )

            {

                success = iArmEngine.Process();

            }

            base.Trace( string.Empty );

            base.Trace( string.Empty );

        }

        private void CreateStackOutput()

        {

            // Get the source data we need to reconstruct and signal we're about to start

            StackSourceData sourceData = base.SourceData;

            // Get the output data sink

            StackOutputData outputData = base.OutputData;

            outputData.Clear();

            outputData.AlgorithmName = Name;

            // Get the address range of the stack pointer data

            AddressRange pointerRange = base.Engine.AddressInfo.StackPointerRange;

            AddressRange pointerRangeExtended = base.Engine.AddressInfo.StackPointerRangeWithExtensionArea;

            foreach ( DataBufferUint sourceEntry in sourceData.GetUintEnumerator() )

            {

                // Check if it is within the stack domain, taking into account

                // our extended range

                if ( pointerRangeExtended.Contains( sourceEntry.Address ) )

                {

                    StackOutputEntry outputEntry = new StackOutputEntry( sourceEntry.Address, sourceEntry.Uint, base.DebugEngineView );

                    // Is it the element that corresponds to the current value of SP?

                    bool isCurrentSPEntry = ( outputEntry.AddressRange.Contains( base.Engine.AddressInfo.Pointer ) );

                    // Is it within the pure 'stack pointer' address range?

                    bool outsidePureStackPointerRange = !pointerRange.Contains( sourceEntry.Address );

                    outputEntry.IsOutsideCurrentStackRange = outsidePureStackPointerRange;

                    // Is it a ghost?

                    if ( outputEntry.Symbol != null )

                    {

                        ArmStackFrame realStackFrame = FrameByStackAddress( sourceEntry.Address );

                        outputEntry.IsAccurate = ( realStackFrame != null );

                        outputEntry.IsGhost = ( realStackFrame == null );

                    }

                    // Save entry

                    EmitElement( outputEntry );

                    // If we're inside the stack address range, then poke in the PC and LR values

                    if ( isCurrentSPEntry )

                    {

                        outputEntry.IsCurrentStackPointerEntry = true;

                        // Working bottom up, so LR should go on the stack first

                        ArmStackFrame stackFrameLR = FrameByRegisterType( TArmRegisterType.EArmReg_LR );

                        if ( stackFrameLR != null )

                        {

                            StackOutputEntry entryLR = new StackOutputEntry( 0, stackFrameLR.Data, base.DebugEngineView );

                            entryLR.IsRegisterBasedEntry = true;

                            entryLR.IsOutsideCurrentStackRange = true;

                            entryLR.AssociatedRegister = stackFrameLR.AssociatedRegister;

                            EmitElement( entryLR );

                        }

                        // Then the PC...

                        ArmStackFrame stackFramePC = FrameByRegisterType( TArmRegisterType.EArmReg_PC );

                        if ( stackFramePC != null )

                        {

                            StackOutputEntry entryPC = new StackOutputEntry( 0, stackFramePC.Data, base.DebugEngineView );

                            entryPC.IsRegisterBasedEntry = true;

                            entryPC.IsOutsideCurrentStackRange = true;

                            entryPC.AssociatedRegister = stackFramePC.AssociatedRegister;

                            EmitElement( entryPC );

                        }

                    }

                }

                else

                {

                    // Nope, ignore it...

                }

                NotifyEvent( TEvent.EReadingProgress );

                ++iDWordIndex;

            }

        }

        private void EmitElement( StackOutputEntry aEntry )

        {

            // Debug support

            if ( base.Engine.Verbose )

            {

                StringBuilder line = new StringBuilder( "[AccurateAlgorithm] " );

                //

                if ( aEntry.IsCurrentStackPointerEntry )

                {

                    line.Append( "[C]       " );

                }

                else if ( aEntry.IsRegisterBasedEntry )

                {

                    const int KNormalAddressWidth = 10;

                    string prefix = "[ " + aEntry.AssociatedRegisterName;

                    prefix = prefix.PadRight( KNormalAddressWidth - 2 );

                    prefix += " ]";

                    line.Append( prefix );

                }

                else if ( aEntry.IsGhost )

                {

                    line.Append( "[G]       " );

                }

                else if ( aEntry.IsOutsideCurrentStackRange )

                {

                    line.Append( "          " );

                }

                else

                {

                    line.AppendFormat( "[{0:x8}]", aEntry.Address );

                }

                line.AppendFormat( " {0:x8} {1}", aEntry.Data, aEntry.DataAsString );

                if ( aEntry.Symbol != null )

                {

                    string baseAddressOffset = aEntry.Symbol.ToStringOffset( aEntry.Data );

                    line.AppendFormat( "{0} {1}", baseAddressOffset, aEntry.Symbol.Name );

                }

                else if ( aEntry.AssociatedBinary != string.Empty )

                {

                    line.AppendFormat( "{0} {1}", SymbolConstants.KUnknownOffset, aEntry.AssociatedBinary );

                }

                base.Trace( line.ToString() );

            }

            // Count the number of accurate entries

            if ( aEntry.IsAccurate )

            {

                ++iAccurateEntryCount;

            }

            // Flush entry

            base.StackObserver.StackBuildingElementConstructed( this, aEntry );

        }

        #endregion

        #region Data members

        private AccurateEngine iArmEngine = null;

        private int iDWordIndex = 0;

        private bool iAccurateEntryCheckRequired = true;

        private int iAccurateEntryCount = 0;

        #endregion

    }

}