static void WriteMemoryDump(IMemoryProvider <Word> memory)
{
bool written = false;
int lastAddress = 0;
foreach (var item in memory.GetDebugDump().OrderBy(item => item.Key))
{
int address = item.Key;
Word value = item.Value;
if (written && address > lastAddress + 1)
{
Console.WriteLine(" · : · ¦ · ¦ · ¦ ·· ¦ · ");
}
string binRepresentation = value.ToString();
Console.WriteLine("{0,5:D}: sdec{1,6:D} | udec{2,5:D} | hex{2,4:X} | {3}{4} | {5} {6}",
address,
value.SignedValue,
value.UnsignedValue,
GetTextValue(value.RawValue, 0),
GetTextValue(value.RawValue, 1),
binRepresentation.Substring(0, 8),
binRepresentation.Substring(8, 8));
written = true;
lastAddress = address;
}
if (!written)
{
Console.WriteLine("---empty---");
}
}
/// <summary>
/// Composes bytes in to an integer of Little Endian byte order
/// </summary>
/// <param name="provider">A memory provider to fetch bytes from</param>
/// <param name="offset">Offset to state fetching bytes from</param>
/// <param name="length">The byte length of the integer</param>
/// <returns>All the things</returns>
public static ushort CompositeInteger(IMemoryProvider provider, int offset, int length)
{
int result = 0;
for (int index = 0; index < length; index++)
{
result = (provider[(ushort)offset++] << (8 * index) | result);
}
return((ushort)result);
}
public new static MdCartInfoProvider CreateInstance(IMemoryProvider memoryProvider, string rom)
{
MdCartInfoProvider provider = new MdCartInfoProvider
{
memoryProvider = memoryProvider,
romName = string.IsNullOrWhiteSpace(rom) ? "norom.bin" : Path.GetFileName(rom)
};
provider.Init();
return(provider);
}
public void Register(int addrLo, int addrHigh, IMemoryProvider provider)
{
_memoryMappings.Add(
new MemoryMapping
{
AddrLo = addrLo,
AddrHi = addrHigh,
Provider = provider,
SupportRead = provider.SupportRead,
SupportWrite = provider.SupportWrite
});
}
public SerialAbacus16Cpu(IMemoryProvider <Word> programMemory, IMemoryProvider <Word> dataMemory)
{
ProgramMemory = programMemory;
DataMemory = dataMemory;
//Initialize Operation Units
OperationRegistry = new Dictionary <byte, Operations.IOperationUnit>();
//memory access
OperationRegistry.Add(Operations.LoadOperationUnit.OpCode, new Operations.LoadOperationUnit(DataMemory, _Register));
OperationRegistry.Add(Operations.LoadIOperationUnit.OpCode, new Operations.LoadIOperationUnit(DataMemory, _Register));
OperationRegistry.Add(Operations.StoreValueOperationUnit.OpCode, new Operations.StoreValueOperationUnit(_Register));
OperationRegistry.Add(Operations.StoreValueIOperationUnit.OpCode, new Operations.StoreValueIOperationUnit(_Register));
//register move
OperationRegistry.Add(Operations.MoveOperationUnit.OpCode, new Operations.MoveOperationUnit(_Register));
//synchronization
OperationRegistry.Add(Operations.SpecialMemoryOperationUnit.OpCode, new Operations.SpecialMemoryOperationUnit(this, _Register));
//scalar arithmetic
OperationRegistry.Add(Operations.AddOperationUnit.OpCode, new Operations.AddOperationUnit(_Register));
OperationRegistry.Add(Operations.AddIOperationUnit.OpCode, new Operations.AddIOperationUnit(_Register));
OperationRegistry.Add(Operations.AddUOperationUnit.OpCode, new Operations.AddUOperationUnit(_Register));
OperationRegistry.Add(Operations.AddIUOperationUnit.OpCode, new Operations.AddIUOperationUnit(_Register));
OperationRegistry.Add(Operations.SubOperationUnit.OpCode, new Operations.SubOperationUnit(_Register));
OperationRegistry.Add(Operations.SubIOperationUnit.OpCode, new Operations.SubIOperationUnit(_Register));
OperationRegistry.Add(Operations.SubUOperationUnit.OpCode, new Operations.SubUOperationUnit(_Register));
OperationRegistry.Add(Operations.SubIUOperationUnit.OpCode, new Operations.SubIUOperationUnit(_Register));
OperationRegistry.Add(Operations.MultiplyOperationUnit.OpCode, new Operations.MultiplyOperationUnit(_Register));
OperationRegistry.Add(Operations.MultiplyIOperationUnit.OpCode, new Operations.MultiplyIOperationUnit(_Register));
OperationRegistry.Add(Operations.MultiplyUOperationUnit.OpCode, new Operations.MultiplyUOperationUnit(_Register));
OperationRegistry.Add(Operations.MultiplyIUOperationUnit.OpCode, new Operations.MultiplyIUOperationUnit(_Register));
OperationRegistry.Add(Operations.DivideOperationUnit.OpCode, new Operations.DivideOperationUnit(_Register));
OperationRegistry.Add(Operations.DivideIOperationUnit.OpCode, new Operations.DivideIOperationUnit(_Register));
OperationRegistry.Add(Operations.DivideUOperationUnit.OpCode, new Operations.DivideUOperationUnit(_Register));
OperationRegistry.Add(Operations.DivideIUOperationUnit.OpCode, new Operations.DivideIUOperationUnit(_Register));
//comparison
OperationRegistry.Add(Operations.SetLessThanOperationUnit.OpCode, new Operations.SetLessThanOperationUnit(_Register));
OperationRegistry.Add(Operations.SetLessThanUOperationUnit.OpCode, new Operations.SetLessThanUOperationUnit(_Register));
OperationRegistry.Add(Operations.SetLessThanEqualOperationUnit.OpCode, new Operations.SetLessThanEqualOperationUnit(_Register));
OperationRegistry.Add(Operations.SetLessThanEqualUOperationUnit.OpCode, new Operations.SetLessThanEqualUOperationUnit(_Register));
OperationRegistry.Add(Operations.SetEqualOperationUnit.OpCode, new Operations.SetEqualOperationUnit(_Register));
OperationRegistry.Add(Operations.SetNotEqualOperationUnit.OpCode, new Operations.SetNotEqualOperationUnit(_Register));
//bitwise logic
OperationRegistry.Add(Operations.LeftShiftOperationUnit.OpCode, new Operations.LeftShiftOperationUnit(_Register));
OperationRegistry.Add(Operations.BitwiseAndOperationUnit.OpCode, new Operations.BitwiseAndOperationUnit(_Register));
OperationRegistry.Add(Operations.BitwiseOrOperationUnit.OpCode, new Operations.BitwiseOrOperationUnit(_Register));
OperationRegistry.Add(Operations.BitwiseXorOperationUnit.OpCode, new Operations.BitwiseXorOperationUnit(_Register));
OperationRegistry.Add(Operations.BitwiseNotOperationUnit.OpCode, new Operations.BitwiseNotOperationUnit(_Register));
//Jump
OperationRegistry.Add(Operations.SimpleJumpOperationUnit.OpCode, new Operations.SimpleJumpOperationUnit());
OperationRegistry.Add(Operations.BranchNotZeroOperationUnit.OpCode, new Operations.BranchNotZeroOperationUnit(_Register));
OperationRegistry.Add(Operations.BranchZeroOperationUnit.OpCode, new Operations.BranchZeroOperationUnit(_Register));
OperationRegistry.Add(Operations.AdvancedJumpOperationUnit.OpCode, new Operations.AdvancedJumpOperationUnit(_Register));
}
private void InitMemoryLayout(IMemoryProvider memoryProvider)
{
romStart = Util.ReadRom(memoryProvider, Size.Word, ROM_START_ADDRESS) << 16;
romStart |= Util.ReadRom(memoryProvider, Size.Word, ROM_START_ADDRESS + 2);
romEnd = Util.ReadRom(memoryProvider, Size.Word, ROM_END_ADDRESS) << 16;
romEnd |= Util.ReadRom(memoryProvider, Size.Word, ROM_END_ADDRESS + 2);
ramStart = Util.ReadRom(memoryProvider, Size.Word, RAM_START_ADDRESS) << 16;
ramStart |= Util.ReadRom(memoryProvider, Size.Word, RAM_START_ADDRESS + 2);
ramEnd = Util.ReadRom(memoryProvider, Size.Word, RAM_END_ADDRESS) << 16;
ramEnd |= Util.ReadRom(memoryProvider, Size.Word, RAM_END_ADDRESS + 2);
romSize = memoryProvider.GetRomData().Length;
DetectSram();
DetectHeaderMetadata();
}
public static long ComputeChecksum(IMemoryProvider memoryProvider)
{
long res = 0;
int i = 0x200;
int size = memoryProvider.GetRomSize();
for (; i < size - 1; i += 2)
{
long val = Util.ReadRom(memoryProvider, Size.Word, i);
res = (res + val) & 0xFFFF;
}
res = size % 2 != 0 ? (res + memoryProvider.ReadRomByte(i)) & 0xFFFF : res;
return(res);
}
static void WriteMemoryDump(IMemoryProvider <Word> memory)
{
for (int address = 0; address < memory.Size; address++)
{
string binRepresentation = memory[address].ToString();
Console.WriteLine("{0,5:D}: sdec{1,6:D} | shex{1,5:X} | udec{2,5:D} | uhex{2,4:X} | {3}{4} | {5} {6}",
address,
memory[address].SignedValue,
memory[address].UnsignedValue,
GetTextValue(memory[address].RawValue, 0),
GetTextValue(memory[address].RawValue, 1),
binRepresentation.Substring(0, 8),
binRepresentation.Substring(8, 8));
}
}
public static long ReadRom(IMemoryProvider memory, Size size, int address)
{
long data;
if (size == Size.Byte)
{
data = memory.ReadRomByte(address);
}
else if (size == Size.Word)
{
data = memory.ReadRomByte(address) << 8;
data |= (uint)memory.ReadRomByte(address + 1);
}
else
{
data = memory.ReadRomByte(address) << 24;
data |= (uint)memory.ReadRomByte(address + 1) << 16;
data |= (uint)memory.ReadRomByte(address + 2) << 8;
data |= (uint)memory.ReadRomByte(address + 3);
}
LOG.Debug("Read ROM: {}, {}: {}", address, data, size, Verbose);
return(data);
}
public LoadOperationUnit(IMemoryProvider <Word> memory, IRegisterGroup registers)
: base(registers)
{
Memory = memory;
}
public MemAccess(IMemoryProvider memory)
{
_memory = memory;
}
public DiskController(IMemoryProvider memory, Action resetCpu)
{
_memAccess = new MemAccess(memory);
_resetCpu = resetCpu;
}
public void AddMapping(int startIndex, IMemoryProvider <Word> provider)
{
Mappings.Add(new MemoryMapping(startIndex, provider));
}
public Serial(IMemoryProvider memory)
{
_memory = memory;
}
static void Main(string[] args)
{
string programMemoryFile = args[0];
string dataMemoryFile = (args.Length < 2 ? null : args[1]);
bool showControlFlow = (args.Length < 3 ? false : args[2].Contains(ShowControlFlowFlag));
bool startPaused = (args.Length < 3 ? false : args[2].Contains(StartPausedFlag));
bool monitorProgramFlow = (args.Length < 3 ? false : args[2].Contains(MonitorProgramFlowFlag));
bool benchmark = (args.Length < 3 ? false : args[2].Contains(BenchmarkFlag));
programMemory = new BufferMemory16(System.IO.File.ReadAllBytes(programMemoryFile));
if (!string.IsNullOrEmpty(dataMemoryFile) && dataMemoryFile != "?")
{
dataMemory = new BufferMemory16(System.IO.File.ReadAllBytes(dataMemoryFile));
}
else
{
dataMemory = new SparseMemory <Word>(SerialAbacus16Cpu.MaximumAddressableMemory);
}
cpu = new SerialAbacus16Cpu(
programMemory,
dataMemory);
virtualSystem = new Host(cpu);
virtualSystem.ExecutionCompleted += virtualSystem_ExecutionCompleted;
if (showControlFlow)
{
cpu.InstructionPending += cpu_InstructionPending;
//virtualSystem.ClockCycleScheduled += virtualSystem_ClockCycleScheduled;
Console.WriteLine("Press ESC to cancel execution");
}
if (monitorProgramFlow)
{
FlowMonitoringMapping = new Dictionary <int, FlowInfo>();
}
if (!startPaused)
{
virtualSystem.Start();
}
if (benchmark)
{
System.Threading.Thread.Sleep(1000);
virtualSystem.SuspendAsync().Wait();
WriteDumps();
Console.ReadLine();
return;
}
while (true)
{
ConsoleKeyInfo input = Console.ReadKey(true);
switch (input.Key)
{
case ConsoleKey.Escape:
if (virtualSystem.IsRunning)
{
Console.WriteLine("Suspending Execution...");
virtualSystem.SuspendAsync().Wait();
WriteDumps();
Console.WriteLine("Execution suspended. Press ENTER to exit.");
Console.ReadLine();
}
return;
case ConsoleKey.P:
Console.WriteLine("Suspending execution...");
virtualSystem.SuspendAsync().Wait();
Console.WriteLine("Execution suspended. Press H for help.");
break;
case ConsoleKey.R:
if (!virtualSystem.IsRunning)
{
virtualSystem.Start();
}
else
{
Console.WriteLine("Already running.");
}
break;
case ConsoleKey.S:
if (!virtualSystem.IsRunning)
{
virtualSystem.Step(1);
}
else
{
Console.WriteLine("Already running.");
}
break;
case ConsoleKey.F:
WriteFlowDump();
break;
case ConsoleKey.D:
WriteDumps();
break;
case ConsoleKey.H:
Console.WriteLine("ESC: exit | P: pause | S: single step | R: run | D: dump | F: flow info | H: help");
break;
}
}
}
public MemoryCache(IMemoryProvider <Word> backingMemoryProvider)
{
BackingMemoryProvider = backingMemoryProvider;
}
public MemAccess(IMemoryProvider memory)
{
_memory = memory;
}
public DiskController(IMemoryProvider memory, Action resetCpu)
{
_memAccess = new MemAccess(memory);
_resetCpu = resetCpu;
}
public MemoryMapping(int startIndex, IMemoryProvider <Word> provider)
{
StartIndex = startIndex;
Provider = provider;
}
public void RemoveMapping(IMemoryProvider <Word> provider)
{
Mappings.RemoveAll(mapping => mapping.Provider == provider);
}
private const int AddrBuffer = 0x0080; // size of buffer: 512 bytes
public Serial(IMemoryProvider memory)
{
_memory = memory;
}
public LinearDirectMemoryCache(IMemoryProvider <Word> backingMemoryProvider, int cacheSize)
: base(backingMemoryProvider)
{
Cache = new CacheItem[cacheSize];
}
/// <summary>
/// Create a new 6502 instance with a test memory provider
/// </summary>
public C6502()
{
State = new ExecutionState();
Memory = new TestMemoryProvider();
}
public SubsetMemory(IMemoryProvider <Word> source, int startAddress, int size)
{
Source = source;
StartAddress = startAddress;
Size = size;
}
/// <summary>
/// Create a new 6502 instance with a specfied memory provider
/// </summary>
/// <param name="memoryProvider">Memory provider to use</param>
public C6502(IMemoryProvider memoryProvider)
: this()
{
Memory = memoryProvider;
}
