Refactor and optimize register allocator and live set computations

Source/.github/copilot-instructions.md

@@ -351,8 +351,12 @@ public class MyMethodStage : BaseMethodCompilerStage
 ### GC Safepoint infrastructure
 The safepoint system spans two stages:
 - `SafePointStage` (`BaseMethodCompilerStage`) -- inserts `IR.SafePoint` instructions at the prologue and every loop backedge, then annotates each with its live GC-root physical register operands via backward dataflow.
-- `SafePointLayoutStage` (`BaseMethodCompilerStage`, post-codegen) -- reads resolved offsets from the instruction stream, collects `SafePointEntry` records into `MethodData.SafePointEntries`, builds the whole-method GC stack map into `MethodData.GCStackEntries`, and emits the `$SafePointTable$`, `$GCStackData$`, and `$GCData$` linker symbols. `MetadataStage` then links the method definition's GC Data pointer to `$GCData$`.
+- `SafePointLayoutStage` (`BaseMethodCompilerStage`, post-codegen) -- reads resolved offsets from the instruction stream, collects `SafePointEntry` records into `MethodData.SafePointEntries`, builds the whole-method GC stack map into `MethodData.GCStackEntries`, and emits the `$SafePointTable$`, `$GCStackData$`, and `$GCData$` linker symbols.
 
-- @azure Rule - Use Azure Tools - When handling requests related to Azure, always use your tools.
-- @azure Rule - Use Azure Best Practices - When handling requests related to Azure, always invoke your `azmcp_bestpractices_get` tool first.
-- @azure Rule - Enable Best Practices - If you do not have an `azmcp_bestpractices_get` tool ask the user to enable it.
+---
+
+## Azure Tools Guidelines
+
+- **Use Azure Tools**: When handling requests related to Azure, always use your tools.
+- **Invoke Best Practices**: When handling requests related to Azure, always invoke your `azmcp_bestpractices_get` tool first.
+- **Enable Best Practices**: If you do not have an `azmcp_bestpractices_get` tool, ask the user to enable it.

Source/Mosa.Compiler.Framework.xUnit/DelayedIntervalTreeTests.cs

@@ -67,4 +67,357 @@ public void MixedAddDelete()
 		tree.Remove(3, 4);
 		Assert.False(tree.Contains(3));
 	}
+
+	[Fact]
+	public void CheckIntervals()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 2, null);
+
+		Assert.False(tree.Contains(0));
+		Assert.True(tree.Contains(1));
+		Assert.True(tree.Contains(2));
+
+		Assert.True(tree.Contains(2, 3));
+		Assert.False(tree.Contains(3, 4));
+	}
+
+	[Fact]
+	public void CacheDelayedAddShortCircuit()
+	{
+		// Verify that pending add is checked before flushing and accessing tree
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(10, 20, "pending");
+
+		// Should find pending add without touching tree
+		Assert.True(tree.Contains(10));
+		Assert.True(tree.Contains(15));
+		Assert.True(tree.Contains(20));
+		Assert.False(tree.Contains(21));
+		Assert.False(tree.Contains(9));
+
+		// Range check should also work with pending add
+		Assert.True(tree.Contains(10, 20));
+		Assert.True(tree.Contains(15, 18));
+		Assert.False(tree.Contains(25, 30));
+	}
+
+	[Fact]
+	public void CacheDelayedDeleteShortCircuit()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+		tree.Add(10, 15, "value2");
+
+		// Delay the delete
+		tree.Remove(1, 5);
+
+		// Pending delete should prevent Contains from returning true
+		Assert.False(tree.Contains(1));
+		Assert.False(tree.Contains(3));
+		Assert.False(tree.Contains(5));
+
+		// But other intervals should still be found
+		Assert.True(tree.Contains(10));
+		Assert.True(tree.Contains(12));
+	}
+
+	[Fact]
+	public void CacheAddCancelsByDelete()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(5, 10, "pending");
+
+		// Removing the pending add should cancel it
+		tree.Remove(5, 10);
+
+		// Should not find anything
+		Assert.False(tree.Contains(5));
+		Assert.False(tree.Contains(7));
+		Assert.False(tree.Contains(10));
+	}
+
+	[Fact]
+	public void CacheSearchFirstOverlappingWithPendingAdd()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(10, 20, "tree_value");
+
+		// Add pending interval
+		tree.Add(30, 40, "pending_value");
+
+		// Search should find pending add without flushing tree add
+		Assert.True(tree.TrySearchFirstOverlapping(30, 40, out var result));
+		Assert.Equal("pending_value", result);
+
+		// Search that only matches tree should also work
+		Assert.True(tree.TrySearchFirstOverlapping(10, 20, out result));
+		Assert.Equal("tree_value", result);
+	}
+
+	[Fact]
+	public void CacheSearchFirstOverlappingByPoint()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+		tree.Add(10, 20, "pending");
+
+		// Search by point should find pending without flushing
+		Assert.True(tree.TrySearchFirstOverlapping(15, out var result));
+		Assert.Equal("pending", result);
+
+		// Search point before pending
+		Assert.True(tree.TrySearchFirstOverlapping(3, out result));
+		Assert.Equal("value1", result);
+	}
+
+	[Fact]
+	public void CacheSearchRangeWithPendingAdd()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+		tree.Add(20, 30, "pending");
+
+		// Search range that overlaps pending
+		var results = tree.Search(25, 35);
+		Assert.Single(results);
+		Assert.Equal("pending", results[0]);
+
+		// Search range that doesn't overlap pending
+		results = tree.Search(1, 5);
+		Assert.Single(results);
+		Assert.Equal("value1", results[0]);
+
+		// Search range that overlaps both
+		results = tree.Search(3, 25);
+		Assert.Equal(2, results.Count);
+		Assert.Contains("value1", results);
+		Assert.Contains("pending", results);
+	}
+
+	[Fact]
+	public void CacheSearchPointWithPendingAdd()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+		tree.Add(20, 30, "pending");
+
+		// Search at point in pending
+		var results = tree.Search(25);
+		Assert.Single(results);
+		Assert.Equal("pending", results[0]);
+
+		// Search at point in tree value
+		results = tree.Search(3);
+		Assert.Single(results);
+		Assert.Equal("value1", results[0]);
+	}
+
+	[Fact]
+	public void CacheReplacePendingAdd()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(5, 10, "original");
+
+		// Replace the pending add
+		tree.Replace(5, 10, "replaced");
+
+		Assert.True(tree.TrySearchFirstOverlapping(7, out var result));
+		Assert.Equal("replaced", result);
+	}
+
+	[Fact]
+	public void CacheReplaceTreeValue()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(5, 10, "original");
+		tree.Add(20, 30, "pending");
+
+		// Replace value in tree (flush both pending ops first)
+		tree.Replace(5, 10, "replaced");
+
+		// Pending should be flushed
+		Assert.True(tree.Contains(25));
+
+		// Original should be replaced
+		Assert.True(tree.TrySearchFirstOverlapping(7, out var result));
+		Assert.Equal("replaced", result);
+	}
+
+	[Fact]
+	public void CacheMixedPendingOperations()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		// Add and then remove different intervals
+		tree.Add(5, 10, "add1");
+		tree.Add(20, 30, "add2");
+
+		// Remove first one while second is pending
+		tree.Remove(5, 10);
+
+		// First should not be found
+		Assert.False(tree.Contains(7));
+
+		// Second should be found (it's pending)
+		Assert.True(tree.Contains(25));
+
+		// Now remove the pending second
+		tree.Remove(20, 30);
+
+		// Both should be gone
+		Assert.False(tree.Contains(7));
+		Assert.False(tree.Contains(25));
+	}
+
+	[Fact]
+	public void CacheDeleteWithOverlapAddInteraction()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+
+		// Add pending interval
+		tree.Add(3, 7, "add_during_delete");
+
+		// Remove that overlaps the pending add (should cancel it)
+		tree.Remove(3, 7);
+
+		// The pending add was cancelled, so value1 should still be found
+		Assert.True(tree.Contains(1));
+		Assert.True(tree.Contains(5));
+
+		// Point 6 should not be found (value1 only goes to 5)
+		Assert.False(tree.Contains(6));
+	}
+
+	[Fact]
+	public void CacheSearchWithReplacedValue()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(10, 20, "value1");
+		tree.Add(30, 40, "pending");
+
+		// Replace tree value
+		tree.Replace(10, 20, "replaced1");
+
+		// Search should find replaced value
+		Assert.True(tree.TrySearchFirstOverlapping(15, out var result));
+		Assert.Equal("replaced1", result);
+	}
+
+	[Fact]
+	public void EnumeratorFlushesAllPending()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 2, "add1");
+		tree.Add(3, 4, "add2");
+
+		// Before enumeration, pending operations not flushed
+		tree.Remove(1, 2);
+
+		// Enumerate should flush both operations
+		var list = new List<object>();
+		foreach (var item in tree)
+		{
+			list.Add(item);
+		}
+
+		// Should only have add2 (add1 was removed)
+		Assert.Single(list);
+		Assert.Equal("add2", list[0]);
+	}
+
+	[Fact]
+	public void ToStringFlushesAllPending()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 2, "test");
+		tree.Add(3, 4, "pending");
+
+		// ToString should flush all pending operations
+		var str = tree.ToString();
+
+		// Should not be empty
+		Assert.NotEmpty(str);
+
+		// After ToString, tree should be in consistent state
+		// Adding more should work correctly
+		tree.Add(5, 6, "another");
+		Assert.True(tree.Contains(5));
+	}
+
+	[Fact]
+	public void EdgeCaseEmptyTree()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		Assert.False(tree.Contains(1));
+		Assert.False(tree.Contains(1, 2));
+
+		Assert.False(tree.TrySearchFirstOverlapping(1, out _));
+		Assert.False(tree.TrySearchFirstOverlapping(1, 2, out _));
+
+		var results = tree.Search(1);
+		Assert.Empty(results);
+
+		results = tree.Search(1, 2);
+		Assert.Empty(results);
+	}
+
+	[Fact]
+	public void EdgeCaseRemoveNonExistent()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 2, "value");
+
+		// Remove non-existent should be safe
+		tree.Remove(10, 20);
+
+		// Original should still be there
+		Assert.True(tree.Contains(1));
+	}
+
+	[Fact]
+	public void SearchWithCallerProvidedList()
+	{
+		var tree = new DelayedIntervalTree<object>();
+
+		tree.Add(1, 5, "value1");
+		tree.Add(10, 20, "pending");
+
+		var results = new List<object>();
+
+		// Search by point with provided list
+		tree.Search(3, results);
+		Assert.Single(results);
+		Assert.Equal("value1", results[0]);
+
+		results.Clear();
+
+		// Search by range with provided list
+		tree.Search(10, 20, results);
+		Assert.Single(results);
+		Assert.Equal("pending", results[0]);
+
+		results.Clear();
+
+		// Search overlapping both
+		tree.Search(3, 15, results);
+		Assert.Equal(2, results.Count);
+	}
 }

Source/Mosa.Compiler.Framework/CompilerHooks.cs

@@ -50,4 +50,23 @@ public class CompilerHooks
 	public ExtendMethodCompilerPipelineHandler ExtendMethodCompilerPipeline;
 
 	public GetMethodTraceLevelHandler GetMethodTraceLevel;
+
+	#region Standardization
+
+	public static string GetStandardNotifyEventStatus(CompilerEvent compilerEvent, string message)
+	{
+		var eventName = compilerEvent.ToText();
+		return string.IsNullOrWhiteSpace(message) ? eventName : $"{eventName}: {message}";
+	}
+
+	public static bool IsStandardFilteredNotifyEvent(CompilerEvent compilerEvent)
+		=> compilerEvent is CompilerEvent.MethodCompileEnd
+			or CompilerEvent.MethodCompileStart
+			or CompilerEvent.Counter
+			or CompilerEvent.SetupStageStart
+			or CompilerEvent.SetupStageEnd
+			or CompilerEvent.FinalizationStageStart
+			or CompilerEvent.FinalizationStageEnd;
+
+	#endregion Standardization
 }