1 /*

     2 * Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 using System;

    19 using System.Collections.Generic;

    20 using System.Text;

    21 using SymbianStructuresLib.Arm.Registers;

    22 using SymbianUtils.DataBuffer;

    23 using SymbianUtils.DataBuffer.Entry;

    24 

    25 namespace CrashDebuggerLib.Structures.UserContextTable

    26 {

    27     internal class UserContextTableEntry

    28     {

    29         #region Enumerations

    30         public enum TType

    31 		{

    32 		    EUndefined,				/**< register is not available */

    33 		    EOffsetFromSp,			/**< iOffset is offset from stack pointer */

    34 		    EOffsetFromStackTop,	/**< iOffset is offset from stack top */

    35 		    ESpPlusOffset,			/**< value = SP + offset */

    36         }

    37         #endregion

    38 

    39         #region Constructors

    40         public UserContextTableEntry()

    41         {

    42         }

    43         #endregion

    44 

    45         #region API

    46         public bool IsAvailable( bool aIsCurrentThread )

    47         {

    48             bool ret = false;

    49             //

    50             switch ( Type )

    51             {

    52             case TType.EOffsetFromSp:

    53                 // Not allowed when it's the current thread

    54                 ret = ( !aIsCurrentThread );

    55                 break;

    56             case TType.EOffsetFromStackTop:

    57                 // Always allowed

    58                 ret = true;

    59                 break;

    60             case TType.ESpPlusOffset:

    61                 // Not allowed when it's the current thread

    62                 ret = ( !aIsCurrentThread );

    63                 break;

    64             default:

    65             case TType.EUndefined:

    66                 break;

    67             }

    68             //

    69             return ret;

    70         }

    71 

    72         public uint Process( ArmRegister aSp, DataBuffer aStackData )

    73         {

    74             uint ret = 0;

    75             //

    76             switch ( Type )

    77             {

    78             case TType.EUndefined:

    79                 throw new NotSupportedException();

    80             case TType.EOffsetFromSp:

    81                 ret = UpdateUsingOffsetFromSp( aSp, aStackData );

    82                 break;

    83             case TType.EOffsetFromStackTop:

    84                 ret = UpdateUsingOffsetFromStackTop( aSp, aStackData );

    85                 break;

    86             case TType.ESpPlusOffset:

    87                 ret = UpdateUsingSpPlusOffset( aSp, aStackData );

    88                 break;

    89             }

    90             //

    91             return ret;

    92         }

    93         #endregion

    94 

    95         #region Properties

    96         public TType Type

    97         {

    98             get { return iType; }

    99             set { iType = value; }

   100         }

   101 

   102         public byte Offset

   103         {

   104             get { return iOffset; }

   105             set { iOffset = value; }

   106         }

   107 

   108         public uint OffsetAsDWord

   109         {

   110             get { return (uint) Offset * 4; }

   111         }

   112         #endregion

   113 

   114         #region Internal methods

   115         private uint UpdateUsingOffsetFromSp( ArmRegister aSp, DataBuffer aStackData )

   116         {

   117             uint sp = aSp;

   118             uint offset = OffsetAsDWord;

   119             uint fetchAddr = offset + sp;

   120             DataBufferUint val = aStackData[ fetchAddr ];

   121             return val;

   122         }

   123 

   124         private uint UpdateUsingOffsetFromStackTop( ArmRegister aSp, DataBuffer aStackData )

   125         {

   126             uint stackTop = aStackData.Last.Address + 1;

   127             uint offset = OffsetAsDWord;

   128             uint fetchAddr = stackTop - offset;

   129             DataBufferUint val = aStackData[ fetchAddr ];

   130             return val;

   131         }

   132 

   133         private uint UpdateUsingSpPlusOffset( ArmRegister aSp, DataBuffer aStackData )

   134         {

   135             uint sp = aSp;

   136             uint offset = OffsetAsDWord;

   137             uint val = offset + sp;

   138             return val;

   139         }

   140         #endregion

   141 

   142         #region Data members

   143         private TType iType = TType.EUndefined;

   144         private byte iOffset = 0;

   145         #endregion

   146     }

   147 }