/*
* 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.BasicTypes;
using SymbianStructuresLib.Arm.Registers;
using SymbianStructuresLib.Arm.Instructions;
using SymbianInstructionLib.Arm.Instructions.Common;

namespace SymbianInstructionLib.Arm.Instructions.Arm.DataTransfer
{
    [ArmRefAttribute( "A4.1.20 LDM(1) + A5.4.1 Encoding", "LDM{<cond>}<addressing_mode> <Rn>{!}, <registers>" )]
    public class Arm_LDM : Arm_LoadOrStoreMultiple_GP
    {
        #region Enumerations
        public enum TType
        {
            ETypeNotSupported = -1,
            ETypeNonEmptyGP = 0,
            ETypeUserModeWhenInPrivilaged,
            ETypeGPAndPCAndUpdateCPSR
        }
        #endregion

        #region Constructors
        public Arm_LDM()
        {
            //  4    3                  4               16 bits
            // ---------------------------------------------------
            // cond 100 P U S W L       Rn          register list
            // 1110 100 0 1 0 1 1     1101         1000111111110000
            //
            // P  = indicates that the word addressed by Rn is included in the range of memory
            //      locations accessed, lying at the top (U==0) or bottom (U==1) of that range.
            //
            // U  = Indicates that the transfer is made upwards (U==1) or downwards (U==0) from 
            //      the base register.
            //
            // S  = For LDMs that load the PC, the S bit indicates that the CPSR is loaded 
            //      from the SPSR.
            //
            // W  = Indicates that the base register is updated after the transfer. The base 
            //      register is incremented (U==1) or decremented (U==0) by four times the 
            //      number of registers in the register list.
            //
            // L  = Distinguishes between Load (L==1) and Store (L==0) instructions.
            //
            // Rn = Specifies the base register used by <addressing_mode>. Using R15 as 
            //      the base register <Rn> gives an UNPREDICTABLE result.
            // 
            // This mask translates to "LDM's that load PC from SP"
            //        1110 100 01011 1101    1000111111110000
            base.SetMask( "####" + "100" + "##" + "##1" + "####" + "######## ########" );
        }
        #endregion

        #region From ArmInstruction
        public override bool Matches( uint aOpCode )
        {
            bool match = base.Matches( aOpCode );
            if ( match )
            {
                TType type = StaticInternalType( aOpCode );
                match = ( type != TType.ETypeNotSupported );
            }
            return match;
        }
        #endregion

        #region From Arm_LoadOrStore
        public override TArmDataTransferType DataTransferType
        {
            get { return TArmDataTransferType.ELoad; }
        }
        #endregion

        #region Properties
        public TType Type
        {
            get { return iType; }
        }
        #endregion

        #region From ArmBaseInstruction
        protected override void OnRawValueAssigned()
        {
            base.OnRawValueAssigned();
            iType = InternalType;
        }
        #endregion

        #region Internal methods
        private new SymBit SBit // Hide
        {
            get { return SymBit.EClear; }
        }

        private TType InternalType
        {
            get
            {
                uint raw = base.AIRawValue;
                TType ret = StaticInternalType( raw );
                return ret;
            }
        }

        private static TType StaticInternalType( uint aRaw )
        {
            TType ret = TType.ETypeNotSupported;
            //
            if ( KLDM1.IsMatch( aRaw ) )
            {
                ret = TType.ETypeNonEmptyGP;
            }
            else if ( KLDM2.IsMatch( aRaw ) )
            {
                ret = TType.ETypeUserModeWhenInPrivilaged;
            }
            else if ( KLDM3.IsMatch( aRaw ) )
            {
                ret = TType.ETypeGPAndPCAndUpdateCPSR;
            }
            //
            return ret;
        }
        #endregion

        #region Data members
        private TType iType = TType.ETypeNotSupported;
        private static readonly SymMask KLDM1 = new SymMask( "####" + "100" + "##" + "0#1" + "####" + "######## ########" );
        private static readonly SymMask KLDM2 = new SymMask( "####" + "100" + "##" + "101" + "####" + "0####### ########" );
        private static readonly SymMask KLDM3 = new SymMask( "####" + "100" + "##" + "1#1" + "####" + "1####### ########" );
        #endregion
    }
}