diff --git a/src/cdac/runtime-source.txt b/src/cdac/runtime-source.txt index 1e6379f8b2..f5844244c9 100644 --- a/src/cdac/runtime-source.txt +++ b/src/cdac/runtime-source.txt @@ -1 +1 @@ -d9a38d9d8b5660ff45d67cf52644a9be65372009 +ed0fb46706a7c6b99f62a0825871fa00855077cf diff --git a/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/StackWalk_1.cs b/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/StackWalk_1.cs index a9e17cdbf7..90b28f22c8 100644 --- a/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/StackWalk_1.cs +++ b/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/StackWalk_1.cs @@ -46,7 +46,19 @@ private record StackDataFrameHandle( private class StackWalkData(IPlatformAgnosticContext context, StackWalkState state, FrameIterator frameIter, ThreadData threadData) { - public IPlatformAgnosticContext Context { get; set; } = context; + private IPlatformAgnosticContext _context = context; + private IPlatformAgnosticContext? _callerContext; + + public IPlatformAgnosticContext Context + { + get => _context; + set + { + _context = value; + _callerContext = null; + } + } + public StackWalkState State { get; set; } = state; public FrameIterator FrameIter { get; set; } = frameIter; public ThreadData ThreadData { get; set; } = threadData; @@ -71,6 +83,32 @@ private class StackWalkData(IPlatformAgnosticContext context, StackWalkState sta // set IsInterrupted when transitioning to a managed frame. public FrameType? LastProcessedFrameType { get; set; } + public IPlatformAgnosticContext GetCallerContext(Target target) + { + if (_callerContext is null) + { + IPlatformAgnosticContext context = Context.Clone(); + context.Unwind(target); + _callerContext = context; + } + + return _callerContext; + } + + public void Unwind(Target target) + { + if (_callerContext is IPlatformAgnosticContext callerContext) + Context = callerContext; + else + Context.Unwind(target); + } + + public IPlatformAgnosticContext GetContextForUpdate() + { + _callerContext = null; + return Context; + } + public bool IsCurrentFrameResumable() { if (State is not (StackWalkState.Frame or StackWalkState.SkippedFrame)) @@ -846,13 +884,13 @@ private bool Next(StackWalkData handle) // This mirrors VirtualUnwindInterpreterCallFrame in eetwain.cpp. if (IsInterpreterCode(handle.Context.InstructionPointer)) { - _frameHelpers.InterpreterVirtualUnwind(handle.Context); + _frameHelpers.InterpreterVirtualUnwind(handle.GetContextForUpdate()); } else { try { - handle.Context.Unwind(_target); + handle.Unwind(_target); } catch { @@ -921,7 +959,7 @@ private bool Next(StackWalkData handle) if (returnAddress != TargetPointer.Null || frameType == FrameType.InterpreterFrame) { - handle.FrameIter.UpdateContextFromCurrentFrame(handle.Context); + handle.FrameIter.UpdateContextFromCurrentFrame(handle.GetContextForUpdate()); } // An active ICF is left current so CheckForSkippedFrames can pass it once the // walk reaches its managed caller. If its context is not managed code (e.g. no @@ -1029,8 +1067,7 @@ private bool CheckForSkippedFrames(StackWalkData handle) } // get the caller context - IPlatformAgnosticContext parentContext = handle.Context.Clone(); - parentContext.Unwind(_target); + IPlatformAgnosticContext parentContext = handle.GetCallerContext(_target); return handle.FrameIter.CurrentFrameAddress.Value < parentContext.StackPointer.Value; } diff --git a/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/EnumMemory/MemoryRegionEmitter.cs b/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/EnumMemory/MemoryRegionEmitter.cs index fc6de467df..311aef526f 100644 --- a/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/EnumMemory/MemoryRegionEmitter.cs +++ b/src/cdac/runtime/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/EnumMemory/MemoryRegionEmitter.cs @@ -17,7 +17,8 @@ internal sealed unsafe class MemoryRegionEmitter(nint callback, uint pointerSize // ICLRDataEnumMemoryRegionsCallback::EnumMemoryRegion follows the three IUnknown vtable slots. private readonly delegate* unmanaged[MemberFunction] _enumMemoryRegion = (delegate* unmanaged[MemberFunction])(*(nint**)callback)[3]; - private readonly List _metadataRanges = []; + // Both Start and End are inclusive. + private readonly List<(ulong Start, ulong End)> _metadataRanges = []; public int Result { get; private set; } @@ -50,23 +51,71 @@ public void Add(ulong address, ulong size) public void RegisterMetadataRange(TargetSpan range) { - if (range.Address != TargetPointer.Null && range.Size != 0) - _metadataRanges.Add(range); + ulong start = range.Address.Value; + if (start == 0 || range.Size == 0) + return; + + ulong end = checked(start + (range.Size - 1)); + int index = FindMetadataRangeIndex(start); + // Subtract from nonzero starts to merge adjacent ranges without overflowing an end. + if (index >= 0 && _metadataRanges[index].End >= start - 1) + { + if (_metadataRanges[index].End >= end) + // The current range already covers the new range. + return; + + // Merge with the current range by extending its end to cover the new range. + start = _metadataRanges[index].Start; + } + else + { + index++; + } + + int next = index; + while (next < _metadataRanges.Count && _metadataRanges[next].Start - 1 <= end) + { + end = Math.Max(end, _metadataRanges[next].End); + next++; + } + + if (next == index) + _metadataRanges.Insert(index, (start, end)); + else + { + _metadataRanges[index] = (start, end); + _metadataRanges.RemoveRange(index + 1, next - index - 1); + } } public bool ShouldEmitTargetRead(ulong address, ulong size) { - foreach (TargetSpan range in _metadataRanges) - { - if (address < range.Address.Value) - continue; + int index = FindMetadataRangeIndex(address); + if (index < 0) + return true; - ulong offset = address - range.Address.Value; - if (offset <= range.Size && size <= range.Size - offset) - return false; + ulong end = _metadataRanges[index].End; + if (size == 0) + return address > end && address - end > 1; + + return address > end || size - 1 > end - address; + } + + // Returns the last range whose start is <= address, or -1 if none. The caller must still check its end. + private int FindMetadataRangeIndex(ulong address) + { + int low = 0; + int high = _metadataRanges.Count; + while (low < high) + { + int middle = low + (high - low) / 2; + if (_metadataRanges[middle].Start <= address) + low = middle + 1; + else + high = middle; } - return true; + return low - 1; } public bool Update(ulong address, ReadOnlySpan buffer)