/*

* 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 SymbianDebugLib.PluginAPI.Types.Symbol;

using SymbianStructuresLib.Debug.Symbols;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Registers;

using SymbianStructuresLib.Arm.Registers;

using SymbianStackAlgorithmAccurate.CPU;

using SymbianStackAlgorithmAccurate.Code;

using SymbianStackAlgorithmAccurate.Engine;

using SymbianStackAlgorithmAccurate.Interfaces;

using SymbianStackAlgorithmAccurate.Instructions;

namespace SymbianStackAlgorithmAccurate.Prologue

{

    internal class ArmPrologueHelper

    {

        #region Constructors

        public ArmPrologueHelper( AccurateEngine aEngine )

        {

            iEngine = aEngine;

            // Make a new PC register, since we're going to manipulate it...

            iPC = new ArmRegister( aEngine.CPU.PC );

            // Create offsets

            iOffsetValues.AddDefaults();

            iOffsetValues.SetAll( uint.MaxValue );

        }

        #endregion

        #region API

        public void Build()

        {

            // First, work out how many instructions we need to read from

            // the code data in order to reach the current PC value.

            // We currently cap this at 20 instructions.

            CalculatePrologueInstructionCount();

            // Get Prologue instructions

            GetPrologueInstructions();

            // Update iPC with Prologue starting address - needed for PC-relative

            // instructions

            PrepareInitialPCValue();

            // Process the instructions until exhausted

            ProcessPrologueInstructions();

        }

        public int IncrementNumberOfWordsPushedOnStack( TArmRegisterType aRegister )

        {

            uint offset = (uint) iNumberOfWordsPushedOnStack * 4;

            int ret = iNumberOfWordsPushedOnStack++;

            iEngine.Trace( "[PLG] IncrementNumberOfWordsPushedOnStack - register: {0}, offset: 0x{1:x4}, DWORDs now on stack: {2:d2}", aRegister, offset, NumberOfWordsPushedOnStack );

            return ret;

        }

        public int AddToNumberOfWordsPushedOnStack( int aExtraWords )

        {

            iNumberOfWordsPushedOnStack += aExtraWords;

            iEngine.Trace( "[PLG] AddToNumberOfWordsPushedOnStack     - DWORDs added: {0}, prior SP adjustment: 0x{1:x8} ({2} x DWORDs), new SP adjustment: 0x{3:x8} ({4} x DWORDs)",

                aExtraWords, 

                ( iNumberOfWordsPushedOnStack - aExtraWords ) * 4, 

                iNumberOfWordsPushedOnStack - aExtraWords,

                iNumberOfWordsPushedOnStack * 4,

                iNumberOfWordsPushedOnStack  

            );

            //

            return iNumberOfWordsPushedOnStack;

        }

        #endregion

        #region Properties

        public int PrologueInstructionCount

        {

            get

            { 

                int ret = iPrologueInstructionCount;

                //

                if ( ret > KMaxPrologueInstructionCount )

                {

                    ret = KMaxPrologueInstructionCount;

                    iEngine.Trace( "[PLG] Capping the amount of Prologue instructions to read to: " + ret ); 

                }

                //

                return ret;

            }

            set

            {

                iPrologueInstructionCount = value;

            }

        }

        public string FunctionName

        {

            get { return iFunctionName; }

        }

        public TArmInstructionSet FunctionInstructionSet

        {

            get

            {

                TArmInstructionSet ret = TArmInstructionSet.EARM;

                //

                if ( ( FunctionStartingAddress & 0x1 ) == 0x1 )

                {

                    ret = TArmInstructionSet.ETHUMB;

                }

                //

                return ret;

            }

        }

        public uint FunctionStartingAddress

        {

            get { return iFunctionStartAddress; }

        }

        public uint FunctionStartingAddressWithoutType

        {

            get { return iFunctionStartAddress & KInstructionSetMask; }

        }

        public uint FunctionOffsetToPC

        {

            get

            {

                uint funcAddrWithoutInstructionSetType = FunctionStartingAddressWithoutType;

                uint offset = iPC - funcAddrWithoutInstructionSetType;

                return offset;

            }

        }

        public ArmRegister ProloguePC

        {

            get { return iPC; }

        }

        public int NumberOfWordsPushedOnStack

        {

            get { return iNumberOfWordsPushedOnStack; }

            set { iNumberOfWordsPushedOnStack = value; }

        }

        #endregion

        #region Internal methods

        private void CalculatePrologueInstructionCount()

        {

            DbgViewSymbol symbolView = iEngine.DebugEngineView.Symbols;

            // Get the PC and try to match it to a function

            SymbolCollection collection = null;

            Symbol symbol = symbolView.Lookup( iPC, out collection );

            if ( symbol != null )

            {

                iFunctionStartAddress = symbol.Address;

                iFunctionName = symbol.Name;

                //

                uint offset = FunctionOffsetToPC;

                uint instructionSize = SingleInstructionSize;

                uint prologueInstructionCount = ( offset / instructionSize );

                //

                iEngine.Trace( "[PLG] Prologue function: 0x{0:x8} = {1} [+{2:x4}], {3} instructions", iPC.Value, iFunctionName, offset, PrologueInstructionCount );

                PrologueInstructionCount = (int) prologueInstructionCount;

            }

            else

            {

                // We could not locate the symbol for the corresponding program counter address.

                // In this situation, there's nothing we can do - if we cannot work out the offset

                // within the function, then we cannot identify how many Prologue instructions to 

                // attempt to read.

                //

                // If the symbol was not found because no code segment claims ownership of this address

                // then that might indicate premature dll unload or bad crash data (missing code segments)

                if ( collection == null )

                {

                    throw new APESymbolNotFoundCodeSegmentUnavailable( iPC );

                }

                else

                {

                    throw new APESymbolNotFound( iPC, string.Format( "Code segment \'{0}\' should describe symbol, but none was found for requested program counter address", collection.FileName ) );

                }

            }

        }

        private void GetPrologueInstructions()

        {

            TArmInstructionSet instSet = CPU.CurrentProcessorMode;

            uint address = FunctionStartingAddressWithoutType;

            // Let's get unadulterated instruction counts

            int instCount = iPrologueInstructionCount;

            if ( address > 0 && instCount > 0 )

            {

                iInstructions = CodeHelper.LoadInstructions( address, instCount, instSet );

            }

            else

            {

                iInstructions = new AccInstructionList();

            }

            // Verify that we have the expected number of instructions.

            // If, for some reason, the code provider does not supply

            // any Prologue instructions, then we should bail out.

            int actual = iInstructions.Count;

            if ( actual != instCount )

            {

                throw new Exception( string.Format( "Prologue instructions unavailable or insufficient @ address: 0x{0:x8} - expected: {1}, received: {2}", FunctionStartingAddressWithoutType, instCount, actual ) );

            }

            // Since we fetch all the instructions from a function (leading up to the current address)

            // we may have lots more instructions that we'd ideally normally expect to see form part

            // of the function prologue. Normally, we cap the prologue instruction count at ~19 instructions,

            // so therefore we should disable any instructions beyond this maximum.

            for ( int i = KMaxPrologueInstructionCount - 1; i < iInstructions.Count; i++ )

            {

                iInstructions[ i ].Ignored = true;

            }

            // Run the instructions through the pre-filter. We tell the 

            // instruction list how many instructions through the current function

            // we are because this helps to identify whether a branch has been

            // executed as the last instruction, or whether we artificially limited

            // the preamble, in which case the branch was "probably" not taken.

            iInstructions.Prefilter( iPrologueInstructionCount );

            iInstructions.DebugPrint( iEngine as ITracer );

        }

        private void PrepareInitialPCValue()

        {

            // Update the program counter so that we skip past the start of

            // the function. According to Tom G, this is two instructions past

            // the function entry address

            uint newPC = FunctionStartingAddress;

            newPC += (uint) ( 2 * SingleInstructionSize );

            // Zero the non-address bits for sanity

            uint clearBitMask = (uint) ( SingleInstructionSize - 1 );

            newPC &= ~clearBitMask;

            iPC.Value = newPC;

            string sym = iEngine.DebugEngineView.Symbols.PlainText[ iPC.Value ];

            iEngine.Trace( "[PLG] PrepareInitialPCValue - new PC value: 0x{0:x8} = {1}", iPC.Value, sym );

        }

        private void ProcessPrologueInstructions()

        {

            uint sp = iEngine.CPU[ TArmRegisterType.EArmReg_SP ];

            iEngine.Trace( "[PLG] ProcessPrologueInstructions - initial PC: 0x{0:x8}, SP: 0x{1:x8}", iPC.Value, sp );

            // We've got the necessary instructions so continue as normal...

            int actual = iInstructions.Count;

            while ( actual > 0 )

            {

                // Get instruction

                AccInstruction inst = iInstructions.Deque();

                // Don't process any ignored instructions

                if ( inst.Ignored == false )

                {

                    iEngine.Trace( "[PLG] ProcessPrologueInstructions - PC: 0x{0:x8}, SP: 0x{1:x8}, I: {2}", iPC.Value, sp + ( iNumberOfWordsPushedOnStack * 4 ), inst.ToString() );

                    iEngine.SetIndent( 1 );

                    // Process it to update offsets & register values

                    inst.Process( this );

                    // Update Prologue program counter value

                    iPC.Value += SingleInstructionSize;

                    // Finished with indentation

                    iEngine.SetIndent( 0 );

                }

                // Update count

                actual = iInstructions.Count;

            }

        }

        #endregion

        #region Internal properties

        internal ArmCpu CPU

        {

            get { return iEngine.CPU; }

        }

        internal ArmCodeHelper CodeHelper

        {

            get { return iEngine.CodeHelper; }

        }

        internal ArmRegisterCollection OffsetValues

        {

            get { return iOffsetValues; }

        }

        private uint SingleInstructionSize

        {

            get

            {

                uint size = ArmCpuUtils.InstructionSize( CPU.CurrentProcessorMode );

                return size;

            }

        }

        #endregion

        #region Internal constants

        private const int KMaxPrologueInstructionCount = 19;

        private const uint KInstructionSetMask = 0xFFFFFFFE;

        #endregion

        #region Data members

        private readonly AccurateEngine iEngine;

        private readonly ArmRegister iPC;

        private int iPrologueInstructionCount = 0;

        private string iFunctionName = string.Empty;

        private uint iFunctionStartAddress = 0;

        private int iNumberOfWordsPushedOnStack = 0;

        private AccInstructionList iInstructions = new AccInstructionList();

        private ArmRegisterCollection iOffsetValues = new ArmRegisterCollection();

        #endregion

    }

}