/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
*   this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
*   this list of conditions and the following disclaimer in the documentation
*   and/or other materials provided with the distribution.
* - Neither the name of Nokia Corporation nor the names of its contributors
*   may be used to endorse or promote products derived from this software
*   without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* 
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using MemAnalysisLib.Parser.Prefixes;
using MemAnalysisLib.MemoryOperations.Functions;
using MemAnalysisLib.MemoryOperations.Class;
using MemAnalysisLib.MemoryOperations.Operations;
using MemAnalysisLib.Interfaces;
using SymbianUtils;

namespace MemAnalysisLib.MemoryOperations.Functions.Kernel
{
    internal abstract class MemOpFnKReallocBase : MemOpFnKAllocBase
    {
		#region Constructors & destructor
        protected MemOpFnKReallocBase()
		{
		}
		#endregion

		#region From MemOpFnBase
        public override MemAnalysisLib.MemoryOperations.Class.TClass Class
        {
            get { return TClass.EReallocation; } 
        }

        public override MemOpBase Parse( ref string aLine, MemAnalysisParserPrefixesBase aPrefixes )
        {
            MemOpReallocation ret = new MemOpReallocation();

            // Parse fields
            base.ParseCommonKernel( ret, ref aLine, aPrefixes );
            base.ParseCommonAlloc( ret, ref aLine, aPrefixes );
            ParseCommonRealloc( ret, ref aLine, aPrefixes );

            // Set type
            ret.Function = this;

            return ret;
        }
        #endregion

        #region Internal methods
        protected void ParseCommonRealloc( MemOpReallocation aOperation, ref string aLine, MemAnalysisParserPrefixesBase aPrefixes )
        {
            if ( aLine.IndexOf( aPrefixes.ReallocMode ) >= 0 )
            {
                PrefixParser.SkipPrefix( aPrefixes.ReallocMode, ref aLine );
                aOperation.ReallocationMode = (byte) PrefixParser.ReadLong( ref aLine );
            }
            if ( aLine.IndexOf( aPrefixes.OriginalCellAddress ) >= 0 )
            {
                PrefixParser.SkipPrefix( aPrefixes.OriginalCellAddress, ref aLine );
                aOperation.OriginalAddress = PrefixParser.ReadUint( ref aLine );
            }
            if ( aLine.IndexOf( aPrefixes.OriginalCellSize ) >= 0 )
            {
                PrefixParser.SkipPrefix( aPrefixes.OriginalCellSize, ref aLine );
                aOperation.OriginalAllocationSize = PrefixParser.ReadUint( ref aLine );
            }
            if ( aLine.IndexOf( aPrefixes.OriginalCellAllocNumber ) >= 0 )
            {
                PrefixParser.SkipPrefix( aPrefixes.OriginalCellAllocNumber, ref aLine );
                aOperation.OriginalAllocationNumber = PrefixParser.ReadUint( ref aLine );
            }
        }
        #endregion
    }

    internal class MemOpFnKernReAlloc : MemOpFnKReallocBase
	{
		#region Constructors & destructor
        public MemOpFnKernReAlloc()
		{
		}
		#endregion

		#region From MemOpFnBase
        public override string ToString()
        {
            return base.ToString() + "Kern::ReAlloc";
        }
		#endregion
	}

    internal class MemOpFnKernSafeReAlloc : MemOpFnKReallocBase
	{
		#region Constructors & destructor
        public MemOpFnKernSafeReAlloc()
		{
		}
		#endregion

		#region From MemOpFnBase
        public override string ToString()
        {
            return base.ToString() + "Kern::SafeReAlloc";
        }

        public override void Process( MemOpBase aItem, CollectionManager aCollectionManager )
        {
            if ( aItem.CellAddress == 0xc8099f8c )
            {
                int x = 0;
                x++;
            }

            // (1) Alloc, SafeRealloc
            // 
            // [KMEM] OKA     - C: 0xc801a65c, HS:    29096, HCS:    53128, LR: 0x800b82f4, CS:        4, AS:        4, AN:       93
            // [KMEM] OKSR    - C: 0xc801a65c, HS:    29096, HCS:    53128, LR: 0x800aebdc, AS:        4, AN:       93, OC: 0x00000000, OCS:        0, OCAN:        0, VT: 0x00000000
            // 
            // 
            // (2) Realloc, SafeRealloc
            // [KMEM] OKR     - C: 0xc801ae1c, HS:    33656, HCS:    53128, LR: 0x800b82d4, AS:       12, AN:      106, MD: 1, OC: 0xc801ae1c, OCS:       12, OCAN:      106, VT: 0xc801a688
            // [KMEM] OKSR    - C: 0xc801ae1c, HS:    33656, HCS:    53128, LR: 0x800aebdc, AS:       12, AN:      106, OC: 0xc801ae1c, OCS:       12, OCAN:      106, VT: 0xc801a688
            // ...
            // [KMEM] OKR     - C: 0xc822ee8c, HS:  1672036, HCS:  2236296, LR: 0x800b83c8 [ Kern::SafeReAlloc(void*&, int, int) ], CS:      660, AS:      652, AN:    99936, MD: 0, OC: 0xc822ee8c, OCS:      660, OCAN:    99936, VT: 0xc80131e8
            // [KMEM] OKSR    - C: 0xc822ee8c, HS:  1672036, HCS:  2236296, LR: 0x800adc7c [ DObjectCon::Remove(DObject*) ], CS:      660, AS:      652, AN:    99936, OC: 0xc822ee8c, OCS:      660, OCAN:    99936, VT: 0xc80131e8
            // 
            //
            // (3) Alloc, Free, SafeRealloc
            //
            // [KMEM] OKA     - C: 0xc801a744, HS:    29268, HCS:    53128, LR: 0x800b82f4, CS:        4, AS:        4, AN:       98
            // [KMEM] OKSR    - C: 0xc801a744, HS:    29268, HCS:    53128, LR: 0x800aebdc, AS:        4, AN:       98, OC: 0x00000000, OCS:        0, OCAN:        0, VT: 0x00000000
            // ...
            // [KMEM] OKA     - C: 0xc801ae1c, HS:    30932, HCS:    53128, LR: 0x800b82f4, CS:       12, AS:        8, AN:      106
            // [KMEM] OKF     - C: 0xc801a744, HS:    30928, HCS:    53128, LR: 0x800b836c, CS:        4, AN:       98, VT: 0xc801a688
            // [KMEM] OKSR    - C: 0xc801ae1c, HS:    30928, HCS:    53128, LR: 0x800aebdc, AS:        8, AN:      106, OC: 0xc801a744, OCS:        4, OCAN:       98, VT: 0xc801a688

            MemOpBase lastOpByAllocNumber = aCollectionManager.PriorOperationByAllocationNumber( aItem.AllocationNumber );
            MemOpReallocation op = (MemOpReallocation) aItem;

            if ( lastOpByAllocNumber != null )
            {
                if ( lastOpByAllocNumber.CellAddress == op.CellAddress &&
                     lastOpByAllocNumber.Class == TClass.EAllocation &&
                     op.OriginalAddress == 0 )
                {
                    // 1) Alloc, SafeRealloc => dump alloc
                    aCollectionManager.RemoveFromCollection( lastOpByAllocNumber );
                    aCollectionManager.RemovePriorOperation( lastOpByAllocNumber );
                    aCollectionManager.AddToCollection( op, op.LinkRegisterSymbol, op.LinkRegisterAddress );
                    aCollectionManager.AddNewPriorOperation( op );
                }
                else if ( lastOpByAllocNumber.Class == TClass.EReallocation && lastOpByAllocNumber.CellAddress == op.CellAddress )
                {
                    // 2) Realloc, SafeRealloc => dump realloc
                    aCollectionManager.RemoveFromCollection( lastOpByAllocNumber );
                    aCollectionManager.RemovePriorOperation( lastOpByAllocNumber );

                    // Also, it's possible that this is just a no-op. For example, this pattern can occur when removing
                    // an object from a DObjectCon, in which case the DObjectCon code requests that the cell be shrunk in size.
                    //
                    // If there is no cell growth, then we shouldn't bother saving the operation.
                    int impact = (int) op.AllocationSize - (int) op.OriginalAllocationSize;
                    if ( impact > 0 )
                    {
                        aCollectionManager.AddToCollection( op, op.LinkRegisterSymbol, op.LinkRegisterAddress );
                        aCollectionManager.AddNewPriorOperation( op );
                    }
                }
                else
                {
                    // Checking for scenario (3)
                    //
                    // lastOpByAllocNumber will correspond to the 'alloc' operation. 
                    if ( lastOpByAllocNumber.Class == TClass.EAllocation &&
                         lastOpByAllocNumber.CellAddress == op.CellAddress ) // Satisfies linkage between OKSR and OKA
                    {
                        // We need to find out what the prior op was for the original cell allocation number. 
                        // This should point to the 'free' operation.
                        MemOpBase freeOp = aCollectionManager.PriorOperationByAllocationNumber( op.OriginalAllocationNumber );

                        // If we're throwing away matching allocated & subsequently freed cells, then freeOp will be null...
                        if ( freeOp == null || ( freeOp.Class == TClass.EDeallocation && freeOp.CellAddress == op.OriginalAddress ) )
                        {
                            // (3) Alloc, Free, SafeRealloc => dump alloc and free!

                            // Remove alloc, which is replaced by our new SafeRealloc entry
                            aCollectionManager.RemovePriorOperation( lastOpByAllocNumber );
                            aCollectionManager.RemoveFromCollection( lastOpByAllocNumber );

                            // Remove free for the old SafeRealloc heap cell
                            if ( freeOp != null )
                            {
                                aCollectionManager.RemovePriorOperation( freeOp );
                                aCollectionManager.RemoveFromCollection( freeOp );

                                // We may also need to remove a prior SafeRealloc that uses the same heap cell
                                MemOpBase safeReallocForDeletedCell = aCollectionManager.PriorOperationByAllocationNumber( freeOp.AllocationNumber );
                                if ( safeReallocForDeletedCell.Class == TClass.EReallocation && safeReallocForDeletedCell.CellAddress == freeOp.CellAddress )
                                {
                                    // Remove prior realloc associated with the old heap cell
                                    aCollectionManager.RemovePriorOperation( safeReallocForDeletedCell );
                                    aCollectionManager.RemoveFromCollection( safeReallocForDeletedCell );
                                }
                            }
                            
                            // Now add our new SafeRealloc entry to the master list
                            aCollectionManager.AddToCollection( op, op.LinkRegisterSymbol, op.LinkRegisterAddress );
                            aCollectionManager.AddNewPriorOperation( op );
                        }
                    }
                }
            }
        }
        #endregion
	}
}