/*

* 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 System.IO;

using SymbianUtils.BasicTypes;

using SymbianStackAlgorithmAccurate.CPU;

using SymbianStackAlgorithmAccurate.Prologue;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Instructions;

using SymbianStructuresLib.Arm.Registers;

using SymbianInstructionLib.Arm.Instructions.Common;

using SymbianInstructionLib.Arm.Instructions.Arm;

using SymbianInstructionLib.Arm.Instructions.Arm.DataProcessing;

using SymbianInstructionLib.Arm.Instructions.Thumb;

using SymbianInstructionLib.Arm.Instructions.Thumb.DataProcessing;

namespace SymbianStackAlgorithmAccurate.Instructions.Types

{

    internal class AccInstDataProcessing : AccInstruction

    {

        #region Constructors

        public AccInstDataProcessing( IArmInstruction aInstruction )

            : base( aInstruction )

        {

            System.Diagnostics.Debug.Assert( base.Instruction.AIGroup == TArmInstructionGroup.EGroupDataProcessing );

        }

        #endregion

        #region API

        internal override void Process( ArmPrologueHelper aProlog )

        {

            IArmInstruction instruction = base.Instruction;

            // Only unconditional instructions are handled

            if ( instruction.AIConditionCode == TArmInstructionCondition.AL )

            {

                // Two heuristically observed requirements:

                //

                // 1) It must be an immediate instruction

                // 2) It must apply with source & destination registers both being SP

                if ( instruction is ArmInstruction )

                {

                    // Aim is to detect modifications to SP (i.e. reservation of stack space)

                    Arm_DataProcessing armDpInst = instruction as Arm_DataProcessing;

                    // 1) Must supply an immediate value

                    if ( armDpInst != null && armDpInst.SuppliesImmediate )

                    {

                        // 2) Must apply to SP

                        if ( armDpInst.Rd == TArmRegisterType.EArmReg_SP &&

                             armDpInst.Rn == TArmRegisterType.EArmReg_SP )

                        {

                            uint immediate = armDpInst.Immediate;

                            HandleDPOperation( armDpInst.OperationType, immediate, aProlog );

                        }

                    }

                }

                else if ( instruction is ThumbInstruction )

                {

                    Thumb_AddOrSubtract thumbDpInst = instruction as Thumb_AddOrSubtract;

                    // 2) Must apply to SP

                    if ( thumbDpInst.Rd == TArmRegisterType.EArmReg_SP )

                    {

                        // 1) Must supply an immediate value

                        if ( thumbDpInst != null && thumbDpInst.SuppliesImmediate )

                        {

                            uint immediate = thumbDpInst.Immediate;

                            HandleDPOperation( thumbDpInst.OperationType, immediate, aProlog );

                        }

                        else if ( thumbDpInst is Thumb_Add_2Regs_High )

                        {

                            // Handle the case where one register supplies the number of

                            // words by which the stack pointer is incremented. Used when 

                            // a large stack allocation is made.

                        }

                    }

                }

                else

                {

                    throw new NotSupportedException( "Instruction type not supported" );

                }

            }

        }

        #endregion

        #region Properties

        public bool AppliesToSP

        {

            get

            {

                bool ret = false;

                IArmInstruction instruction = base.Instruction;

                // Only unconditional instructions are handled

                if ( instruction.AIConditionCode == TArmInstructionCondition.AL )

                {

                    // Two heuristically observed requirements:

                    //

                    // 1) It must be an immediate instruction

                    // 2) It must apply with source & destination registers both being SP

                    if ( instruction is ArmInstruction )

                    {

                        // Aim is to detect modifications to SP (i.e. reservation of stack space)

                        Arm_DataProcessing armDpInst = instruction as Arm_DataProcessing;

                        // 1) Must supply an immediate value

                        if ( armDpInst != null && armDpInst.SuppliesImmediate )

                        {

                            // 2) Must apply to SP

                            if ( armDpInst.Rd == TArmRegisterType.EArmReg_SP &&

                                 armDpInst.Rn == TArmRegisterType.EArmReg_SP )

                            {

                                ret = true;

                            }

                        }

                    }

                    else if ( instruction is ThumbInstruction )

                    {

                        Thumb_AddOrSubtract thumbDpInst = instruction as Thumb_AddOrSubtract;

                        // 2) Must apply to SP

                        if ( thumbDpInst.Rd == TArmRegisterType.EArmReg_SP )

                        {

                            // 1) Must supply an immediate value

                            if ( thumbDpInst != null && thumbDpInst.SuppliesImmediate )

                            {

                                ret = true;

                            }

                            else if ( thumbDpInst is Thumb_Add_2Regs_High )

                            {

                                // Handle the case where one register supplies the number of

                                // words by which the stack pointer is incremented. Used when 

                                // a large stack allocation is made.

                            }

                        }

                    }

                }

                return ret;

            }

        }

        #endregion

        #region Internal methods

        private void HandleDPOperation( TArmDataProcessingType aType, uint aImmediate, ArmPrologueHelper aProlog )

        {

            int wordsPushed = (int) aImmediate / 4;

            //

            switch( aType )

            {

            case TArmDataProcessingType.ADD:

                wordsPushed = -wordsPushed;

                break;

            case TArmDataProcessingType.SUB:

                break;

            default:

                throw new NotSupportedException( "Data processing does not (yet) support instructions of type: " + aType );

            }

            //

            aProlog.AddToNumberOfWordsPushedOnStack( wordsPushed );

        }

        #endregion

        #region Data members

        #endregion

    }

}