FCL/sftools/ana/dynaanamdw/crashmdw: comparison crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianCodeLib/SourceManagement/Source/CodeSource.cs

equal deleted inserted replaced

--1:000000000000
+:818e61de6cd1
+/*
+* Copyright (c) 2004-2008 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;
+using SymbianUtils.Range;
+using SymbianUtils.Threading;
+using SymbianStructuresLib.Arm;
+using SymbianStructuresLib.Arm.Instructions;
+using SymbianStructuresLib.CodeSegments;
+using SymbianStructuresLib.Debug.Code;
+using SymbianStructuresLib.Debug.Code.Interfaces;
+using SymbianStructuresLib.Debug.Common.FileName;
+using SymbianCodeLib.SourceManagement.Provisioning;
+namespace SymbianCodeLib.SourceManagement.Source
+{
+public abstract class CodeSource : DisposableObject, IEnumerable<CodeCollection>, ICodeCollectionRelocationHandler, ICodeCollectionInstructionConverter
+{
+#region Delegates & events
+public delegate void EventHandlerFunction( TEvent aEvent, CodeSource aSource, object aData );
+public event EventHandlerFunction EventHandler;
+#endregion
+#region Enumerations
+public enum TEvent
+{
+EReadingStarted = 0,
+EReadingProgress,
+EReadingComplete
+}
+public enum TTimeToRead
+{
+EReadWhenPriming = 0,
+EReadWhenNeeded // i.e. relocated
+}
+#endregion
+#region Constructors
+public CodeSource( string aURI, CodeSourceProvider aProvider )
+{
+iURI = aURI;
+iProvider = aProvider;
+}
+#endregion
+#region API
+public virtual void Read( TSynchronicity aSynchronicity )
+{
+bool isReading = this.IsReadInProgress;
+if ( isReading )
+{
+// Another thread is already reading this source.
+// If the caller asked for asynchronous reading, then when the
+// other thread completes the read the caller (in this thread)
+// will be notified via the normal event callback framework - in which
+// case we need do nothing at all - just let the other thread get on with it.
+//
+// If, on the other hand, the caller requested a synchronous read, then they
+// will expect the code to be ready at the point in time which we return to them.
+//
+// In this situation, we should block this method until the code becomes ready.
+if ( aSynchronicity == TSynchronicity.ESynchronous )
+{
+while ( this.IsReadInProgress )
+{
+System.Threading.Thread.Sleep( 0 );
+}
+}
+}
+else
+{
+DoRead( aSynchronicity );
+}
+}
+public virtual void Add( CodeCollection aCollection )
+{
+// We can always do this task
+aCollection.IfaceInstructionConverter = this;
+// We want to be told if the collection changes it's relocation state.
+aCollection.RelocationStatusChanged += new CodeCollection.RelocationStatusChangeHandler( Collection_RelocationStatusChanged );
+lock ( iCollectionsAll )
+{
+iCollectionsAll.Add( aCollection );
+}
+CategoriseCollection( aCollection );
+}
+public virtual void Remove( CodeCollection aCollection )
+{
+aCollection.RelocationStatusChanged -= new CodeCollection.RelocationStatusChangeHandler( Collection_RelocationStatusChanged );
+//
+lock ( iCollectionsAll )
+{
+iCollectionsAll.Remove( aCollection );
+}
+lock ( iAlwaysActivatedCollections )
+{
+iAlwaysActivatedCollections.Remove( aCollection );
+}
+}
+public virtual bool Contains( uint aAddress )
+{
+return iAlwaysActivatedCollections.Contains( aAddress );
+}
+public virtual bool ProvideInstructions( uint aAddress, TArmInstructionSet aInstructionSet, int aCount, out IArmInstruction[] aInstructions )
+{
+lock ( iAlwaysActivatedCollections )
+{
+bool ret = iAlwaysActivatedCollections.GetInstructions( aAddress, aInstructionSet, aCount, out aInstructions );
+return ret;
+}
+}
+protected abstract void DoRead( TSynchronicity aSynchronicity );
+protected virtual void OnAddedToCollection( CodeSourceCollection aCollection )
+{
+++iReferenceCount;
+}
+protected virtual void OnRemovedFromCollection( CodeSourceCollection aCollection )
+{
+if ( --iReferenceCount <= 0 )
+{
+this.Dispose();
+}
+}
+protected virtual void OnPrepareForRelocation( CodeCollection aCollection, uint aOldBase, uint aNewBase )
+{
+// If we read our data during priming, then we don't need to do anything... otherwise, we should
+// read the data now.
+//
+// However, don't initiate a read if we already have obtained code for the specified collection
+// (this can be the case if we are relocating a cloned code collection which has already been activated
+// itself in the past).
+if ( aCollection.IsCodeAvailable == false )
+{
+System.Diagnostics.Debug.Assert( this.IsReady == false );
+//
+if ( TimeToRead == TTimeToRead.EReadWhenNeeded )
+{
+this.Read( TSynchronicity.ESynchronous );
+}
+}
+}
+protected virtual void OnReadComplete()
+{
+}
+#endregion
+#region API - framework
+public void ReportEvent( TEvent aEvent )
+{
+ReportEvent( aEvent, null );
+}
+public void ReportEvent( TEvent aEvent, object aData )
+{
+PreProcessEvent( aEvent );
+// Cascade
+if ( EventHandler != null )
+{
+EventHandler( aEvent, this, aData );
+}
+}
+#endregion
+#region Properties
+public int Count
+{
+get { return iCollectionsAll.Count; }
+}
+public string URI
+{
+get
+{
+lock ( iURI )
+{
+return iURI;
+}
+}
+set
+{
+lock ( iURI )
+{
+iURI = value;
+}
+}
+}
+public string FileName
+{
+get { return iProvider.GetFileName( this ); }
+}
+public TTimeToRead TimeToRead
+{
+get { return iTimeToRead; }
+set
+{
+iTimeToRead = value;
+}
+}
+public CodeSourceProvider Provider
+{
+get
+{
+lock ( iProvider )
+{
+return iProvider;
+}
+}
+}
+public CodeCollection this[ int aIndex ]
+{
+get { return iCollectionsAll[ aIndex ]; }
+}
+public virtual CodeCollection this[ CodeSegDefinition aCodeSegment ]
+{
+get
+{
+CodeCollection ret = iCollectionsAll[ aCodeSegment ];
+return ret;
+}
+}
+public virtual CodeCollection this[ PlatformFileName aFileName ]
+{
+get
+{
+lock ( iCollectionsAll )
+{
+CodeCollection ret = iCollectionsAll[ aFileName ];
+return ret;
+}
+}
+}
+public bool IsReady
+{
+get
+{
+lock ( iFlagsSyncRoot )
+{
+bool ret = ( iFlags & TFlags.EFlagsIsReady ) != 0;
+return ret;
+}
+}
+set
+{
+lock ( iFlagsSyncRoot )
+{
+if ( value )
+{
+iFlags |= TFlags.EFlagsIsReady;
+}
+else
+{
+iFlags &= ~TFlags.EFlagsIsReady;
+}
+}
+}
+}
+public bool IsReadInProgress
+{
+get
+{
+lock ( iFlagsSyncRoot )
+{
+bool ret = ( iFlags & TFlags.EFlagsIsReadInProgress ) != 0;
+return ret;
+}
+}
+set
+{
+lock ( iFlagsSyncRoot )
+{
+if ( value )
+{
+iFlags |= TFlags.EFlagsIsReadInProgress;
+}
+else
+{
+iFlags &= ~TFlags.EFlagsIsReadInProgress;
+}
+}
+}
+}
+#endregion
+#region Event handlers
+private void Collection_RelocationStatusChanged( CodeCollection aCollection )
+{
+CategoriseCollection( aCollection );
+}
+#endregion
+#region Internal methods
+internal int CountActivated
+{
+get { return iAlwaysActivatedCollections.Count; }
+}
+internal void AddedToCollection( CodeSourceCollection aCollection )
+{
+OnAddedToCollection( aCollection );
+}
+internal void RemovedFromCollection( CodeSourceCollection aCollection )
+{
+OnRemovedFromCollection( aCollection );
+}
+private void CategoriseCollection( CodeCollection aCollection )
+{
+// Reset state
+lock ( iAlwaysActivatedCollections )
+{
+iAlwaysActivatedCollections.Remove( aCollection );
+aCollection.IfaceRelocationHandler = null;
+}
+// Collections which do not move from their pre-determined base address
+// are transparently "activated" which means that they will be queried
+// automatically during symbolic look up.
+if ( aCollection.IsFixed )
+{
+lock ( iAlwaysActivatedCollections )
+{
+iAlwaysActivatedCollections.Add( aCollection );
+}
+}
+else
+{
+// Otherwise, we must wait until the client relocates the code
+// and then we will be called back. During the callback processing
+// we'll load the code (if needed) and fixup the base address.
+aCollection.IfaceRelocationHandler = this;
+}
+}
+private void PreProcessEvent( TEvent aEvent )
+{
+switch ( aEvent )
+{
+case TEvent.EReadingStarted:
+IsReady = false;
+IsReadInProgress = true;
+break;
+case TEvent.EReadingComplete:
+IsReady = true;
+IsReadInProgress = false;
+OnReadComplete();
+break;
+}
+}
+#endregion
+#region Internal enumerations
+[Flags]
+private enum TFlags
+{
+EFlagsNone = 0,
+EFlagsIsReady = 1,
+EFlagsIsReadInProgress = 2
+}
+#endregion
+#region From ICodeCollectionRelocationHandler
+public void PrepareForRelocation( CodeCollection aCollection, uint aOldBase, uint aNewBase )
+{
+OnPrepareForRelocation( aCollection, aOldBase, aNewBase );
+}
+#endregion
+#region From ICodeCollectionInstructionConverter
+public IArmInstruction[] ConvertRawValuesToInstructions( TArmInstructionSet aInstructionSet, uint[] aRawValues, uint aStartingAddress )
+{
+IArmInstruction[] ret = iProvider.ConvertToInstructions( aInstructionSet, aRawValues, aStartingAddress );
+return ret;
+}
+#endregion
+#region From IEnumerable<CodeCollection>
+public IEnumerator<CodeCollection> GetEnumerator()
+{
+foreach ( CodeCollection col in iCollectionsAll )
+{
+yield return col;
+}
+}
+System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+{
+foreach ( CodeCollection col in iCollectionsAll )
+{
+yield return col;
+}
+}
+#endregion
+#region From DisposableObject
+protected override void CleanupManagedResources()
+{
+try
+{
+base.CleanupManagedResources();
+}
+finally
+{
+int count = iCollectionsAll.Count;
+for ( int i = count - 1; i >= 0; i-- )
+{
+CodeCollection col = iCollectionsAll[ i ];
+Remove( col );
+col.Dispose();
+}
+// These should both be empty in any case
+iCollectionsAll.Clear();
+iAlwaysActivatedCollections.Clear();
+}
+}
+#endregion
+#region From System.Object
+public override string ToString()
+{
+return URI;
+}
+public override int GetHashCode()
+{
+return URI.GetHashCode();
+}
+public override bool Equals( object aObject )
+{
+if ( aObject is CodeSource )
+{
+CodeSource other = (CodeSource) aObject;
+bool ret = ( string.Compare( other.URI, this.URI, StringComparison.CurrentCultureIgnoreCase ) == 0 );
+return ret;
+}
+//
+return base.Equals( aObject );
+}
+#endregion
+#region Data members
+private readonly CodeSourceProvider iProvider;
+private string iURI = string.Empty;
+private int iReferenceCount = 0;
+private TTimeToRead iTimeToRead = TTimeToRead.EReadWhenPriming;
+private CodeCollectionList iCollectionsAll = new CodeCollectionList();
+private CodeCollectionList iAlwaysActivatedCollections = new CodeCollectionList();
+private object iFlagsSyncRoot = new object();
+private TFlags iFlags = TFlags.EFlagsNone;
+#endregion
+}
+}