Changeset 59 for branches/ByteArray/Instructions.pas

Timestamp:

Nov 25, 2023, 11:47:52 PM (12 months ago)

Author:

chronos

Message:

• Fixed: Assembler and disassembler to work correctly with supported instructions.

File:

• branches/ByteArray/Instructions.pas (modified) (5 diffs)

branches/ByteArray/Instructions.pas

@@ -7 +7 @@
 
 type
-  TParamType = (ptNone, ptNumber, ptReg, ptRegIndirect, ptRegIndirectIndex,
-    ptSize);
+  TParamType = (ptNone, ptRegIndirectIndex, ptRegIndirect, ptReg,
+    ptDataWidth, ptAddressWidth, ptData, ptAddress);
   TParamTypeArray = array of TParamType;
 
@@ -18 +18 @@
   end;
 
-  { TInstructionSet }
+  { TInstructionInfos }
 
-  TInstructionSet = class
-    Items: TObjectList<TInstructionInfo>;
-    function SearchName(Name: string): TInstructionInfo;
+  TInstructionInfos = class(TObjectList<TInstructionInfo>)
+    function SearchByName(Name: string): TInstructionInfo;
+    function SearchByNameMultiple(Name: string): TInstructionInfos;
     function SearchInstruction(Instruction: TInstruction): TInstructionInfo;
     function AddNew(Instruction: TInstruction; Name: string;
       Params: TParamTypeArray; Description: string): TInstructionInfo;
-    constructor Create;
-    destructor Destroy; override;
+    procedure Init;
   end;
+
+const
+  ParamTypeString: array[TParamType] of string = ('None', 'Data', 'Address',
+    'Register', 'Indirect register', 'Indirect indexed register',
+    'Data width', 'Address width');
 
 
 implementation
 
-{ TInstructionSet }
+{ TInstructionInfos }
 
-function TInstructionSet.SearchName(Name: string): TInstructionInfo;
+function TInstructionInfos.SearchByName(Name: string): TInstructionInfo;
 var
   I: Integer;
 begin
   I := 0;
-  while (I < Items.Count) and (Items[I].Name <> Name) do Inc(I);
-  if I < Items.Count then Result := Items[I]
+  while (I < Count) and (Items[I].Name <> Name) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
 
-function TInstructionSet.SearchInstruction(Instruction: TInstruction
+function TInstructionInfos.SearchByNameMultiple(Name: string
+  ): TInstructionInfos;
+var
+  I: Integer;
+begin
+  Result := TInstructionInfos.Create(False);
+  for I := 0 to Count - 1 do
+    if Items[I].Name = Name then Result.Add(Items[I]);
+end;
+
+function TInstructionInfos.SearchInstruction(Instruction: TInstruction
   ): TInstructionInfo;
 var
@@ -51 +65 @@
 begin
   I := 0;
-  while (I < Items.Count) and (Items[I].Instruction <> Instruction) do Inc(I);
-  if I < Items.Count then Result := Items[I]
+  while (I < Count) and (Items[I].Instruction <> Instruction) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
 
-function TInstructionSet.AddNew(Instruction: TInstruction; Name: string;
+function TInstructionInfos.AddNew(Instruction: TInstruction; Name: string;
   Params: TParamTypeArray; Description: string): TInstructionInfo;
 begin
@@ -64 +78 @@
   Result.Params := Params;
   Result.Description := Description;
-  Items.Add(Result);
+  Add(Result);
 end;
 
-constructor TInstructionSet.Create;
+procedure TInstructionInfos.Init;
 begin
-  Items := TObjectList<TInstructionInfo>.Create;
+  Clear;
   AddNew(inNop, 'NOP', [], 'No operation - The instruction doesn''t do anything.');
   AddNew(inHalt, 'HALT', [], 'It terminates program execution and halts processor. Processor can be waked up by interrupt.');
-  AddNew(inLoadConst, 'LD', [ptReg, ptNumber], 'Sets register to immediate constant value.');
-  AddNew(inLoadConstSize, 'LD', [ptSize, ptReg, ptNumber], 'Sets register to immediate constant value.');
+  AddNew(inLoadConst, 'LD', [ptReg, ptData], 'Sets register to immediate constant value.');
+  AddNew(inLoadConstSize, 'LD', [ptDataWidth, ptReg, ptData], 'Sets register to immediate constant value.');
   AddNew(inLoad, 'LD', [ptReg, ptReg], 'Copies value from one register to another.');
+  AddNew(inLoadSize, 'LD', [ptDataWidth, ptReg, ptReg], 'Copies value from one register to another.');
+  AddNew(inLoadMem, 'LD', [ptReg, ptRegIndirect], 'Loads value from memory to register.');
+  AddNew(inLoadMemSize, 'LD', [ptDataWidth, ptReg, ptRegIndirect], 'Loads value from memory to register.');
+  AddNew(inStoreMem, 'LD', [ptRegIndirect, ptReg], 'Stores value from register to memory.');
+  AddNew(inStoreMemSize, 'LD', [ptDataWidth, ptRegIndirect, ptReg], 'Stores value from register to memory.');
+  AddNew(inLoadMemIndex, 'LD', [ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
+  AddNew(inLoadMemIndexSize, 'LD', [ptDataWidth, ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
+  AddNew(inStoreMemIndex, 'LD', [ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
+  AddNew(inStoreMemIndexSize, 'LD', [ptDataWidth, ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
   AddNew(inInc, 'INC', [ptReg], 'Increments value in specified register.');
+  AddNew(inIncSize, 'INC', [ptDataWidth, ptReg], 'Increments value in specified register.');
   AddNew(inDec, 'DEC', [ptReg], 'Decrements value in specified register.');
-  AddNew(inLoadMem, 'LD', [ptReg, ptRegIndirect], 'Loads value from memory to register.');
-  AddNew(inStoreMem, 'ST', [ptRegIndirect, ptReg], 'Stores value from register to memory.');
+  AddNew(inDecSize, 'DEC', [ptDataWidth, ptReg], 'Decrements value in specified register.');
   AddNew(inAdd, 'ADD', [ptReg, ptReg], 'Adds second register to first register.');
+  AddNew(inAddSize, 'ADD', [ptDataWidth, ptReg, ptReg], 'Adds second register to first register.');
   AddNew(inSub, 'SUB', [ptReg, ptReg], 'Subtracts second register from first register.');
+  AddNew(inSubSize, 'SUB', [ptDataWidth, ptReg, ptReg], 'Subtracts second register from first register.');
   AddNew(inInput, 'IN', [ptReg, ptRegIndirect], 'Reads value from input port to register.');
   AddNew(inOutput, 'OUT', [ptRegIndirect, ptReg], 'Writes value from register to output port.');
-  AddNew(inJumpZero, 'JZ', [ptReg, ptNumber], 'Jumps to given address if value of register is zero');
-  AddNew(inJumpNotZero, 'JNZ', [ptReg, ptNumber], 'Jumps to given address if value of register is not zero');
+  AddNew(inJumpZero, 'JZ', [ptReg, ptAddress], 'Jumps to given address if value of register is zero');
+  AddNew(inJumpNotZero, 'JNZ', [ptReg, ptAddress], 'Jumps to given address if value of register is not zero');
   AddNew(inPush, 'PUSH', [ptReg], 'Pushes value of register to top of the stack.');
+  AddNew(inPushSize, 'PUSH', [ptDataWidth, ptReg], 'Pushes value of register to top of the stack.');
   AddNew(inPop, 'POP', [ptReg], 'Pops value of register from top of the stack.');
-  AddNew(inCall, 'CALL', [ptNumber], 'Calls subroutine at given address. Stores return address to the stack.');
+  AddNew(inPopSize, 'POP', [ptDataWidth, ptReg], 'Pops value of register from top of the stack.');
+  AddNew(inCall, 'CALL', [ptAddress], 'Calls subroutine at given address. Stores return address to the stack.');
+  AddNew(inCallSize, 'CALL', [ptAddressWidth, ptAddress], 'Calls subroutine at given address. Stores return address to the stack.');
   AddNew(inRet, 'RET', [], 'Return from subroutine. Reads return address from top of the stack to IP register.');
+  AddNew(inRetSize, 'RET', [ptAddressWidth], 'Return from subroutine. Reads return address from top of the stack to IP register.');
   AddNew(inAnd, 'AND', [ptReg, ptReg], 'Bitwise AND operation. Result is stored in first parameter.');
+  AddNew(inAndSize, 'AND', [ptDataWidth, ptReg, ptReg], 'Bitwise AND operation. Result is stored in first parameter.');
   AddNew(inOr, 'OR', [ptReg, ptReg], 'Bitwise OR operation. Result is stored in first parameter.');
+  AddNew(inOrSize, 'OR', [ptDataWidth, ptReg, ptReg], 'Bitwise OR operation. Result is stored in first parameter.');
   AddNew(inXor, 'XOR', [ptReg, ptReg], 'Bitwise XOR operation. Result is stored in first parameter.');
-  AddNew(inXor, 'SHL', [ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
-  AddNew(inXor, 'SHR', [ptReg, ptReg], 'Shifts all bits to the right in first register by n bits according value of second register.');
+  AddNew(inXorSize, 'XOR', [ptDataWidth, ptReg, ptReg], 'Bitwise XOR operation. Result is stored in first parameter.');
+  AddNew(inShl, 'SHL', [ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
+  AddNew(inShlSize, 'SHL', [ptDataWidth, ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
+  AddNew(inShr, 'SHR', [ptReg, ptReg], 'Shifts all bits to the right in first register by n bits according value of second register.');
+  AddNew(inShrSize, 'SHR', [ptDataWidth, ptReg, ptReg], 'Shifts all bits to the right in first register by n bits according value of second register.');
   AddNew(inMul, 'MUL', [ptReg, ptReg], 'Multiplies first register with second register value.');
+  AddNew(inMulSize, 'MUL', [ptDataWidth, ptReg, ptReg], 'Multiplies first register with second register value.');
   AddNew(inDiv, 'DIV', [ptReg, ptReg], 'Diviedes first register with second register value.');
+  AddNew(inDivSize, 'DIV', [ptDataWidth, ptReg, ptReg], 'Diviedes first register with second register value.');
   //AddNew(inMod, 'MOD', [ptReg, ptReg], 'Returns modulo in first registr after division of values.');
-  AddNew(inJump, 'JP', [ptNumber], 'Unconditional absolute jump to defined address.');
-  AddNew(inJumpRel, 'JR', [ptNumber], 'Unconditional relative jump to defined address.');
-  //AddNew(inLoadIndex, 'LDI', [ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
-  //AddNew(inStoreIndex, 'STI', [ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
+  AddNew(inJump, 'JP', [ptAddress], 'Unconditional absolute jump to defined address.');
+  AddNew(inJumpSize, 'JP', [ptAddressWidth, ptAddress], 'Unconditional absolute jump to defined address.');
+  AddNew(inJumpRel, 'JR', [ptAddress], 'Unconditional relative jump to defined address.');
+  AddNew(inJumpRelSize, 'JR', [ptAddressWidth, ptAddress], 'Unconditional relative jump to defined address.');
   //AddNew(inLoadCpu, 'LDC', [], 'Loads value from system register.');
   //AddNew(inStoreCpu, 'STC', [], 'Stores value to system register.');
@@ -107 +143 @@
 end;
 
-destructor TInstructionSet.Destroy;
-begin
-  FreeAndNil(Items);
-  inherited;
-end;
-
 end.