FCL/sftools/ana/dynaanamdw/crashmdw: comparison crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianStructuresLib/Debug/Symbols/Utilities/SymbolCollectionHarmoniser.cs

equal deleted inserted replaced

--1:000000000000
+:818e61de6cd1
+/*
+* 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;
+using SymbianStructuresLib.MemoryModel;
+namespace SymbianStructuresLib.Debug.Symbols.Utilities
+{
+public class SymbolCollectionHarmoniser : DisposableObject
+{
+#region Enumerations
+public enum TCollectionType
+{
+EXIP = 0,
+ENotXIP,
+EPossiblyXIP
+}
+#endregion
+#region Constructors
+public SymbolCollectionHarmoniser( SymbolCollection aCollection )
+: this( aCollection, TCollectionType.ENotXIP )
+{
+}
+public SymbolCollectionHarmoniser( SymbolCollection aCollection, TCollectionType aType )
+{
+iCollection = aCollection;
+iType = aType;
+// If the collection is not XIP, then we can definitely say it is relocatable
+if ( aType == TCollectionType.ENotXIP )
+{
+iCollection.IsFixed = false;
+}
+else if ( aType == TCollectionType.EXIP )
+{
+iCollection.IsFixed = true;
+}
+}
+#endregion
+#region API
+public bool Add( Symbol aSymbol )
+{
+Debug( aSymbol );
+// Perform pre-filter, which might currently include a blanket ban
+// on new symbols for this collection
+bool save = PreFilterBasedUponFlags( aSymbol );
+if ( save )
+{
+// Flags indicate we can accept the symbol, so perform
+// normal checks based upon symbol meta-data
+Symbol last = this.LastSymbol;
+if ( last != null && !last.IsDefault )
+{
+if ( aSymbol.Size == 0 )
+{
+save = ShouldSaveWhenNewSymbolHasNoSize( last, aSymbol );
+}
+else
+{
+save = ShouldSaveWhenNewSymbolHasValidSize( last, aSymbol );
+}
+}
+//
+if ( save )
+{
+Collection.Add( aSymbol );
+}
+}
+// Perform any final updates
+PostFilterBasedUponFlags( aSymbol );
+//
+return save;
+}
+#endregion
+#region Properties
+public bool DisallowSymbolsOnceReadOnlyLimitReached
+{
+get
+{
+bool disallow = false;
+// We can only do this once we have one non-default symbol and after
+// we have set the base address.
+if ( ( iFlags & TFlags.EFlagsHaveSetXIPBaseAddress ) == TFlags.EFlagsHaveSetXIPBaseAddress )
+{
+bool isEmpty = Collection.IsEmptyApartFromDefaultSymbol;
+if ( !isEmpty )
+{
+Symbol first = Collection.FirstSymbol;
+disallow = ( first.Address == 0 );
+}
+}
+//
+return disallow;
+}
+}
+#endregion
+#region Internal enumerations
+[Flags]
+private enum TFlags
+{
+EFlagsNone = 0,
+EFlagsUpdateLengthOfPreviousSymbol = 1,
+EFlagsDisallowFurtherSymbolsForCollection = 2,
+EFlagsHaveSetXIPBaseAddress = 4,
+}
+#endregion
+#region Internal constants
+private const uint KMaxAutomaticLengthUpdateDelta = 4 * 1024 * 1024;
+private const string KSectionNameMarker = "$$";
+private const string KSectionNameUserBase = "Image$$ER_RO$$Base";
+private const string KSectionNameUserLimit = "Image$$ER_RO$$Limit";
+#endregion
+#region Internal properties
+private SymbolCollection Collection
+{
+get { return iCollection; }
+}
+private Symbol LastSymbol
+{
+get
+{
+Symbol ret = null;
+//
+if ( Collection.Count > 0 )
+{
+ret = Collection.LastSymbol;
+}
+//
+return ret;
+}
+}
+#endregion
+#region Internal methods
+private void Debug( Symbol aSymbol )
+{
+}
+private bool PreFilterBasedUponFlags( Symbol aSymbol )
+{
+// Do we need to update the length of the previous symbol?
+if ( ( iFlags & TFlags.EFlagsUpdateLengthOfPreviousSymbol ) == TFlags.EFlagsUpdateLengthOfPreviousSymbol )
+{
+FlagBasedUpdateOfLastSymbolLength( aSymbol );
+}
+// Check for Image$$ER_RO$$Base
+// This symbol is emitted for user-side code and can be used to work around some maksym problems.
+string symbolName = aSymbol.Name;
+if ( symbolName == KSectionNameUserBase )
+{
+int count = iCollection.Count;
+if ( !iCollection.IsEmptyApartFromDefaultSymbol )
+{
+// Discard all the entries we've seen so far because most likely
+// they are invalid.
+System.Diagnostics.Debug.WriteLine( string.Format( "Discarding {0} invalid symbols for library: {1}", count, iCollection.FileName ) );
+iCollection.Clear();
+// At this point, we need to reset the base address because any symbols that have gone
+// before are invalid.
+iFlags &= ~TFlags.EFlagsHaveSetXIPBaseAddress;
+}
+}
+// Do we need to set the base address for the symbol collection?
+bool haveSetXIPBase = ( ( iFlags & TFlags.EFlagsHaveSetXIPBaseAddress ) == TFlags.EFlagsHaveSetXIPBaseAddress );
+if ( !haveSetXIPBase && iType != TCollectionType.ENotXIP )
+{
+// If we're seeing the first valid symbol, then try to set the base address
+bool needToSet = true;
+if ( iType == TCollectionType.EPossiblyXIP )
+{
+// Perhaps we're dealing with an XIP collection. In which case, we need to check
+// with the memory model utility to decide if it really is or not.
+//
+// If the symbol address is zero (NULL), then we can't be dealing with an
+// XIP collection.
+if ( aSymbol.Address == 0 )
+{
+// ROFS
+needToSet = true;
+}
+else
+{
+TMemoryModelRegion region = MMUtilities.RegionByAddress( aSymbol.Address );
+needToSet = ( region == TMemoryModelRegion.EMemoryModelRegionROM );
+}
+}
+if ( needToSet )
+{
+SetCollectionBaseAddress( aSymbol );
+}
+}
+bool disallowNewSymbols = ( iFlags & TFlags.EFlagsDisallowFurtherSymbolsForCollection ) == TFlags.EFlagsDisallowFurtherSymbolsForCollection;
+return !disallowNewSymbols;
+}
+private void PostFilterBasedUponFlags( Symbol aSymbol )
+{
+string symbolName = aSymbol.Name;
+if ( symbolName.Contains( KSectionNameMarker ) )
+{
+if ( symbolName == KSectionNameUserLimit )
+{
+// User data follows - don't update length of previous symbol
+iFlags &= ~TFlags.EFlagsUpdateLengthOfPreviousSymbol;
+// If we're reading a ROFS symbol then most likely we don't want
+// to allow any more entries since they start to be a little wacky...
+bool disallow = this.DisallowSymbolsOnceReadOnlyLimitReached;
+if ( disallow )
+{
+iFlags |= TFlags.EFlagsDisallowFurtherSymbolsForCollection;
+}
+}
+else if ( symbolName.Contains( "$$Limit" ) )
+{
+// Don't change the length of a limit symbol should we happen to encounter a data item.
+iFlags &= ~TFlags.EFlagsUpdateLengthOfPreviousSymbol;
+}
+}
+}
+/// <summary>
+/// Called when the new proposed symbol has no size.
+/// </summary>
+private bool ShouldSaveWhenNewSymbolHasNoSize( Symbol aLastSymbol, Symbol aNewSymbol )
+{
+bool save = true;
+//
+if ( aLastSymbol.Contains( aNewSymbol.Address ) )
+{
+// The new symbol overlaps the previous one. Additionally, the new symbol has a size of zero.
+//
+// E.g. #1:
+//
+//  _E32Dll                                         0x00008000   ARM Code      40  uc_dll_.o(.emb_text)
+//  Symbian$$CPP$$Exception$$Descriptor             0x00008014   Data           0  uc_dll_.o(.emb_text)
+//
+// E.g. #2:
+//
+//  RArray<unsigned long>::RArray()                 0x00009289   Thumb Code    10  abcd.in(t._ZN6RArrayImEC1Ev)
+//  RArray<unsigned long>::RArray__sub_object()     0x00009289   Thumb Code     0  abcd.in(t._ZN6RArrayImEC1Ev)
+//
+//      => NEW SYMBOL IS DISCARDED
+//
+save = false;
+}
+else if ( aNewSymbol.Address > aLastSymbol.EndAddress )
+{
+// The new symbol has a size of zero, but it doesn't overlap with prior symbol address.
+//
+//             _E32Dll_Body                             0x00008ecd   Thumb Code    34  uc_dll.o(.text)
+//             __DLL_Export_Table__                     0x00008f5c   ARM Code       0  abcd{000a0000}.exp(ExportTable)
+//             DLL##ExportTableSize                     0x00008f60   Data           0  abcd{000a0000}.exp(ExportTable)
+//             DLL##ExportTable                         0x00008f64   Data           0  abcd{000a0000}.exp(ExportTable)
+//             CActive::Cancel()                        0x00008f9c   ARM Code       0  euser{000a0000}-1088.o(StubCode)
+// aSymbol ==> CActive::SetActive()                     0x00008fa4   ARM Code       0  euser{000a0000}-1090.o(StubCode)
+//             CActive::CActive__sub_object(int)        0x00008fac   ARM Code       0  euser{000a0000}-1091.o(StubCode)
+//             CActive::~CActive__sub_object()          0x00008fb4   ARM Code       0  euser{000a0000}-1094.o(StubCode)
+//             RArrayBase::At(int) const                0x00008fbc   ARM Code       0  euser{000a0000}-1507.o(StubCode)
+//
+//      => NEW SYMBOL IS SAVED
+//
+iFlags |= TFlags.EFlagsUpdateLengthOfPreviousSymbol;
+}
+//
+return save;
+}
+/// <summary>
+/// Called when the new symbol has a valid size
+/// </summary>
+private bool ShouldSaveWhenNewSymbolHasValidSize( Symbol aLastSymbol, Symbol aNewSymbol )
+{
+bool save = true;
+if ( aLastSymbol.Contains( aNewSymbol.Address ) )
+{
+// The new symbol and the last symbol somehow overlap.
+if ( aLastSymbol.Address == aNewSymbol.Address && aLastSymbol.Size == aNewSymbol.Size )
+{
+// The symbols start at the same address:
+//
+// E.g. #1:
+//
+//      CABCMonitor::~CABCMonitor()              0x000091a5   Thumb Code     0  abcmonitor.in(i._ZN11CABCMonitorD2Ev)
+//      CABCMonitor::~CABCMonitor__sub_object()  0x000091a5   Thumb Code     8  abcmonitor.in(i._ZN11CABCMonitorD2Ev)
+//
+// E.g. #2:
+//
+//      8022ab10    0060    Math::DivMod64(long long, long long, long long&)
+//      8022ab70    0014    Math::UDivMod64(unsigned long long, unsigned long long, unsigned long long&)
+//      8022ab84    0000    $v0
+// >>>  8022ab84    0018    TRealX::Set(int)
+//      8022ab9c    0044    TRealX::operator =(int)
+//
+// For example #1, we want to discard the new symbol and keep the original.
+// For example #2, we want to discard the original symbol and keep the new one.
+//
+//
+if ( !aLastSymbol.IsFunction )
+{
+// E.g. #2 => discard old symbol
+Collection.RemoveAt( Collection.Count - 1 );
+}
+else
+{
+// E.g. #1 => discard new symbol
+save = false;
+}
+}
+else if ( aLastSymbol.Address == aNewSymbol.Address && aLastSymbol.Size == 0 )
+{
+// E.g. :
+//
+//      8342d6b8    0000    Image$$ER_RO$$Base                       anon$$obj.o(linker$$defined$$symbols)
+// >>>  8342d6b8    0070    _E32Startup                              uc_exe_.o(.emb_text)
+//
+Collection.RemoveAt( Collection.Count - 1 );
+}
+else
+{
+// The symbols start at different addresses, but somehow they still overlap.
+//
+// E.g.:
+//
+//    typeinfo name for CABCMonitorCapMapper   0x000094a8   Data          23  accmonitor.in(.constdata__ZTS20CABCMonitorCapMapper)
+//    typeinfo name for CABCMonitorContainer   0x000094bf   Data          23  accmonitor.in(.constdata__ZTS20CABCMonitorContainer)
+//
+// In this scenario, the size of the 0x94a8 entry (23 bytes) causes it's address to overlap
+// with the first byte from the entry starting at 0x94bf.
+//
+// In this scenario, we make an assumption that the size of the 0x94A8 entry is incorrect/invalid
+uint overlap = aLastSymbol.AddressRange.Max - aNewSymbol.Address + 1;
+aLastSymbol.Size = aLastSymbol.Size - overlap;
+}
+}
+else
+{
+if ( aLastSymbol.Address > aNewSymbol.Address )
+{
+}
+}
+//
+return save;
+}
+private void FlagBasedUpdateOfLastSymbolLength( Symbol aSymbol )
+{
+System.Diagnostics.Debug.Assert( ( iFlags & TFlags.EFlagsUpdateLengthOfPreviousSymbol ) == TFlags.EFlagsUpdateLengthOfPreviousSymbol );
+bool clearFlag = true;
+// Don't set the length of the default symbol!
+if ( !Collection.IsEmptyApartFromDefaultSymbol )
+{
+// Must have some existing symbol.
+int count = Collection.Count;
+System.Diagnostics.Debug.Assert( count > 0 );
+// Last symbol must have bad size?
+Symbol previousSymbol = LastSymbol;
+System.Diagnostics.Debug.Assert( previousSymbol.Size == 0 );
+// The new symbol must be exactly the same address as the last symbol
+// (in which case, the new symbol must have a valid size or else we're
+// unable to do anything sensible with it)
+//
+// OR
+//
+// The new symbol must be after the last symbol. It cannot be before.
+if ( aSymbol.Address < previousSymbol.Address )
+{
+// Data can confuse us, so skip when the address is earlier. E.g.:
+//
+//    83409b88    0000    .ARM.exidx$$Base                          uc_exe_.o(.ARM.exidx)
+//    83409f80    0000    .ARM.exidx$$Limit                         xxx.in(.ARM.exidx)
+//    83409f80    0000    Image$$ER_RO$$Limit                       anon$$obj.o(linker$$defined$$symbols)
+// >> 00400000    0008    AllCapabilities                           xxx.in(.data)
+//    00400008    0008    DisabledCapabilities                      xxx.in(.data)
+//
+clearFlag = true;
+}
+else
+{
+if ( aSymbol.Address == previousSymbol.Address )
+{
+if ( aSymbol.Size > 0 )
+{
+// Okay, the new symbol has a valid size, the old one didn't.
+previousSymbol.Size = aSymbol.Size;
+}
+else
+{
+// Hmm, neither the last or new symbol have a valid size.
+// Nothing we can do in this case...
+clearFlag = false;
+}
+}
+else
+{
+// Need to work out the length of the previous symbol by comparing the
+// address of this symbol against it.
+uint delta = aSymbol.Address - previousSymbol.Address;
+if ( delta > KMaxAutomaticLengthUpdateDelta )
+{
+// The delta is huge. Don't allow this kind of update.
+}
+else if ( delta > 1 )
+{
+// It's okay, this symbol had a later address than the last one
+// This is normal.
+previousSymbol.Size = delta - 1;
+}
+else
+{
+// This is not good. Two symbols both have the same address. In this
+// situation discard the old symbol and take the new one instead because
+// in all aspects other than name, they are identical.
+Collection.RemoveAt( count - 1 );
+}
+}
+}
+}
+if ( clearFlag )
+{
+iFlags &= ~TFlags.EFlagsUpdateLengthOfPreviousSymbol;
+}
+}
+private void SetCollectionBaseAddress( Symbol aSymbolToUse )
+{
+uint baseAddress = aSymbolToUse.Address;
+bool haveSet = ( iFlags & TFlags.EFlagsHaveSetXIPBaseAddress ) == TFlags.EFlagsHaveSetXIPBaseAddress;
+System.Diagnostics.Debug.Assert( haveSet == false );
+// Relocate (changes base address)
+iCollection.Relocate( baseAddress );
+iFlags |= TFlags.EFlagsHaveSetXIPBaseAddress;
+// The symbol address needs to be reset to zero (i.e. start of collection)
+uint symbolSize = aSymbolToUse.Size;
+aSymbolToUse.OffsetAddress = 0;
+}
+#endregion
+#region From DisposableObject
+protected override void CleanupManagedResources()
+{
+try
+{
+base.CleanupManagedResources();
+}
+finally
+{
+// When we aren't sure if we're being used to harmonise an XIP collection
+// we must check whether the base address has been set to something other than
+// zero and that the address is in the XIP range.
+// NB: Other cases are handled in the constructor.
+if ( iType == TCollectionType.EPossiblyXIP )
+{
+if ( !iCollection.IsEmptyApartFromDefaultSymbol )
+{
+Symbol first = iCollection.FirstSymbol;
+uint address = first.Address;
+if ( address > 0 )
+{
+TMemoryModelRegion region = MMUtilities.RegionByAddress( address );
+bool isFixed = ( region == TMemoryModelRegion.EMemoryModelRegionROM );
+iCollection.IsFixed = isFixed;
+}
+else
+{
+// First address is zero, indicates RAM-loaded code and therefore
+// non-XIP.
+iCollection.IsFixed = false;
+}
+}
+else
+{
+// The collection only contains the default symbol so in that case
+// it can be thought to be relocatable (although in practise that wouldn't
+// be very helpful). The main point is that we don't want this collection
+// to start matching null addresses (quite common when performing symbolic
+// lookup).
+iCollection.IsFixed = false;
+}
+}
+}
+}
+#endregion
+#region Data members
+private readonly SymbolCollection iCollection;
+private readonly TCollectionType iType;
+private TFlags iFlags = TFlags.EFlagsNone;
+#endregion
+}
+}