source: branches/multi-width/Cpu.pas

unit Cpu;

interface

uses
  Classes, SysUtils, Channel;

type
  TOpcode = (opNop, opHalt, opLoad, opLoadMem, opStoreMem,
    opInput, opOutput, opJump,
    opWidth8, opWidth16, opWidth24, opWidth32, opWidth64, opWidth128,
    opLoadSys, opStoreSys);

  { TCpu }

  TCpu = class
  private
    FDataWidth: TBitWidth;
    FAddressWidth: TBitWidth;
    FPrefixDataWidth: TBitWidth;
  public
    Memory: TChannel;
    IO: TChannel;
    Terminated: Boolean;
    PC: QWord;
    A: QWord;
    procedure ReadData(var Data: QWord); overload;
    procedure ReadData(Address: QWord; var Data: QWord); overload;
    procedure ReadAddress(var Address: QWord);
    function Read8: Byte;
    function Read16: Word;
    function Read24: DWord;
    function Read32: DWord;
    function Read64: QWord;
    function ReadOpcode: TOpcode;
    procedure WriteData(Data: QWord); overload;
    procedure WriteData(Address: QWord; Data: QWord); overload;
    procedure WriteAddress(Address: QWord);
    procedure Write8(Data: Byte);
    procedure Write16(Data: Word);
    procedure Write24(Data: DWord);
    procedure Write32(Data: DWord);
    procedure Write64(Data: QWord);
    procedure WriteOpcode(Opcode: TOpcode);
    procedure Reset;
    procedure Run;
    procedure Step;
    constructor Create;
    destructor Destroy; override;
    property AddressWidth: TBitWidth read FAddressWidth write FAddressWidth;
  end;


implementation

{ TCpu }

function TCpu.Read8: Byte;
begin
  Result := Memory.Read8(PC);
  Inc(PC);
end;

function TCpu.Read16: Word;
begin
  Result := Memory.Read16(PC);
  Inc(PC, SizeOf(Word));
end;

function TCpu.Read24: DWord;
begin
  Result := Memory.Read24(PC);
  Inc(PC, 3);
end;

function TCpu.Read32: DWord;
begin
  Result := Memory.Read32(PC);
  Inc(PC, SizeOf(DWord));
end;

function TCpu.Read64: QWord;
begin
  Result := Memory.Read64(PC);
  Inc(PC, SizeOf(QWord));
end;

procedure TCpu.ReadData(var Data: QWord);
begin
  ReadData(PC, Data);
  Inc(PC, Integer(FDataWidth));
end;

procedure TCpu.ReadData(Address: QWord; var Data: QWord);
begin
  Memory.Read(FDataWidth, Address, Data);
end;

procedure TCpu.ReadAddress(var Address: QWord);
begin
  Memory.Read(FAddressWidth, PC, Address);
  Inc(PC, Integer(FAddressWidth));
end;

function TCpu.ReadOpcode: TOpcode;
begin
  Result := TOpcode(Memory.Read8(PC));
  Inc(PC);
end;

procedure TCpu.WriteData(Data: QWord);
begin
  WriteData(PC, Data);
  Inc(PC, Integer(FDataWidth));
end;

procedure TCpu.WriteData(Address: QWord; Data: QWord);
begin
  Memory.Write(FDataWidth, Address, Data);
end;

procedure TCpu.WriteAddress(Address: QWord);
begin
  Memory.Write(FAddressWidth, PC, Address);
  Inc(PC, Integer(FAddressWidth));
end;

procedure TCpu.Write8(Data: Byte);
begin
  Memory.Write8(PC, Data);
  Inc(PC);
end;

procedure TCpu.Write16(Data: Word);
begin
  Memory.Write16(PC, Data);
  Inc(PC, SizeOf(Word));
end;

procedure TCpu.Write24(Data: DWord);
begin
  Memory.Write24(PC, Data);
  Inc(PC, 3);
end;

procedure TCpu.Write32(Data: DWord);
begin
  Memory.Write32(PC, Data);
  Inc(PC, SizeOf(DWord));
end;

procedure TCpu.Write64(Data: QWord);
begin
  Memory.Write64(PC, Data);
  Inc(PC, SizeOf(QWord));
end;

procedure TCpu.WriteOpcode(Opcode: TOpcode);
begin
  Memory.Write8(PC, Byte(Opcode));
  Inc(PC);
end;

procedure TCpu.Reset;
begin
  Terminated := False;
  PC := 0;
  FPrefixDataWidth := bwNone;
  FDataWidth := FAddressWidth;
end;

procedure TCpu.Run;
begin
  Reset;
  while not Terminated do
    Step;
end;

procedure TCpu.Step;
var
  Opcode: TOpcode;
  Address: QWord;
begin
  if FPrefixDataWidth <> bwNone then begin
    FDataWidth := FPrefixDataWidth;
    FPrefixDataWidth := bwNone;
  end;
  Opcode := TOpcode(Read8);
  case Opcode of
    opNop: ;
    opHalt: Terminated := True;
    opLoad: ReadData(A);
    opLoadMem: begin
      Address := 0;
      ReadAddress(Address);
      ReadData(Address, A);
    end;
    opStoreMem: begin
      Address := 0;
      ReadAddress(Address);
      WriteData(Address, A);
    end;
    opInput: begin
      Address := 0;
      ReadAddress(Address);
      IO.Read(FDataWidth, Address, A);
    end;
    opOutput: begin
      Address := 0;
      ReadAddress(Address);
      IO.Write(FDataWidth, Address, A);
    end;
    opJump: begin
      PC := 0;
      ReadData(PC);
    end;
    opWidth8: if FAddressWidth <= bw8 then FPrefixDataWidth := bw8;
    opWidth16: if FAddressWidth <= bw16 then FPrefixDataWidth := bw16;
    opWidth24: if FAddressWidth <= bw24 then FPrefixDataWidth := bw24;
    opWidth32: if FAddressWidth <= bw32 then FPrefixDataWidth := bw32;
    opWidth64: if FAddressWidth <= bw64 then FPrefixDataWidth := bw64;
    opWidth128: if FAddressWidth <= bw128 then FPrefixDataWidth := bw128;
  end;
  FDataWidth := FAddressWidth;
end;

constructor TCpu.Create;
begin
  Memory := TChannel.Create;
  IO := TChannel.Create;
  FAddressWidth := bw8;
  Reset;
end;

destructor TCpu.Destroy;
begin
  FreeAndNil(Memory);
  FreeAndNil(IO);
  inherited;
end;

end.