Fix CfgCpu messing up graph on external interruptions. Make interrupt vector table a memory based array.

src/Spice86.Core/Emulator/CPU/CfgCpu/CfgCpu.cs

@@ -18,17 +18,18 @@ public class CfgCpu : IInstructionExecutor {
  private readonly InstructionExecutionHelper _instructionExecutionHelper;
  private readonly State _state;
  private readonly DualPic _dualPic;
- private readonly ExecutionContextManager _executionContextManager;
-
  private readonly CfgNodeFeeder _cfgNodeFeeder;
+ private readonly ExecutionContextManager _executionContextManager;
+ private readonly InstructionReplacerRegistry _replacerRegistry = new();
 
  public CfgCpu(IMemory memory, State state, IOPortDispatcher ioPortDispatcher, CallbackHandler callbackHandler,
  DualPic dualPic, EmulatorBreakpointsManager emulatorBreakpointsManager, ILoggerService loggerService) {
  _instructionExecutionHelper = new(state, memory, ioPortDispatcher, callbackHandler, loggerService);
  _state = state;
  _dualPic = dualPic;
- _executionContextManager = new(emulatorBreakpointsManager);
- _cfgNodeFeeder = new(memory, state, emulatorBreakpointsManager);
+
+ _cfgNodeFeeder = new(memory, state, emulatorBreakpointsManager, _replacerRegistry);
+ _executionContextManager = new(emulatorBreakpointsManager, _cfgNodeFeeder, _replacerRegistry);
  }
 
  public ExecutionContextManager ExecutionContextManager => _executionContextManager;
@@ -56,6 +57,13 @@ public void ExecuteNext() {
  CurrentExecutionContext.NodeToExecuteNextAccordingToGraph = nextToExecute;
  HandleExternalInterrupt();
  }
+
+ /// <summary>
+ /// Signal to the cfg cpu that we are at the entry point of the program
+ /// </summary>
+ public void SignalEntry() {
+ _executionContextManager.SignalNewExecutionContext(_state.IpSegmentedAddress, null);
+ }
 
  private void HandleExternalInterrupt() {
  if (!_state.InterruptFlag) {

src/Spice86.Core/Emulator/CPU/CfgCpu/ExecutionContextManager.cs

@@ -1,43 +1,61 @@
 namespace Spice86.Core.Emulator.CPU.CfgCpu;
 
+using Spice86.Core.Emulator.CPU.CfgCpu.ControlFlowGraph;
+using Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 using Spice86.Core.Emulator.CPU.CfgCpu.Linker;
+using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction;
 using Spice86.Core.Emulator.VM;
 using Spice86.Core.Emulator.VM.Breakpoint;
 using Spice86.Shared.Emulator.Memory;
 
-public class ExecutionContextManager {
+public class ExecutionContextManager : InstructionReplacer {
  private readonly EmulatorBreakpointsManager _emulatorBreakpointsManager;
- private readonly Dictionary<uint, ExecutionContext> _executionContextEntryPoints = new();
-
- public ExecutionContextManager(EmulatorBreakpointsManager emulatorBreakpointsManager) {
+ private readonly Dictionary<SegmentedAddress, ISet<ICfgNode>> _executionContextEntryPoints = new();
+ private readonly CfgNodeFeeder _cfgNodeFeeder;
+ private int _currentDepth;
+
+ public ExecutionContextManager(EmulatorBreakpointsManager emulatorBreakpointsManager, CfgNodeFeeder cfgNodeFeeder,
+ InstructionReplacerRegistry replacerRegistry) : base(replacerRegistry) {
  _emulatorBreakpointsManager = emulatorBreakpointsManager;
+ _cfgNodeFeeder = cfgNodeFeeder;
  // Initial context at init
- CurrentExecutionContext = new();
- InitialExecutionContext = CurrentExecutionContext;
+ CurrentExecutionContext = new(_currentDepth);
  }
-
- public ExecutionContext InitialExecutionContext { get; }
 
  public ExecutionContext CurrentExecutionContext { get; private set; }
 
  public void SignalNewExecutionContext(SegmentedAddress entryAddress, SegmentedAddress? expectedReturnAddress) {
- uint physicalEntryAddress = entryAddress.ToPhysical();
- if (!_executionContextEntryPoints.TryGetValue(physicalEntryAddress, out ExecutionContext? executionContext)) {
- executionContext = new ExecutionContext();
- _executionContextEntryPoints.Add(entryAddress.ToPhysical(), executionContext);
- }
- // Reset the execution context so that nodes it last executed are not linked to the new ones that will come
- executionContext.LastExecuted = null;
- executionContext.NodeToExecuteNextAccordingToGraph = null;
+ // Save current execution context
  ExecutionContext previousExecutionContext = CurrentExecutionContext;
- CurrentExecutionContext = executionContext;
+ // Create a new one at a higher depth
+ _currentDepth++;
+ CurrentExecutionContext = new(_currentDepth);
  if (expectedReturnAddress != null) {
  // breakpoint that deletes itself on reach. Should be triggered when the return address is reached and before it starts execution.
  _emulatorBreakpointsManager.ToggleBreakPoint(new AddressBreakPoint(BreakPointType.EXECUTION, expectedReturnAddress.Value.ToPhysical(), (_) => {
- // Restore previous execution context
+ // Restore previous execution context and depth
  CurrentExecutionContext = previousExecutionContext;
+ _currentDepth--;
  }, true), true);
  }
+
+ RegisterCurrentInstructionAsEntryPoint(entryAddress);
+ }
+
+ private void RegisterCurrentInstructionAsEntryPoint(SegmentedAddress entryAddress) {
+ // Register a new entry point
+ ICfgNode toExecute = _cfgNodeFeeder.GetLinkedCfgNodeToExecute(CurrentExecutionContext);
+ if (!_executionContextEntryPoints.TryGetValue(entryAddress, out ISet<ICfgNode>? nodes)) {
+ nodes = new HashSet<ICfgNode>();
+ _executionContextEntryPoints.Add(entryAddress, nodes);
+ }
+ nodes.Add(toExecute);
  }
 
+ public override void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
+ if (_executionContextEntryPoints.TryGetValue(instruction.Address, out ISet<ICfgNode>? entriesAtAddress) 
+ && entriesAtAddress.Remove(old)) {
+ entriesAtAddress.Add(instruction);
+ }
+ }
 }

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/CfgNodeFeeder.cs

@@ -1,14 +1,13 @@
 namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 
 using Spice86.Core.Emulator.CPU.CfgCpu.ControlFlowGraph;
+using Spice86.Core.Emulator.CPU.CfgCpu.Exceptions;
 using Spice86.Core.Emulator.CPU.CfgCpu.Linker;
 using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction;
 using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction.SelfModifying;
 using Spice86.Core.Emulator.Memory;
 using Spice86.Core.Emulator.VM;
 
-using System.Linq;
-
 /// <summary>
 /// Handles coherency between the memory and the graph of instructions executed by the CPU.
 /// Next node to execute is normally the next node from the graph but several checks are done to make sure it is really it:
@@ -20,14 +19,15 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 public class CfgNodeFeeder {
  private readonly State _state;
  private readonly InstructionsFeeder _instructionsFeeder;
- private readonly NodeLinker _nodeLinker = new();
+ private readonly NodeLinker _nodeLinker;
  private readonly DiscriminatorReducer _discriminatorReducer;
 
- public CfgNodeFeeder(IMemory memory, State state, EmulatorBreakpointsManager emulatorBreakpointsManager) {
+ public CfgNodeFeeder(IMemory memory, State state, EmulatorBreakpointsManager emulatorBreakpointsManager,
+ InstructionReplacerRegistry replacerRegistry) {
  _state = state;
- _instructionsFeeder = new(emulatorBreakpointsManager, memory, state);
- _discriminatorReducer = new(new List<IInstructionReplacer<CfgInstruction>>()
-  { _nodeLinker, _instructionsFeeder });
+ _instructionsFeeder = new(emulatorBreakpointsManager, memory, state, replacerRegistry);
+ _nodeLinker = new(replacerRegistry);
+ _discriminatorReducer = new(replacerRegistry);
  }
 
  private CfgInstruction CurrentNodeFromInstructionFeeder =>
@@ -61,6 +61,11 @@ private ICfgNode DetermineToExecute(ICfgNode? currentFromGraph) {
  return currentFromGraph;
  }
 
+ if (fromMemory.Address != currentFromGraph.Address) {
+ // should never happen
+ throw new UnhandledCfgDiscrepancyException("Nodes from memory and from graph don't have the same address. This should never happen.");
+ }
+
  // Graph and memory are not aligned ... Need to inject Node with discriminator
  // If previous was Discriminated and current was not in its successors we would not be there because 
  // currentFromGraph would have been null and the linker would then link it to DiscriminatedNode

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/CurrentInstructions.cs

@@ -10,25 +10,24 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 /// Cache of current instructions in memory.
 /// Cache coherency is managed by breakpoints, as soon as an instruction is written in memory it is evicted.
 /// </summary>
-public class CurrentInstructions : IInstructionReplacer<CfgInstruction> {
+public class CurrentInstructions : InstructionReplacer {
  private readonly IMemory _memory;
  private readonly EmulatorBreakpointsManager _emulatorBreakpointsManager;
 
  /// <summary>
  /// Instruction currently known to be in memory at a given address.
  /// Memory write breakpoints invalidate this cache when CPU writes there.
  /// </summary>
- private readonly Dictionary<SegmentedAddress, CfgInstruction> _currentInstructionAtAddress =
- new Dictionary<SegmentedAddress, CfgInstruction>();
+ private readonly Dictionary<SegmentedAddress, CfgInstruction> _currentInstructionAtAddress = new();
 
 
  /// <summary>
  /// Breakpoints that have been installed to monitor instruction at a given address. So that we can reset them when we want.
  /// </summary>
- private readonly Dictionary<SegmentedAddress, List<AddressBreakPoint>> _breakpointsForInstruction =
- new Dictionary<SegmentedAddress, List<AddressBreakPoint>>();
+ private readonly Dictionary<SegmentedAddress, List<AddressBreakPoint>> _breakpointsForInstruction = new();
 
- public CurrentInstructions(IMemory memory, EmulatorBreakpointsManager emulatorBreakpointsManager) {
+ public CurrentInstructions(IMemory memory, EmulatorBreakpointsManager emulatorBreakpointsManager,
+ InstructionReplacerRegistry replacerRegistry) : base(replacerRegistry) {
  _memory = memory;
  _emulatorBreakpointsManager = emulatorBreakpointsManager;
  }
@@ -38,7 +37,7 @@ public CurrentInstructions(IMemory memory, EmulatorBreakpointsManager emulatorBr
  return res;
  }
 
- public void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
+ public override void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
  SegmentedAddress instructionAddress = instruction.Address;
  if (_currentInstructionAtAddress.ContainsKey(instructionAddress)) {
  ClearCurrentInstruction(old);

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/DiscriminatorReducer.cs

@@ -5,10 +5,10 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 using System.Linq;
 
 public class DiscriminatorReducer {
- private readonly IList<IInstructionReplacer<CfgInstruction>> _instructionReplacers;
+ private readonly InstructionReplacerRegistry _replacerRegistry;
 
- public DiscriminatorReducer(IList<IInstructionReplacer<CfgInstruction>> instructionReplacers) {
- _instructionReplacers = instructionReplacers;
+ public DiscriminatorReducer(InstructionReplacerRegistry replacerRegistry) {
+ _replacerRegistry = replacerRegistry;
  }
 
  private static Dictionary<Type, List<CfgInstruction>> GroupByType(List<CfgInstruction> instructions) {
@@ -98,9 +98,7 @@ private void ReplaceWithReference(CfgInstruction reference, IList<CfgInstruction
  continue;
  }
 
- foreach (var instructionReplacer in _instructionReplacers) {
- instructionReplacer.ReplaceInstruction(instruction, reference);
- }
+ _replacerRegistry.ReplaceInstruction(instruction, reference);
  }
  }
 

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/IInstructionReplacer.cs

@@ -1,7 +1,7 @@
 namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 
-using Spice86.Core.Emulator.CPU.CfgCpu.ControlFlowGraph;
+using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction;
 
-public interface IInstructionReplacer<in T> where T : ICfgNode {
- void ReplaceInstruction(T old, T instruction);
+public interface IInstructionReplacer {
+ void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction);
 }

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/InstructionReplacer.cs

@@ -0,0 +1,10 @@
+namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
+
+using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction;
+
+public abstract class InstructionReplacer : IInstructionReplacer {
+ protected InstructionReplacer(InstructionReplacerRegistry replacerRegistry) {
+ replacerRegistry.Register(this);
+ }
+ public abstract void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction);
+}

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/InstructionReplacerRegistry.cs

@@ -0,0 +1,17 @@
+namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
+
+using Spice86.Core.Emulator.CPU.CfgCpu.ParsedInstruction;
+
+public class InstructionReplacerRegistry : IInstructionReplacer {
+ private List<InstructionReplacer> _replacers = new();
+
+ public void Register(InstructionReplacer replacer) {
+ _replacers.Add(replacer);
+ }
+
+ public void ReplaceInstruction(CfgInstruction old, CfgInstruction newInstruction) {
+ foreach (InstructionReplacer instructionReplacer in _replacers) {
+ instructionReplacer.ReplaceInstruction(old, newInstruction);
+ }
+ }
+}

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/InstructionsFeeder.cs

@@ -14,15 +14,16 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 /// If an instruction is modified and then put back in its original version, it is the original instance of the parsed instruction that will be returned for the address
 /// Instructions can be replaced in the cache (see method ReplaceInstruction)
 /// </summary>
-public class InstructionsFeeder : IInstructionReplacer<CfgInstruction> {
+public class InstructionsFeeder {
  private readonly InstructionParser _instructionParser;
  private readonly CurrentInstructions _currentInstructions;
  private readonly PreviousInstructions _previousInstructions;
 
- public InstructionsFeeder(EmulatorBreakpointsManager emulatorBreakpointsManager, IMemory memory, State cpuState) {
- _currentInstructions = new(memory, emulatorBreakpointsManager);
+ public InstructionsFeeder(EmulatorBreakpointsManager emulatorBreakpointsManager, IMemory memory, State cpuState,
+ InstructionReplacerRegistry replacerRegistry) {
+ _currentInstructions = new(memory, emulatorBreakpointsManager, replacerRegistry);
  _instructionParser = new(memory, cpuState);
- _previousInstructions = new(memory);
+ _previousInstructions = new(memory, replacerRegistry);
  }
 
  public CfgInstruction GetInstructionFromMemory(SegmentedAddress address) {
@@ -48,9 +49,4 @@ public CfgInstruction GetInstructionFromMemory(SegmentedAddress address) {
  _previousInstructions.AddInstructionInPrevious(parsed);
  return parsed;
  }
-
- public void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
- _currentInstructions.ReplaceInstruction(old, instruction);
- _previousInstructions.ReplaceInstruction(old, instruction);
- }
 }

src/Spice86.Core/Emulator/CPU/CfgCpu/Feeder/PreviousInstructions.cs

@@ -7,15 +7,16 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Feeder;
 /// <summary>
 /// Cache of previous instructions that existed in a memory address at a time.
 /// </summary>
-public class PreviousInstructions : IInstructionReplacer<CfgInstruction> {
+public class PreviousInstructions : InstructionReplacer {
  private readonly MemoryInstructionMatcher _memoryInstructionMatcher;
 
  /// <summary>
  /// Instructions that were parsed at a given address. List for address is ordered by instruction decreasing length
  /// </summary>
  private readonly Dictionary<SegmentedAddress, HashSet<CfgInstruction>> _previousInstructionsAtAddress = new();
 
- public PreviousInstructions(IMemory memory) {
+ public PreviousInstructions(IMemory memory, InstructionReplacerRegistry replacerRegistry) : base(
+ replacerRegistry) {
  _memoryInstructionMatcher = new MemoryInstructionMatcher(memory);
  }
 
@@ -28,7 +29,7 @@ public PreviousInstructions(IMemory memory) {
  return null;
  }
 
- public void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
+ public override void ReplaceInstruction(CfgInstruction old, CfgInstruction instruction) {
  SegmentedAddress instructionAddress = instruction.Address;
 
  if (_previousInstructionsAtAddress.TryGetValue(instructionAddress,

src/Spice86.Core/Emulator/CPU/CfgCpu/Linker/ExecutionContext.cs

@@ -3,13 +3,13 @@ namespace Spice86.Core.Emulator.CPU.CfgCpu.Linker;
 using Spice86.Core.Emulator.CPU.CfgCpu.ControlFlowGraph;
 
 public class ExecutionContext {
- private static int _nextIndex = 0;
 
- public ExecutionContext() {
- Index = _nextIndex++;
+ public ExecutionContext(int depth) {
+ Depth = depth;
  }
 
- public int Index { get; }
+ public int Depth { get; }
+
  /// <summary>
  /// Last node actually executed by the CPU
  /// </summary>