/*
* 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 SymbianDebugLib.Engine;
using SymbianDebugLib.PluginAPI.Types.Symbol;
using SymbianStackAlgorithmAccurate.Code;
using SymbianStackAlgorithmAccurate.CPU;
using SymbianStackAlgorithmAccurate.Interfaces;
using SymbianStackAlgorithmAccurate.Prologue;
using SymbianStackAlgorithmAccurate.Stack;
using SymbianStructuresLib.Arm;
using SymbianStructuresLib.Arm.Registers;
using SymbianUtils;
using SymbianUtils.Tracer;

namespace SymbianStackAlgorithmAccurate.Engine
{
    internal class AccurateEngine : DisposableObject, ITracer
    {
        #region Constructors
        public AccurateEngine( DbgEngineView aDebugEngineView, IArmStackInterface aStackInterface, ITracer aTracer )
        {
            iTracer = aTracer;
            iDebugEngineView = aDebugEngineView;
            iStackInterface = aStackInterface;
            iCodeHelper = new ArmCodeHelper( aDebugEngineView, aTracer );
        }
        #endregion

        #region API
        public bool Process()
        {
            // We need SP, LR, PC, CPSR
            CheckRequiredRegistersAvailable();

            // Debug info
            PrintInitialInfo();

            // Make initial stack frames for seed registers
            MakeInitialSeedStackFramesFromRegisterValues();

            // Get sp
            ArmRegister sp = CPU[ TArmRegisterType.EArmReg_SP ];
            uint initialSPValue = sp.Value;

            // Create Prologue object that will establish the instructions for the
            // function and also identify operations that might affect SP and LR.
            ArmPrologueHelper Prologue = new ArmPrologueHelper( this );
            Prologue.Build();
            
            // Create a new stack frame for this function call
            ArmStackFrame stackFrame = new ArmStackFrame( Prologue );

            // We save the stack address which contained the popped link register
            // during the previous cycle. If possible, use that value. If it
            // hasn't been set, then assume we obtained the link register from the
            // previous 4 bytes of stack (according to the current value of SP).
            long stackAddressAssociatedWithCurrentFrame = iLastLinkRegisterStackAddress;
            if ( stackAddressAssociatedWithCurrentFrame == KLinkRegisterWasNotPushedOnStack )
            {
                // We're always four bytes behind the current SP
                stackAddressAssociatedWithCurrentFrame = sp - 4;
            }
            stackFrame.Address = (uint) stackAddressAssociatedWithCurrentFrame;
            stackFrame.Data = iStackInterface.StackValueAtAddress( stackFrame.Address );

            Trace( "Creating Stack Frame [" + stackFrame.Address.ToString( "x8" ) + "] = 0x" + stackFrame.Data.ToString( "x8" ) + " = " + SymbolString ( stackFrame.Data ) );

            // Can now adjust stack pointer based upon the number of stack-adjusting
            // instructions during the Prologue phase.
            uint stackAdjustment = (uint) ( Prologue.NumberOfWordsPushedOnStack * 4 );
            sp.Value += stackAdjustment;
            Trace( "stack adjusted by: 0x" + stackAdjustment.ToString( "x8" ) );

            // We're hoping that the link register was pushed on the stack somewhere
            // during the function preamble. If that was the case, then as we processed
            // each instruction, we'll have updated the register offsets so that we know
            // the offset to the link register from the perspective of the starting stack
            // address for the function.
            uint lrOffsetInWords = Prologue.OffsetValues[ TArmRegisterType.EArmReg_LR ];
            Trace( string.Format( "LR offset on stack is: 0x{0:x8}", lrOffsetInWords * 4 ) );
            GetNewLRValue( lrOffsetInWords, Prologue );

            // Update the PC to point to the new function address (which we obtain
            // from LR)
            uint oldPCValue = CPU.PC;
            ChangePCToLRAddress();
            uint newPCValue = CPU.PC;
            Trace( string.Format( "oldPCValue: 0x{0:x8}, newPCValue: 0x{1:x8}, fn: {2}", oldPCValue, newPCValue, SymbolViewText[ newPCValue ] ) );

            // Decide if we are in thumb or ARM mode after switching functions
            UpdateInstructionSet( newPCValue );

            // Return true if we moved to a new function
            bool gotNewFunction = ( oldPCValue != CPU.PC );
            Trace( "gotNewFunction: " + gotNewFunction );

            // Save stack frame
            SaveStackFrames( stackFrame );

            // Increment iteration
            ++iIterationNumber;

            // Do we have more to do?
            bool moreToDo = gotNewFunction && ( CPU.PC > 0 );

            // Done
            Trace( "moreToDo: " + moreToDo );
            return moreToDo;
        }
        #endregion

        #region Properties
        public ArmCpu CPU
        {
            get { return iCPU; }
        }

        public ArmStackFrame[] StackFrames
        {
            get
            {
                return iStackFrames.ToArray();
            }
        }

        internal ArmCodeHelper CodeHelper
        {
            get { return iCodeHelper; }
        }

        internal DbgEngineView DebugEngineView
        {
            get { return iDebugEngineView; }
        }

        internal DbgViewSymbol SymbolView
        {
            get { return DebugEngineView.Symbols; }
        }

        internal DbgSymbolViewText SymbolViewText
        {
            get { return SymbolView.PlainText; }
        }
        #endregion

        #region Internal methods
        private void PrintInitialInfo()
        {
            ArmRegister sp = CPU[ TArmRegisterType.EArmReg_SP ];
            //
            ArmRegister lr = CPU[ TArmRegisterType.EArmReg_LR ];
            string lrSymbol = SymbolViewText[ lr ];
            //
            ArmRegister pc = CPU[ TArmRegisterType.EArmReg_PC ];
            string pcSymbol = SymbolViewText[ pc ];
            //
            ArmRegister cpsr = CPU[ TArmRegisterType.EArmReg_CPSR ];
            //
            Trace( System.Environment.NewLine );
            Trace( string.Format( "[{5:d2}] SP: 0x{0:x8}, LR: 0x{1:x8} [{2}], PC: 0x{3:x8} [{4}], isThumb: {6}", sp.Value, lr.Value, lrSymbol, pc.Value, pcSymbol, iIterationNumber, CPU.CurrentProcessorMode == TArmInstructionSet.ETHUMB ) );
        }

        private void CheckRequiredRegistersAvailable()
        {
            ArmRegisterCollection regs = CPU.Registers;

            // We need SP, LR, PC, CPSR
            bool sp = regs.Contains( TArmRegisterType.EArmReg_SP );
            bool lr = regs.Contains( TArmRegisterType.EArmReg_LR );
            bool pc = regs.Contains( TArmRegisterType.EArmReg_PC );
            bool cpsr = regs.Contains( TArmRegisterType.EArmReg_CPSR );
            //
            bool available = ( sp && lr && pc && cpsr );
            if ( !available )
            {
                SymbianUtils.SymDebug.SymDebugger.Break();
                throw new ArgumentException( "One or more registers is unavailable" );
            }
        }

        private void MakeInitialSeedStackFramesFromRegisterValues()
        {
            if ( !iAlreadySavedInitialRegisterFrames )
            {
                ArmRegisterCollection regs = CPU.Registers;

                // Make PC stack frame
                ArmStackFrame framePC = new ArmStackFrame( TArmRegisterType.EArmReg_PC );
                framePC.Data = regs[ TArmRegisterType.EArmReg_PC ].Value;

                // Make LR stack frame
                ArmStackFrame frameLR = new ArmStackFrame( TArmRegisterType.EArmReg_LR );
                frameLR.Data = regs[ TArmRegisterType.EArmReg_LR ].Value;

                // Save 'em
                SaveStackFrames( framePC, frameLR );

                // Don't do this again
                iAlreadySavedInitialRegisterFrames = true;
            }
        }

        private void GetNewLRValue( uint aLinkRegOffsetInWords, ArmPrologueHelper aPrologue )
        {
            uint sp = CPU[ TArmRegisterType.EArmReg_SP ];
            Trace( string.Format( "GetNewLRValue - stack DWORD offset to LR: 0x{0:x8}, sp: 0x{1:x8}", aLinkRegOffsetInWords, sp ) );

            // If the link register was pushed onto the stack, then get the new value
            // now...
            if ( aLinkRegOffsetInWords != uint.MaxValue )
            {
                ArmRegisterCollection regs = aPrologue.OffsetValues;
                foreach ( ArmRegister reg in regs )
                {
                    Trace( "GetNewLRValue - reg offsets - " + reg.ToString() );
                }

                long offsetOnStackToLR = aLinkRegOffsetInWords * 4;
                long stackBase = iStackInterface.StackBase;
                long stackOffsetToLR = sp - 4 - stackBase - offsetOnStackToLR;
                iLastLinkRegisterStackAddress = stackBase + stackOffsetToLR;
                uint newLRValue = iStackInterface.StackValueAtAddress( (uint) iLastLinkRegisterStackAddress );
                Trace( string.Format( "GetNewLRValue - Fetching LR from stack address: 0x{0:x8} (0x{1:x8})", iLastLinkRegisterStackAddress, newLRValue ) );

                uint temp;
                string sym;
                SymbolViewText.Lookup( newLRValue, out temp, out sym );
                Trace( "GetNewLRValue - LR changed to: 0x" + newLRValue.ToString( "x8" ) + " => [ " + sym + " ]" );

                CPU[ TArmRegisterType.EArmReg_LR ].Value = newLRValue;
            }
            else
            {
                iLastLinkRegisterStackAddress = KLinkRegisterWasNotPushedOnStack;
                Trace( "GetNewLRValue - LR not pushed on stack!" );
            }
        }

        private void UpdateInstructionSet( uint aPC )
        {
            uint isThumb = aPC & 0x1;
            if ( isThumb != 0 )
            {
                CPU.CurrentProcessorMode = TArmInstructionSet.ETHUMB;
            }
            else
            {
                CPU.CurrentProcessorMode = TArmInstructionSet.EARM;
            }

            // Twiddle the first bit to clear any possible non-address value
            CPU.PC.Value &= 0xFFFFFFFE;
        }

        private void ChangePCToLRAddress()
        {
            CPU.PC.Value = CPU.LR.Value;

            // Zero out the LR value as it has just been promoted to PC
            CPU.LR.Value = 0;
        }

        private void SaveStackFrames( params ArmStackFrame[] aFrames )
        {
            foreach ( ArmStackFrame frame in aFrames )
            {
                iStackFrames.Add( frame );
            }
        }

        private string SymbolString( uint aAddress )
        {
            // Used for debugging
            uint fnStartAddr = 0;
            string symbolName = string.Empty;
            SymbolViewText.Lookup( aAddress, out fnStartAddr, out symbolName );
            return symbolName;
        }
        #endregion

        #region Internal constants
        private const long KLinkRegisterWasNotPushedOnStack = -1;
        #endregion

        #region From ITracer
        public void Trace( string aMessage )
        {
            StringBuilder t = new StringBuilder();
            //
            string pad = string.Empty;
            //
            if ( iTraceIndentLevel != 0 )
            {
                pad = pad.PadLeft( iTraceIndentLevel * 4, ' ' );
            }
            //
            t.AppendFormat( "[AIE] {0}{1}", pad, aMessage );
            iTracer.Trace( t.ToString() );
        }

        public void Trace( string aFormat, params object[] aParams )
        {
            string t = string.Format( aFormat, aParams );
            Trace( t );
        }

        internal void SetIndent( int aIndentLevel )
        {
            iTraceIndentLevel = aIndentLevel;
        }
        #endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                base.CleanupManagedResources();
            }
            finally
            {
                iStackFrames.Clear();
                iStackFrames = null;
            }
        }
        #endregion

        #region Data members
        private readonly ITracer iTracer;
        private readonly DbgEngineView iDebugEngineView;
        private readonly ArmCodeHelper iCodeHelper;
        private readonly IArmStackInterface iStackInterface;
        private long iLastLinkRegisterStackAddress = KLinkRegisterWasNotPushedOnStack;
        private int iTraceIndentLevel = 0;
        private int iIterationNumber = 0;
        private bool iAlreadySavedInitialRegisterFrames = false;
        private ArmCpu iCPU = new ArmCpu();
        private List<ArmStackFrame> iStackFrames = new List<ArmStackFrame>();
        #endregion
    }
}