Changeset 153

Timestamp:

Apr 20, 2018, 10:56:29 PM (6 years ago)

Author:

chronos

Message:

• Modified: Conditional jump/call divided to test instruction executed before jump.
• Added: More opcode handling.

Location:

branches/virtualcpu2

Files:

• UFormMain.lfm (modified) (1 diff)
• UFormMain.pas (modified) (2 diffs)
• UMachine.pas (modified) (29 diffs)

branches/virtualcpu2/UFormMain.lfm

@@ -7 +7 @@
   ClientHeight = 732
   ClientWidth = 1504
-  DesignTimePPI = 120
   OnCreate = FormCreate
   OnDestroy = FormDestroy
   OnShow = FormShow
-  LCLVersion = '1.8.0.6'
+  LCLVersion = '1.8.0.4'
   object ButtonRun: TButton
     Left = 32

branches/virtualcpu2/UFormMain.pas

@@ -107 +107 @@
     AddCopyConst(Counter, 8);
     AddCopyConst(Source, $30);
-    AddCopyConst(Dest, $40);
+    AddCopyConst(Dest, $60);
 
     LoopAddr := Addr;
@@ -115 +115 @@
     AddInc(Dest);
     AddDec(Counter);
-    AddJumpRelNotZero(Counter, LoopAddr - Addr);
+    AddTestNotZero(Counter);
+    AddJumpRelCond8(LoopAddr - Addr);
     AddHalt;
   end;

branches/virtualcpu2/UMachine.pas

@@ -9 +9 @@
 
 type
+ Int8    = ShortInt;
+ Int16   = SmallInt;
+ Int32   = Longint;
+ PInt8 = ^Int8;
+ PInt16 = ^Int16;
+ PInt32 = ^Int32;
+ UInt8   = Byte;
+ UInt16  = Word;
+ UInt32  = Cardinal;
+ PUInt8   = ^UInt8;
+ PUInt16  = ^UInt16;
+ PUInt32  = ^UInt16;
+
+
   //TAddrInt = Int8;
   TAddrInt = Int16;
   //TAddrInt = Int32;
   //TAddrInt = Int64;
+  PAddrInt = ^TAddrInt;
   TDataInt = QWord;
   //TDataInt = Int16;
@@ -19 +34 @@
   PDataInt = ^TDataInt;
 
-  TRegIndex = TAddrInt;
+  TRegIndex = Byte;
   TRegSize = Int8;
 
@@ -40 +55 @@
     opPop,
     // Skip
-    opSkipZero,
-    opSkipNotZero,
+    opTestZero,
+    opTestNotZero,
     opSkipCarry,
     opSkipNotCarray,
@@ -47 +62 @@
     opCallRel,
     opCallAbs,
+    opCallRelCond,
+    opCallAbsCond,
     opRet,
     // Jump
     opJumpRel,
     opJumpAbs,
+    opJumpRelCond,
+    opJumpAbsCond,
     // Logical operations
     opAnd,
@@ -103 +122 @@
     procedure OpcodePop;
     procedure OpcodePush;
+    procedure OpcodePush8;
+    procedure OpcodePush16;
+    procedure OpcodePush32;
+    procedure OpcodePush64;
     procedure OpcodeLdir;
     procedure OpcodeInc;
@@ -110 +133 @@
     procedure OpcodeInc64;
     procedure OpcodeDec;
-    procedure OpcodeSkipNotZero;
-    procedure OpcodeSkipZero;
+    procedure OpcodeTestNotZero;
+    procedure OpcodeTestZero;
     procedure OpcodeJumpRel;
     procedure OpcodeJumpAbs;
+    procedure OpcodeJumpRelCond;
+    procedure OpcodeJumpRelCond8;
+    procedure OpcodeJumpAbsCond;
+    procedure OpcodeCallRel;
+    procedure OpcodeCallAbs;
+    procedure OpcodeCallRelCond;
+    procedure OpcodeCallAbsCond;
     procedure OpcodeUnsupported;
+    procedure OpcodeSetSize;
+    procedure OpcodeSetSize8;
+    procedure OpcodeSetSize16;
+    procedure OpcodeSetSize32;
+    procedure OpcodeSetSize64;
     function ReadNext: TDataInt;
+    function ReadNextS: TDataInt;
     function ReadNext8: Byte;
     function ReadNextS8: ShortInt;
@@ -131 +167 @@
     SP: TAddrInt;
     DataSize: TDataSize;
+    BaseDataSize: TDataSize;
     Terminated: Boolean;
-    SkipNext: Boolean;
+    Condition: Boolean;
     procedure Run;
     constructor Create;
@@ -143 +180 @@
     Machine: TMachine;
     procedure AddData(Data: TDataInt);
+    procedure AddDataS(Data: Int64);
     procedure AddData8(Data: Byte);
     procedure AddDataS8(Data: ShortInt);
     procedure AddCopyConst(Reg: TRegIndex; Value: TDataInt);
+    procedure AddCopyConst8(Reg: TRegIndex; Value: UInt8);
     procedure AddGetDataSize(Reg: TRegIndex);
     procedure AddCopyFromMem(Reg, Src: TRegIndex);
@@ -152 +191 @@
     procedure AddDec(Reg: TRegIndex);
     procedure AddHalt;
-    procedure AddJumpRelNotZero(Reg: TRegIndex; RelAddr: Integer);
+    procedure AddTestNotZero(Reg: TRegIndex);
+    procedure AddJumpRelCond(RelAddr: Integer);
+    procedure AddJumpRelCond8(RelAddr: ShortInt);
     constructor Create;
   end;
 
 const
-  DataSizeValue: array[TDataSize] of Byte = (SizeOf(TDataInt), SizeOf(Byte),
-    SizeOf(Word), SizeOf(Cardinal), SizeOf(QWord));
+  DataSizeValue: array[TDataSize] of Byte = (SizeOf(TDataInt), SizeOf(UInt8),
+    SizeOf(UInt16), SizeOf(UInt32), SizeOf(UInt64));
 
 implementation
@@ -203 +244 @@
   SetOpcode(opInc, OpcodeInc64, ds64);
   SetOpcode(opDec, OpcodeDec);
-  SetOpcode(opSkipZero, OpcodeSkipZero);
-  SetOpcode(opSkipNotZero, OpcodeSkipNotZero);
+  SetOpcode(opTestZero, OpcodeTestZero);
+  SetOpcode(opTestNotZero, OpcodeTestNotZero);
   SetOpcode(opJumpRel, OpcodeJumpRel);
   SetOpcode(opJumpAbs, OpcodeJumpAbs);
+  SetOpcode(opJumpRelCond, OpcodeJumpRelCond);
+  SetOpcode(opJumpRelCond, OpcodeJumpRelCond8, ds8);
+  SetOpcode(opJumpAbsCond, OpcodeJumpAbsCond);
+  SetOpcode(opCallRel, OpcodeCAllRel);
+  SetOpcode(opCallAbs, OpcodeCallAbs);
+  SetOpcode(opCallRelCond, OpcodeCallRelCond);
+  SetOpcode(opCallAbsCond, OpcodeCallAbsCond);
   SetOpcode(opAdd, OpcodeAdd);
   SetOpcode(opSub, OpcodeSub);
@@ -214 +262 @@
   SetOpcode(opXor, OpcodeXor);
   SetOpcode(opPush, OpcodePush);
+  SetOpcode(opPush, OpcodePush8, ds8);
+  SetOpcode(opPush, OpcodePush16, ds16);
+  SetOpcode(opPush, OpcodePush32, ds32);
+  SetOpcode(opPush, OpcodePush64, ds64);
   SetOpcode(opPop, OpcodePop);
+  SetOpcode(opSetSize8, OpcodeSetSize8);
 end;
 
@@ -226 +279 @@
   if (Opcode <= High(Opcode)) then begin
     OpcodeHandler := OpcodeTable[Opcode, DataSize];
-    if not Assigned(OpcodeHandler) then OpcodeHandler
+    if Assigned(OpcodeHandler) then OpcodeHandler
     else raise Exception.Create('Opcode without handler: ' + IntToHex(Integer(Opcode), 2));
   end else raise Exception.Create('Unknown opcode: ' + IntToHex(Integer(Opcode), 2));
+  if (DataSize <> BaseDataSize) and (Opcode <> opSetSize) and (Opcode <> opSetSize8) and
+    (Opcode <> opSetSize16) and (Opcode <> opSetSize32) and (Opcode <> opSetSize64) then
+    DataSize := BaseDataSize;
 end;
 
@@ -253 +309 @@
   Dest := ReadNext8;
   Source := ReadNext8;
-  PByte(@Registers[Dest])^ := PByte(@Registers[Source])^;
+  PUInt8(@Registers[Dest])^ := PUInt8(@Registers[Source])^;
 end;
 
@@ -263 +319 @@
   Dest := ReadNext8;
   Source := ReadNext8;
-  PWord(@Registers[Dest])^ := PWord(@Registers[Source])^;
+  PUInt16(@Registers[Dest])^ := PUInt16(@Registers[Source])^;
 end;
 
@@ -273 +329 @@
   Dest := ReadNext8;
   Source := ReadNext8;
-  PCardinal(@Registers[Dest])^ := PCardinal(@Registers[Source])^;
+  PUInt32(@Registers[Dest])^ := PUInt32(@Registers[Source])^;
 end;
 
@@ -283 +339 @@
   Dest := ReadNext8;
   Source := ReadNext8;
-  PQWord(@Registers[Dest])^ := PQWord(@Registers[Source])^;
+  PUInt64(@Registers[Dest])^ := PUInt64(@Registers[Source])^;
 end;
 
@@ -328 +384 @@
 procedure TMachine.OpcodeCopyConst8;
 var
-  Source: Byte;
-  Dest: TRegIndex;
-begin
-  Dest := ReadNext8;
-  Source := ReadNext8;
-  PByte(@Registers[Dest])^ := Source;
+  Source: UInt8;
+  Dest: TRegIndex;
+begin
+  Dest := ReadNext8;
+  Source := ReadNext8;
+  PUInt8(@Registers[Dest])^ := Source;
 end;
 
 procedure TMachine.OpcodeCopyConst16;
 var
-  Source: Word;
+  Source: UInt16;
   Dest: TRegIndex;
 begin
   Dest := ReadNext8;
   Source := ReadNext16;
-  PWord(@Registers[Dest])^ := Source;
+  PUInt16(@Registers[Dest])^ := Source;
 end;
 
 procedure TMachine.OpcodeCopyConst32;
 var
-  Source: Cardinal;
+  Source: UInt32;
   Dest: TRegIndex;
 begin
   Dest := ReadNext8;
   Source := ReadNext32;
-  PCardinal(@Registers[Dest])^ := Source;
+  PUInt32(@Registers[Dest])^ := Source;
 end;
 
 procedure TMachine.OpcodeCopyConst64;
 var
-  Source: QWord;
+  Source: UInt64;
   Dest: TRegIndex;
 begin
   Dest := ReadNext8;
   Source := ReadNext64;
-  PQWord(@Registers[Dest])^ := Source;
+  PUInt64(@Registers[Dest])^ := Source;
 end;
 
@@ -453 +509 @@
   Dec(SP, SizeOf(TDataInt));
   PDataInt(@Memory[SP])^ := PDataInt(@Registers[Source])^;
+end;
+
+procedure TMachine.OpcodePush8;
+var
+  Source: TRegIndex;
+begin
+  Source := ReadNext8;
+  Dec(SP, SizeOf(Byte));
+  PUInt8(@Memory[SP])^ := PUInt8(@Registers[Source])^;
+end;
+
+procedure TMachine.OpcodePush16;
+var
+  Source: TRegIndex;
+begin
+  Source := ReadNext8;
+  Dec(SP, SizeOf(Word));
+  PUInt16(@Memory[SP])^ := PUInt16(@Registers[Source])^;
+end;
+
+procedure TMachine.OpcodePush32;
+var
+  Source: TRegIndex;
+begin
+  Source := ReadNext8;
+  Dec(SP, SizeOf(Cardinal));
+  PUInt32(@Memory[SP])^ := PUInt32(@Registers[Source])^;
+end;
+
+procedure TMachine.OpcodePush64;
+var
+  Source: TRegIndex;
+begin
+  Source := ReadNext8;
+  Dec(SP, SizeOf(QWord));
+  PUInt64(@Memory[SP])^ := PUInt64(@Registers[Source])^;
 end;
 
@@ -485 +577 @@
 begin
   Reg := ReadNext8;
-  PByte(@Registers[Reg])^ := PByte(@Registers[Reg])^ + 1;
+  PUInt8(@Registers[Reg])^ := PUInt8(@Registers[Reg])^ + 1;
 end;
 
@@ -493 +585 @@
 begin
   Reg := ReadNext8;
-  PWord(@Registers[Reg])^ := PWord(@Registers[Reg])^ + 1;
+  PUInt16(@Registers[Reg])^ := PUInt16(@Registers[Reg])^ + 1;
 end;
 
@@ -501 +593 @@
 begin
   Reg := ReadNext8;
-  PCardinal(@Registers[Reg])^ := PCardinal(@Registers[Reg])^ + 1;
+  PUInt32(@Registers[Reg])^ := PUInt32(@Registers[Reg])^ + 1;
 end;
 
@@ -509 +601 @@
 begin
   Reg := ReadNext8;
-  PQWord(@Registers[Reg])^ := PQWord(@Registers[Reg])^ + 1;
+  PUInt64(@Registers[Reg])^ := PUInt64(@Registers[Reg])^ + 1;
 end;
 
@@ -520 +612 @@
 end;
 
-procedure TMachine.OpcodeSkipNotZero;
+procedure TMachine.OpcodeTestNotZero;
 var
   Reg: TRegIndex;
 begin
   Reg := ReadNext8;
-  SkipNext := Registers[Reg] <> 0;
-end;
-
-procedure TMachine.OpcodeSkipZero;
+  Condition := Registers[Reg] <> 0;
+end;
+
+procedure TMachine.OpcodeTestZero;
 var
   Reg: TRegIndex;
 begin
   Reg := ReadNext8;
-  SkipNext := Registers[Reg] = 0;
+  Condition := Registers[Reg] = 0;
 end;
 
@@ -540 +632 @@
   RelAddr: TAddrInt;
 begin
-  OpcodeSkipNotZero;
+  RelAddr := ReadNextS;
+  IP := IP + RelAddr;
+end;
+
+procedure TMachine.OpcodeJumpAbs;
+var
+  Addr: TAddrInt;
+begin
+  Addr := ReadNext;
+  IP := Addr;
+end;
+
+procedure TMachine.OpcodeJumpRelCond;
+var
+  RelAddr: TAddrInt;
+begin
+  RelAddr := ReadNextS;
+  if Condition then IP := IP + RelAddr;
+end;
+
+procedure TMachine.OpcodeJumpRelCond8;
+var
+  RelAddr: Int8;
+begin
   RelAddr := ReadNextS8;
-  if not SkipNext then IP := IP + RelAddr;
-end;
-
-procedure TMachine.OpcodeJumpAbs;
+  if Condition then IP := IP + RelAddr;
+end;
+
+procedure TMachine.OpcodeJumpAbsCond;
 var
   Addr: TAddrInt;
 begin
-  OpcodeSkipNotZero;
   Addr := ReadNext;
-  if not SkipNext then IP := Addr;
+  if Condition then IP := Addr;
+end;
+
+procedure TMachine.OpcodeCallRel;
+var
+  RelAddr: TAddrInt;
+begin
+  RelAddr := ReadNextS;
+  Dec(SP, SizeOf(TAddrInt));
+  PAddrInt(@Memory[SP])^ := IP;
+  IP := IP + RelAddr;
+end;
+
+procedure TMachine.OpcodeCallAbs;
+var
+  Addr: TAddrInt;
+begin
+  Addr := ReadNext;
+  Dec(SP, SizeOf(TAddrInt));
+  PAddrInt(@Memory[SP])^ := IP;
+  IP := Addr;
+end;
+
+procedure TMachine.OpcodeCallRelCond;
+var
+  RelAddr: TAddrInt;
+begin
+  RelAddr := ReadNextS;
+  if Condition then begin
+    Dec(SP, SizeOf(TAddrInt));
+    PAddrInt(@Memory[SP])^ := IP;
+    IP := IP + RelAddr;
+  end;
+end;
+
+procedure TMachine.OpcodeCallAbsCond;
+var
+  Addr: TAddrInt;
+begin
+  Dec(SP, SizeOf(TAddrInt));
+  if Condition then begin
+    PAddrInt(@Memory[SP])^ := IP;
+    Addr := ReadNext;
+    IP := Addr;
+  end;
 end;
 
@@ -557 +715 @@
 begin
   raise Exception.Create('Unsupported instruction');
+end;
+
+procedure TMachine.OpcodeSetSize;
+begin
+  DataSize := dsNative;
+end;
+
+procedure TMachine.OpcodeSetSize8;
+begin
+  DataSize := ds8;
+end;
+
+procedure TMachine.OpcodeSetSize16;
+begin
+  DataSize := ds16;
+end;
+
+procedure TMachine.OpcodeSetSize32;
+begin
+  DataSize := ds32;
+end;
+
+procedure TMachine.OpcodeSetSize64;
+begin
+  DataSize := ds64;
 end;
 
@@ -572 +755 @@
 end;
 
+function TMachine.ReadNextS: TDataInt;
+begin
+  CheckIP;
+  Result := PDataInt(@Memory[IP])^;
+  Inc(IP, SizeOf(TDataInt));
+end;
+
 function TMachine.ReadNext8: Byte;
 begin
@@ -615 +805 @@
 end;
 
+procedure TInstructionWriter.AddDataS(Data: Int64);
+begin
+  PInt64(@(Machine.Memory[Addr]))^ := Data;
+  Inc(Addr, SizeOf(Int64));
+end;
+
 procedure TInstructionWriter.AddData8(Data: Byte);
 begin
@@ -634 +830 @@
 end;
 
+procedure TInstructionWriter.AddCopyConst8(Reg: TRegIndex; Value: UInt8);
+begin
+  AddData8(Integer(opSetSize8));
+  AddData8(Integer(opCopyConst));
+  AddData8(Reg);
+  AddData8(Value);
+end;
+
 procedure TInstructionWriter.AddGetDataSize(Reg: TRegIndex);
 begin
@@ -671 +875 @@
 end;
 
-procedure TInstructionWriter.AddJumpRelNotZero(Reg: TRegIndex; RelAddr: Integer
-  );
-begin
-  AddData8(Integer(opJumpRel));
+procedure TInstructionWriter.AddTestNotZero(Reg: TRegIndex);
+begin
+  AddData8(Integer(opTestNotZero));
   AddData8(Reg);
-  AddDataS8(RelAddr - 3);
+end;
+
+procedure TInstructionWriter.AddJumpRelCond(RelAddr: Integer);
+begin
+  AddData8(Integer(opJumpRelCond));
+  AddDataS(RelAddr - SizeOf(Byte) - SizeOf(TDataInt));
+end;
+
+procedure TInstructionWriter.AddJumpRelCond8(RelAddr: ShortInt);
+begin
+  AddData8(Integer(opSetSize8));
+  AddData8(Integer(opJumpRelCond));
+  AddDataS8(RelAddr - SizeOf(Byte) - SizeOf(TDataInt));
 end;