Changeset 7 for branches/bigint

Timestamp:

Aug 1, 2024, 11:47:03 PM (5 months ago)

Author:

chronos

Message:

• Added: More instructions implemented.

Location:

branches/bigint

Files:

• Assembler.pas (modified) (1 diff)
• Cpu.pas (modified) (10 diffs)
• Disassembler.pas (modified) (1 diff)
• Example.asm (modified) (2 diffs)
• Instructions.pas (modified) (3 diffs)

branches/bigint/Assembler.pas

@@ -213 +213 @@
         ParseNumParam(Token);
       end else
+      if InstructionInfo.Params[I] = ptIndirect2 then begin
+        Parser.Expect(tkSpecialSymbol, '((');
+        Parser.Expect(tkSpecialSymbol, '(');
+        Token := Parser.ReadNext;
+        if TryStrToInt(Token.Value, Number) then
+          Memory.WritePos(Number)
+          else Error('Expected numeric index error', Token.Pos);
+        Parser.Expect(tkSpecialSymbol, '))');
+        Parser.Expect(tkSpecialSymbol, '))');
+      end else
       if InstructionInfo.Params[I] = ptIndirect then begin
         Parser.Expect(tkSpecialSymbol, '(');

branches/bigint/Cpu.pas

@@ -10 +10 @@
 
   TInstruction = (inNop, inHalt, inLoad, inLoadConst, inInput, inOutput,
-    inJump, inJumpZero, inJumpNotZero, inInc, inDec);
+    inJump, inJumpZero, inJumpNotZero, inInc, inDec, inLoadIndex, inPush, inPop,
+    inCall, inRet, inLoadMem, inStoreMem);
 
   { TCpu }
@@ -25 +26 @@
     procedure InstructionLoad;
     procedure InstructionLoadConst;
+    procedure InstructionLoadIndex;
+    procedure InstructionLoadMem;
+    procedure InstructionStoreMem;
     procedure InstructionInput;
     procedure InstructionOutput;
@@ -32 +36 @@
     procedure InstructionJumpZero;
     procedure InstructionJumpNotZero;
+    procedure InstructionPush;
+    procedure InstructionPop;
+    procedure InstructionCall;
+    procedure InstructionRet;
     procedure WriteMem(Address, Data: TInt);
     function ReadMem(Address: TInt): TInt;
@@ -37 +45 @@
     procedure WriteIo(Address, Data: TInt);
     function ReadIo(Address: TInt): TInt;
+    procedure Push(Data: TInt);
+    function Pop: TInt;
   public
     Halted: Boolean;
@@ -83 +93 @@
 end;
 
+procedure TCpu.InstructionLoadIndex;
+var
+  Dst, Src, Index: TInt;
+begin
+  Dst := ReadMemPc;
+  Src := ReadMemPc;
+  Index := ReadMemPc;
+  WriteMem(Dst, ReadMem(Src + Index));
+end;
+
+procedure TCpu.InstructionLoadMem;
+var
+  Dst, Src: TInt;
+begin
+  Dst := ReadMemPc;
+  Src := ReadMemPc;
+  WriteMem(Dst, ReadMem(ReadMem(Src)));
+end;
+
+procedure TCpu.InstructionStoreMem;
+var
+  Dst, Src: TInt;
+begin
+  Dst := ReadMemPc;
+  Src := ReadMemPc;
+  WriteMem(ReadMem(Dst), ReadMem(Src));
+end;
+
 procedure TCpu.InstructionInput;
 var
@@ -119 +157 @@
 procedure TCpu.InstructionJump;
 begin
-  PC := ReadMem(ReadMemPc);
+  PC := ReadMemPc;
 end;
 
@@ -140 +178 @@
   Addr := ReadMemPc;
   if ReadMem(Condition) <> 0 then PC := Addr;
+end;
+
+procedure TCpu.InstructionPush;
+begin
+  Push(ReadMem(ReadMemPc));
+end;
+
+procedure TCpu.InstructionPop;
+begin
+  WriteMem(ReadMemPc, Pop);
+end;
+
+procedure TCpu.InstructionCall;
+var
+  Addr: TInt;
+begin
+  Addr := ReadMemPc;
+  Push(PC);
+  PC := Addr;
+end;
+
+procedure TCpu.InstructionRet;
+begin
+  PC := Pop;
 end;
 
@@ -170 +232 @@
 end;
 
+procedure TCpu.Push(Data: TInt);
+begin
+  Dec(SP);
+  WriteMem(SP, Data);
+end;
+
+function TCpu.Pop: TInt;
+begin
+  Result := ReadMem(SP);
+  Inc(SP);
+end;
+
 procedure TCpu.Reset;
 begin
   PC := 0;
-  SP := 0;
+  SP := 1000;
   Halted := False;
 end;
@@ -198 +272 @@
   Instructions[inHalt] := InstructionHalt;
   Instructions[inLoad] := InstructionLoad;
+  Instructions[inLoadIndex] := InstructionLoadIndex;
   Instructions[inLoadConst] := InstructionLoadConst;
+  Instructions[inLoadMem] := InstructionLoadMem;
+  Instructions[inStoreMem] := InstructionStoreMem;
   Instructions[inInput] := InstructionInput;
   Instructions[inOutput] := InstructionOutput;
@@ -206 +283 @@
   Instructions[inInc] := InstructionInc;
   Instructions[inDec] := InstructionDec;
+  Instructions[inPush] := InstructionPush;
+  Instructions[inPop] := InstructionPop;
+  Instructions[inCall] := InstructionCall;
+  Instructions[inRet] := InstructionRet;
 end;
 

branches/bigint/Disassembler.pas

@@ -54 +54 @@
           if InstructionInfo.Params[I] = ptIndirect then begin
             InstText := InstText + '(' + IntToStr(Value) + ')';
+          end else
+          if InstructionInfo.Params[I] = ptIndirect2 then begin
+            InstText := InstText + '((' + IntToStr(Value) + '))';
           end else raise Exception.Create('Unsupported instruction parameter type');
         end;

branches/bigint/Example.asm

@@ +1 @@
+  LDC  (1000), Text
+  CALL PrintText
+  LDC  (1000), Text
+  CALL PrintText
+  CALL PrintInc
+  CALL PrintInc
+  HALT
+
+
+PrintInc:
   LDC  (1000), 65
   LDC  (1001), 30
@@ -6 +16 @@
   DEC  (1001)
   JPNZ (1001), Label
-  HALT
+  RET
+
+PrintText:
+  LDM  (1001), ((1000))
+  JPZ  (1001), Label2
+  OUT  (0), (1001)
+  INC  (1000)
+  JP   PrintText
+Label2:
+  RET
+
+Text:
+  DB 'Text ', 0

branches/bigint/Instructions.pas

@@ -7 +7 @@
 
 type
-  TParamType = (ptNone, ptNumber, ptIndirect);
+  TParamType = (ptNone, ptNumber, ptIndirect, ptIndirect2);
   TParamTypeArray = array of TParamType;
 
@@ -74 +74 @@
   AddNew(inHalt, 'HALT', [], 'It terminates program execution and halts processor. Processor can be waked up by interrupt.');
   AddNew(inLoadConst, 'LDC', [ptIndirect, ptNumber], 'Loads constant into address location.');
-  AddNew(inLoad, 'LD', [ptIndirect, ptIndirect], 'Copies value from one register to another.');
+  AddNew(inLoadIndex, 'LDI', [ptIndirect, ptIndirect, ptNumber], 'Loads value from one memory location with added relative index to another.');
+  AddNew(inLoad, 'LD', [ptIndirect, ptIndirect], 'Loads value from one memory location to another.');
+  AddNew(inLoadMem, 'LDM', [ptIndirect, ptIndirect2], 'Loads value from one indirect memory location to another.');
+  AddNew(inStoreMem, 'STM', [ptIndirect2, ptIndirect], 'Stotes value to indirect memory location from source location.');
   AddNew(inInc, 'INC', [ptIndirect], 'Increments value in specified register.');
   AddNew(inDec, 'DEC', [ptIndirect], 'Decrements value in specified register.');
@@ -82 +85 @@
   AddNew(inJumpZero, 'JPZ', [ptIndirect, ptNumber], 'Jumps to given address if value of register is zero');
   AddNew(inJumpNotZero, 'JPNZ', [ptIndirect, ptNumber], 'Jumps to given address if value of register is not zero');
+  AddNew(inPush, 'PUSH', [ptIndirect], 'Push memory location onto stack.');
+  AddNew(inPop, 'POP', [ptIndirect], 'Pop item from stack and store it into memory location.');
+  AddNew(inCall, 'CALL', [ptNumber], 'Call subroutine.');
+  AddNew(inRet, 'RET', [], 'Return from subrotine.');
 end;