mirror of
https://github.com/livingcomputermuseum/sImlac.git
synced 2026-01-13 23:36:55 +00:00
817 lines
29 KiB
C#
817 lines
29 KiB
C#
/*
|
|
This file is part of sImlac.
|
|
|
|
sImlac is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
sImlac is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with sImlac. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
using imlac.IO;
|
|
using imlac.Debugger;
|
|
|
|
namespace imlac
|
|
{
|
|
|
|
/// <summary>
|
|
/// DisplayProcessor implements the Display processor found in an Imlac PDS-1 with long vector hardware.
|
|
/// </summary>
|
|
public class PDS1DisplayProcessor : DisplayProcessorBase
|
|
{
|
|
public PDS1DisplayProcessor(ImlacSystem system) : base(system)
|
|
{
|
|
|
|
}
|
|
|
|
public override void Reset()
|
|
{
|
|
base.Reset();
|
|
|
|
_sgrModeOn = false;
|
|
_sgrBeamOn = false;
|
|
_sgrDJRMOn = false;
|
|
}
|
|
|
|
public override void InitializeCache()
|
|
{
|
|
_instructionCache = new PDS1DisplayInstruction[Memory.Size];
|
|
}
|
|
|
|
public override void InvalidateCache(ushort address)
|
|
{
|
|
_instructionCache[address & Memory.SizeMask] = null;
|
|
}
|
|
|
|
public override string Disassemble(ushort address, DisplayProcessorMode mode, out int length)
|
|
{
|
|
//
|
|
// Return a precached instruction if we have it due to previous execution
|
|
// otherwise disassemble it now in the requested mode; this disassembly
|
|
// does not get added to the cache.
|
|
//
|
|
if (_instructionCache[address & Memory.SizeMask] != null)
|
|
{
|
|
return _instructionCache[address & Memory.SizeMask].Disassemble(mode, _mem, out length);
|
|
}
|
|
else
|
|
{
|
|
return new PDS1DisplayInstruction(_mem.Fetch(address), address, mode).Disassemble(mode, _mem, out length);
|
|
}
|
|
}
|
|
|
|
public override void Clock()
|
|
{
|
|
_clocks++;
|
|
|
|
if (_clocks > _frameClocks40Hz)
|
|
{
|
|
_clocks = 0;
|
|
_frameLatch = true;
|
|
_system.Display.FrameDone();
|
|
}
|
|
|
|
if (_state == ProcessorState.Halted)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (_mode)
|
|
{
|
|
case DisplayProcessorMode.Processor:
|
|
ExecuteProcessor();
|
|
break;
|
|
|
|
case DisplayProcessorMode.Increment:
|
|
ExecuteIncrement();
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override int[] GetHandledIOTs()
|
|
{
|
|
return _handledIOTs;
|
|
}
|
|
|
|
public override void ExecuteIOT(int iotCode)
|
|
{
|
|
//
|
|
// Dispatch the IOT instruction.
|
|
//
|
|
switch (iotCode)
|
|
{
|
|
case 0x03: // DLA:
|
|
PC = _system.Processor.AC;
|
|
|
|
// this is for debugging only, we keep track of the load address
|
|
// to make it easy to see where the main Display List starts
|
|
_dpcEntry = PC;
|
|
break;
|
|
|
|
case 0x0a: // Halt display processor
|
|
HaltProcessor();
|
|
break;
|
|
|
|
case 0x39: // Clear display 40Hz sync latch
|
|
_frameLatch = false;
|
|
break;
|
|
|
|
case 0xc4: // clear halt state
|
|
_halted = false;
|
|
break;
|
|
|
|
default:
|
|
Helpers.SignalError(LogType.DisplayProcessor, "Unhandled IOT {0}", Helpers.ToOctal((ushort)iotCode));
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ExecuteProcessor()
|
|
{
|
|
PDS1DisplayInstruction instruction = GetCachedInstruction(_pc, DisplayProcessorMode.Processor);
|
|
instruction.UsageMode = DisplayProcessorMode.Processor;
|
|
|
|
switch (instruction.Opcode)
|
|
{
|
|
case DisplayOpcode.DEIM:
|
|
_mode = DisplayProcessorMode.Increment;
|
|
_immediateWord = instruction.Data;
|
|
_immediateHalf = ImmediateHalf.Second;
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Enter increment mode");
|
|
break;
|
|
|
|
case DisplayOpcode.DJMP:
|
|
if (!_dadr)
|
|
{
|
|
// DADR off, use only 12 bits
|
|
_pc = (ushort)((instruction.Data & 0xfff) | _block);
|
|
}
|
|
else
|
|
{
|
|
_pc = (ushort)(instruction.Data | _block);
|
|
}
|
|
break;
|
|
|
|
case DisplayOpcode.DJMS:
|
|
Push();
|
|
|
|
if (!_dadr)
|
|
{
|
|
// DADR off, use only 12 bits
|
|
_pc = (ushort)((instruction.Data & 0xfff) | _block);
|
|
}
|
|
else
|
|
{
|
|
_pc = (ushort)(instruction.Data | _block);
|
|
}
|
|
break;
|
|
|
|
case DisplayOpcode.DOPR:
|
|
// Each of bits 4-11 can be combined in any fashion
|
|
// to do a number of operations simultaneously; we walk the bits
|
|
// and perform the operations as set.
|
|
if ((instruction.Data & 0x800) == 0)
|
|
{
|
|
// DHLT -- halt the display processor. other micro-ops in this
|
|
// instruction are still run.
|
|
HaltProcessor();
|
|
}
|
|
|
|
if ((instruction.Data & 0x400) != 0)
|
|
{
|
|
// HV Sync; this is currently a no-op, not much to do in emulation.
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "HV Sync");
|
|
|
|
MoveAbsolute(X, Y, DrawingMode.Off);
|
|
}
|
|
|
|
if ((instruction.Data & 0x200) != 0)
|
|
{
|
|
// DIXM -- increment X DAC MSB
|
|
X += 0x20;
|
|
MoveAbsolute(X, Y, DrawingMode.Off);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "DIXM, X is now {0}", X);
|
|
}
|
|
|
|
if ((instruction.Data & 0x100) != 0)
|
|
{
|
|
// DIYM -- increment Y DAC MSB
|
|
Y += 0x20;
|
|
MoveAbsolute(X, Y, DrawingMode.Off);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "DIYM, Y is now {0}", Y);
|
|
}
|
|
|
|
if ((instruction.Data & 0x80) != 0)
|
|
{
|
|
// DDXM - decrement X DAC MSB
|
|
X -= 0x20;
|
|
MoveAbsolute(X, Y, DrawingMode.Off);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "DDXM, X is now {0}", X);
|
|
}
|
|
|
|
if ((instruction.Data & 0x40) != 0)
|
|
{
|
|
// DDYM - decrement y DAC MSB
|
|
Y -= 0x20;
|
|
MoveAbsolute(X, Y, DrawingMode.Off);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "DDYM, Y is now {0}", Y);
|
|
}
|
|
|
|
if ((instruction.Data & 0x20) != 0)
|
|
{
|
|
// DRJM - return from display subroutine
|
|
ReturnFromDisplaySubroutine();
|
|
_pc--; // hack (we add +1 at the end...)
|
|
}
|
|
|
|
if ((instruction.Data & 0x10) != 0)
|
|
{
|
|
// DDSP -- intensify point on screen for 1.8us (one instruction)
|
|
// at the current position.
|
|
DrawPoint(X, Y);
|
|
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "DDSP at {0},{1}", X, Y);
|
|
}
|
|
|
|
// F/C ops:
|
|
int f = (instruction.Data & 0xc) >> 2;
|
|
int c = instruction.Data & 0x3;
|
|
|
|
switch (f)
|
|
{
|
|
case 0x0:
|
|
// if bit 15 is set, the MIT mods flip the DADR bit.
|
|
if (Configuration.MITMode && (c == 1))
|
|
{
|
|
_dadr = !_dadr;
|
|
}
|
|
break;
|
|
|
|
case 0x1:
|
|
// Set scale based on C
|
|
switch (c)
|
|
{
|
|
case 0:
|
|
_scale = 1.0f;
|
|
break;
|
|
|
|
default:
|
|
_scale = c;
|
|
break;
|
|
}
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Scale set to {0}", _scale);
|
|
break;
|
|
|
|
case 0x2:
|
|
if (!Configuration.MITMode)
|
|
{
|
|
_block = (ushort)(c << 12);
|
|
}
|
|
break;
|
|
|
|
case 0x3:
|
|
// TODO: light pen sensitize
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Light pen, stub!");
|
|
break;
|
|
}
|
|
|
|
_pc++;
|
|
break;
|
|
|
|
case DisplayOpcode.DLXA:
|
|
X = instruction.Data << 1;
|
|
|
|
DrawingMode mode;
|
|
if (_sgrModeOn && _sgrBeamOn)
|
|
{
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "SGR-1 X set to {0}", X);
|
|
mode = DrawingMode.SGR1;
|
|
}
|
|
else
|
|
{
|
|
mode = DrawingMode.Off;
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "X set to {0}", X);
|
|
}
|
|
|
|
MoveAbsolute(X, Y, mode);
|
|
|
|
if (_sgrDJRMOn)
|
|
{
|
|
ReturnFromDisplaySubroutine();
|
|
}
|
|
else
|
|
{
|
|
_pc++;
|
|
}
|
|
break;
|
|
|
|
case DisplayOpcode.DLYA:
|
|
Y = instruction.Data << 1;
|
|
|
|
if (_sgrModeOn && _sgrBeamOn)
|
|
{
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "SGR-1 Y set to {0}", Y);
|
|
mode = DrawingMode.SGR1;
|
|
}
|
|
else
|
|
{
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Y set to {0}", Y);
|
|
mode = DrawingMode.Off;
|
|
}
|
|
|
|
MoveAbsolute(X, Y, mode);
|
|
|
|
if (_sgrDJRMOn)
|
|
{
|
|
ReturnFromDisplaySubroutine();
|
|
}
|
|
else
|
|
{
|
|
_pc++;
|
|
}
|
|
break;
|
|
|
|
case DisplayOpcode.DLVH:
|
|
DrawLongVector(instruction.Data);
|
|
break;
|
|
|
|
case DisplayOpcode.SGR1:
|
|
_sgrModeOn = (instruction.Data & 0x1) != 0;
|
|
_sgrDJRMOn = (instruction.Data & 0x2) != 0;
|
|
_sgrBeamOn = (instruction.Data & 0x4) != 0;
|
|
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "SGR-1 instruction: Enter {0} BeamOn {1} DRJM {2}", _sgrModeOn, _sgrBeamOn, _sgrDJRMOn);
|
|
_pc++;
|
|
break;
|
|
|
|
case DisplayOpcode.Invalid:
|
|
Helpers.SignalError(
|
|
LogType.DisplayProcessor,
|
|
"Execution of invalid display processor instruction {0}",
|
|
Helpers.ToOctal(instruction.Data));
|
|
_pc++;
|
|
break;
|
|
|
|
default:
|
|
Helpers.SignalError(
|
|
LogType.DisplayProcessor,
|
|
"Unimplemented Display Processor Opcode {0}, operands {1}",
|
|
Helpers.ToOctal((ushort)instruction.Opcode),
|
|
Helpers.ToOctal(instruction.Data));
|
|
break;
|
|
}
|
|
|
|
// If the next instruction has a breakpoint set we'll halt at this point, before executing it.
|
|
if (BreakpointManager.TestBreakpoint(BreakpointType.Display, _pc))
|
|
{
|
|
_state = ProcessorState.BreakpointHalt;
|
|
}
|
|
}
|
|
|
|
private void ExecuteIncrement()
|
|
{
|
|
int halfWord = _immediateHalf == ImmediateHalf.First ? (_immediateWord & 0xff00) >> 8 : (_immediateWord & 0xff);
|
|
|
|
int newX = (int)X;
|
|
int newY = (int)Y;
|
|
|
|
// translate the half word to vector movements or escapes
|
|
if ((halfWord & 0x80) == 0)
|
|
{
|
|
if ((halfWord & 0x40) != 0)
|
|
{
|
|
// Escape code
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Increment mode escape on halfword {0}", _immediateHalf);
|
|
_mode = DisplayProcessorMode.Processor;
|
|
_pc++; // move to next word
|
|
|
|
// Moved this into this check (not sure it makes sense to do a DJMS when not escaped from Increment mode)
|
|
if ((halfWord & 0x20) != 0)
|
|
{
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Increment mode return from subroutine.");
|
|
ReturnFromDisplaySubroutine();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Stay in increment mode.
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Increment instruction, non-drawing.");
|
|
MoveToNextHalfWord();
|
|
}
|
|
|
|
if ((halfWord & 0x10) != 0)
|
|
{
|
|
newX += 0x20;
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Increment X MSB, X is now {0}", X);
|
|
}
|
|
|
|
if ((halfWord & 0x08) != 0)
|
|
{
|
|
newX = newX & (0xffe0);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Reset X LSB, X is now {0}", X);
|
|
}
|
|
|
|
if ((halfWord & 0x02) != 0)
|
|
{
|
|
newY += 0x20;
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Increment Y MSB, Y is now {0}", Y);
|
|
}
|
|
|
|
if ((halfWord & 0x01) != 0)
|
|
{
|
|
newY = newY & (0xffe0);
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "Reset Y LSB, Y is now {0}", Y);
|
|
}
|
|
|
|
MoveAbsolute(newX, newY, DrawingMode.Off);
|
|
|
|
}
|
|
else
|
|
{
|
|
int xSign = ((halfWord & 0x20) == 0) ? 1 : -1;
|
|
int xMag = (int)(((halfWord & 0x18) >> 3) * _scale);
|
|
|
|
int ySign = (int)(((halfWord & 0x04) == 0) ? 1 : -1);
|
|
int yMag = (int)((halfWord & 0x03) * _scale);
|
|
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor,
|
|
"Inc mode ({0}:{1}), x={2} y={3} dx={4} dy={5} beamon {6}",
|
|
Helpers.ToOctal((ushort)_pc),
|
|
Helpers.ToOctal((ushort)halfWord),
|
|
newX,
|
|
newY,
|
|
xSign * xMag,
|
|
ySign * yMag,
|
|
(halfWord & 0x40) != 0);
|
|
|
|
newX = (int)(newX + xSign * xMag * 2);
|
|
newY = (int)(newY + ySign * yMag * 2);
|
|
|
|
MoveAbsolute(newX, newY, (halfWord & 0x40) == 0 ? DrawingMode.Off : DrawingMode.Dotted);
|
|
|
|
MoveToNextHalfWord();
|
|
}
|
|
|
|
// Assign back to X, Y registers; clipping into range.
|
|
X = newX;
|
|
Y = newY;
|
|
|
|
// If the next instruction has a breakpoint set we'll halt at this point, before executing it.
|
|
if (_immediateHalf == ImmediateHalf.First && BreakpointManager.TestBreakpoint(BreakpointType.Display, _pc))
|
|
{
|
|
_state = ProcessorState.BreakpointHalt;
|
|
}
|
|
}
|
|
|
|
private void MoveToNextHalfWord()
|
|
{
|
|
if (_immediateHalf == ImmediateHalf.Second)
|
|
{
|
|
_pc++;
|
|
_immediateWord = _mem.Fetch(_pc);
|
|
_immediateHalf = ImmediateHalf.First;
|
|
|
|
// Update the instruction cache with the type of instruction (to aid in debugging).
|
|
PDS1DisplayInstruction instruction = GetCachedInstruction(_pc, DisplayProcessorMode.Increment);
|
|
}
|
|
else
|
|
{
|
|
_immediateHalf = ImmediateHalf.Second;
|
|
}
|
|
}
|
|
|
|
private void DrawLongVector(ushort word0)
|
|
{
|
|
//
|
|
// A Long Vector instruction is 3 words long:
|
|
// Word 0: upper 4 bits indicate the opcode (4), lower 12 specify N-M
|
|
// Word 1: upper 3 bits specify beam options (dotted, solid, etc) and the lower 12 specify the larger increment "M"
|
|
// Word 2: upper 3 bits specify signs, lower 12 specify the smaller increment "N"
|
|
// M is the larger absolute value between dX and dY
|
|
// N is the smaller.
|
|
|
|
//
|
|
// Unsure at the moment what the N-M bits are for (I'm guessing they're there to help the processor figure things out).
|
|
// Also unsure what bits are used in the 12 bits for N and M (the DACs are only 11-bits, but normally only 10 can be specified)...
|
|
//
|
|
ushort word1 = _mem.Fetch(++_pc);
|
|
ushort word2 = _mem.Fetch(++_pc);
|
|
|
|
uint M = (uint)(word1 & 0x3ff);
|
|
uint N = (uint)(word2 & 0x3ff);
|
|
|
|
bool beamOn = (word1 & 0x2000) != 0;
|
|
bool dotted = (word1 & 0x4000) != 0;
|
|
|
|
int dySign = (word2 & 0x2000) != 0 ? -1 : 1;
|
|
int dxSign = (word2 & 0x4000) != 0 ? -1 : 1;
|
|
bool dyGreater = (word2 & 0x1000) != 0;
|
|
|
|
uint dx = 0;
|
|
uint dy = 0;
|
|
|
|
if (dyGreater)
|
|
{
|
|
dy = M;
|
|
dx = N;
|
|
}
|
|
else
|
|
{
|
|
dx = M;
|
|
dy = N;
|
|
}
|
|
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "LongVector x={0} y={1} dx={2} dy={3} beamOn {4} dotted {5}", X, Y, dx * dxSign, dy * dySign, beamOn, dotted);
|
|
|
|
// * 2 for translation to 11-bit space
|
|
// The docs don't call this out, but the scale setting used in increment mode appears to apply
|
|
// to the LVH vectors as well. (Maze appears to rely on this.)
|
|
int newX = (int)(X + (dx * dxSign) * 2 * _scale);
|
|
int newY = (int)(Y + (dy * dySign) * 2 * _scale);
|
|
|
|
if (Trace.TraceOn) Trace.Log(LogType.DisplayProcessor, "LongVector, move complete - x={0} y={1}", newX, newY, dx * dxSign, dy * dySign, beamOn, dotted);
|
|
|
|
MoveAbsolute(newX, newY, beamOn ? (dotted ? DrawingMode.Dotted : DrawingMode.Normal) : DrawingMode.Off);
|
|
|
|
// Assign back to X, Y registers; clipping into range.
|
|
X = newX;
|
|
Y = newY;
|
|
|
|
_pc++;
|
|
}
|
|
|
|
private void ReturnFromDisplaySubroutine()
|
|
{
|
|
Pop();
|
|
}
|
|
|
|
private PDS1DisplayInstruction GetCachedInstruction(ushort address, DisplayProcessorMode mode)
|
|
{
|
|
if (_instructionCache[address & Memory.SizeMask] == null)
|
|
{
|
|
_instructionCache[address & Memory.SizeMask] = new PDS1DisplayInstruction(_mem.Fetch(address), address, mode);
|
|
}
|
|
|
|
return _instructionCache[address & Memory.SizeMask];
|
|
}
|
|
|
|
// SGR-1 mode switches
|
|
private bool _sgrModeOn;
|
|
private bool _sgrDJRMOn;
|
|
private bool _sgrBeamOn;
|
|
|
|
protected const int _frameClocks40Hz = 13889; // cycles per 1/40th of a second (rounded up) for a 1.8uS clock speed.
|
|
|
|
private PDS1DisplayInstruction[] _instructionCache;
|
|
|
|
private readonly int[] _handledIOTs = { 0x3, 0xa, 0x39, 0xc4 };
|
|
|
|
|
|
/// <summary>
|
|
/// PDS-1 Display instruction decoder and disassembler.
|
|
/// </summary>
|
|
private class PDS1DisplayInstruction : DisplayInstructionBase
|
|
{
|
|
public PDS1DisplayInstruction(ushort word, ushort address, DisplayProcessorMode mode) : base (word, address, mode)
|
|
{
|
|
}
|
|
|
|
public override string Disassemble(DisplayProcessorMode mode, Memory mem, out int length)
|
|
{
|
|
if (mode == DisplayProcessorMode.Indeterminate)
|
|
{
|
|
mode = _usageMode;
|
|
}
|
|
|
|
switch (mode)
|
|
{
|
|
case DisplayProcessorMode.Increment:
|
|
length = 1;
|
|
return DisassembleIncrement();
|
|
|
|
case DisplayProcessorMode.Processor:
|
|
return DisassembleProcessor(mem, out length);
|
|
|
|
case DisplayProcessorMode.Indeterminate:
|
|
length = 1;
|
|
return "Indeterminate";
|
|
|
|
default:
|
|
throw new InvalidOperationException(String.Format("{0} is not a supported disassembly mode for this processor.", mode));
|
|
}
|
|
}
|
|
|
|
protected override void Decode()
|
|
{
|
|
if (_usageMode == DisplayProcessorMode.Processor)
|
|
{
|
|
DecodeProcessor();
|
|
}
|
|
else
|
|
{
|
|
DecodeImmediate();
|
|
}
|
|
}
|
|
|
|
private void DecodeProcessor()
|
|
{
|
|
int op = (_word & 0x7000) >> 12;
|
|
|
|
switch (op)
|
|
{
|
|
case 0x00:
|
|
// opr code
|
|
_opcode = DisplayOpcode.DOPR;
|
|
_data = (ushort)(_word & 0xfff);
|
|
break;
|
|
|
|
case 0x01:
|
|
_opcode = DisplayOpcode.DLXA;
|
|
_data = (ushort)(_word & 0x3ff);
|
|
break;
|
|
|
|
case 0x02:
|
|
_opcode = DisplayOpcode.DLYA;
|
|
_data = (ushort)(_word & 0x3ff);
|
|
break;
|
|
|
|
case 0x03:
|
|
_opcode = DisplayOpcode.DEIM;
|
|
_data = (ushort)(_word & 0xff);
|
|
|
|
if ((_word & 0xff00) == 0x3800)
|
|
{
|
|
Console.WriteLine("PPM-1 not implemented (instr {0})", Helpers.ToOctal(_word));
|
|
}
|
|
break;
|
|
|
|
case 0x04:
|
|
_opcode = DisplayOpcode.DLVH;
|
|
_data = (ushort)(_word & 0xfff);
|
|
break;
|
|
|
|
case 0x05:
|
|
_opcode = DisplayOpcode.DJMS;
|
|
_data = (ushort)(_word & 0xfff);
|
|
|
|
if (Configuration.MITMode && (_word & 0x8000) != 0)
|
|
{
|
|
// MIT's mod takes the MSB of the address from the MSB of the instruction word
|
|
_data |= 0x1000;
|
|
}
|
|
break;
|
|
|
|
case 0x06:
|
|
_opcode = DisplayOpcode.DJMP;
|
|
_data = (ushort)(_word & 0xfff);
|
|
|
|
if (Configuration.MITMode && (_word & 0x8000) != 0)
|
|
{
|
|
// MIT's mod takes the MSB of the address from the MSB of the instruction word
|
|
_data |= 0x1000;
|
|
}
|
|
break;
|
|
|
|
case 0x07:
|
|
DecodeExtendedInstruction(_word);
|
|
break;
|
|
|
|
default:
|
|
Helpers.SignalError(
|
|
LogType.DisplayProcessor,
|
|
"Unhandled Display Processor Mode instruction {0}",
|
|
Helpers.ToOctal(_word));
|
|
|
|
_opcode = DisplayOpcode.Invalid;
|
|
_data = _word;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void DecodeExtendedInstruction(ushort word)
|
|
{
|
|
int op = (word & 0x1f8) >> 3;
|
|
|
|
switch (op)
|
|
{
|
|
case 0x36:
|
|
case 0x37:
|
|
_opcode = DisplayOpcode.ASG1;
|
|
break;
|
|
|
|
case 0x3a:
|
|
case 0x3b:
|
|
_opcode = DisplayOpcode.VIC1;
|
|
break;
|
|
|
|
case 0x3c:
|
|
case 0x3d:
|
|
_opcode = DisplayOpcode.MCI1;
|
|
break;
|
|
|
|
case 0x3e:
|
|
_opcode = DisplayOpcode.STI1;
|
|
break;
|
|
|
|
case 0x3f:
|
|
_opcode = DisplayOpcode.SGR1;
|
|
break;
|
|
|
|
default:
|
|
Helpers.SignalError(
|
|
LogType.DisplayProcessor,
|
|
"Unhandled extended Display Processor Mode instruction {0}",
|
|
Helpers.ToOctal(word));
|
|
|
|
_opcode = DisplayOpcode.Invalid;
|
|
_data = word;
|
|
break;
|
|
}
|
|
|
|
_data = (ushort)(word & 0x7);
|
|
|
|
}
|
|
|
|
private void DecodeImmediate()
|
|
{
|
|
// TODO: eventually actually precache movement calculations.
|
|
}
|
|
|
|
protected override string DisassembleExtended(Memory mem, out int length)
|
|
{
|
|
string ret = String.Empty;
|
|
switch (_opcode)
|
|
{
|
|
case DisplayOpcode.DLVH:
|
|
length = 3;
|
|
ret = DisassembleLongVector(mem);
|
|
break;
|
|
|
|
default:
|
|
length = 1;
|
|
// Handle as yet not-special-cased opcodes
|
|
ret = String.Format("{0} {1}", _opcode, Helpers.ToOctal(_data));
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
private string DisassembleLongVector(Memory mem)
|
|
{
|
|
//
|
|
// A Long Vector instruction is 3 words long:
|
|
// Word 0: upper 4 bits indicate the opcode (4), lower 12 specify N-M
|
|
// Word 1: upper 3 bits specify beam options (dotted, solid, etc) and the lower 12 specify the larger increment "M"
|
|
// Word 2: upper 3 bits specify signs, lower 12 specify the smaller increment "N"
|
|
// M is the larger absolute value between dX and dY
|
|
// N is the smaller.
|
|
//
|
|
// TODO: Would make sense to precache this during decoding, would require
|
|
// modifications to cache invalidation logic.
|
|
ushort word1 = mem.Fetch((ushort)(_address + 1));
|
|
ushort word2 = mem.Fetch((ushort)(_address + 2));
|
|
|
|
uint M = (uint)(word1 & 0x3ff);
|
|
uint N = (uint)(word2 & 0x3ff);
|
|
|
|
bool beamOn = (word1 & 0x2000) != 0;
|
|
bool dotted = (word1 & 0x4000) != 0;
|
|
|
|
int dySign = (word2 & 0x2000) != 0 ? -1 : 1;
|
|
int dxSign = (word2 & 0x4000) != 0 ? -1 : 1;
|
|
bool dyGreater = (word2 & 0x1000) != 0;
|
|
|
|
uint dx = 0;
|
|
uint dy = 0;
|
|
|
|
if (dyGreater)
|
|
{
|
|
dy = M;
|
|
dx = N;
|
|
}
|
|
else
|
|
{
|
|
dx = M;
|
|
dy = N;
|
|
}
|
|
|
|
return String.Format("DLVH ({0},{1}) {2} {3}",
|
|
dx * dxSign, dy * dySign,
|
|
beamOn ? "ON" : "OFF",
|
|
dotted ? "DOTTED" : String.Empty);
|
|
}
|
|
}
|
|
}
|
|
}
|