Simple Computer Simulator Instruction-Set

--D. Thiebaut (talk) 16:57, 26 August 2014 (EDT)

---

This page documents all the instructions that are supported by the Simple Computer Simulator shown below. You can click on the image to go to the Javascript simulator. This simulator is used in the CSC103 How Computers Work course at Smith College.
The instructions are presented in functional groups, rather than in logical ones, so that simple programs can be created with just the first 3 groups, allowing more programming sophistication as subsequent groups are explored.

Simple Computer Simulator

An Instruction that stops Programs

Every program must stop execution at some point. The way to do this is to have a special instruction that stops the execution. In our case, this instruction is HALT. In the simulator, the HALT forces animation to stop and prevents the Step button to operate. In real computers, there is an instruction similar to HALT that actually forces operating system to take over the computer, and remove the program from memory, making the space it was occupying available for other programs the user may want or need to load.

Instruction	Code (decimal)	Code ( binary)	Description
HALT	127	01111111	This instruction forces the processor to stop when the program ends. A program should always have a HALT instruction. While it is most often found at the end of a program, it can also be found inside the program when sophisticated loops are used.

Instructions Using the Accumulator and a Number

These instructions operate with a single number (we refer to them as constants) that is either loaded into, added, or subtracted from the accumulator register.

Instruction	Code (decimal)	Code ( binary)	Description
ADD number	24	00011000	This instruction adds the number to the one already in the accumulator. For example, if the accumulator register already contains 10, and the processor executes ADD 3 the result is that the accumulator will contain 13 after the instruction.
DIV number	44	00101100	This instruction divides the contents of the accumulator by number, and keeps the integer part of the result. For example, if the accumulator register already contains 10, and the processor executes DIV 4 the result is that the accumulator will contain 2 after the instruction.
LOAD number	4	00000100	This instruction puts the number into the accumulator. Whatever was in the accumulator prior to the operation is lost. , if the accumulator register already contains 10, and the processor executes ADD 3 the result is that the accumulator will contain 13 after the instruction.
MUL number	40	00101000	This instruction multiplies the contents of the accumulator by number, and replaces the contents of the accumulator by the result. For example, if the accumulator register already contains 10, and the processor executes MUL 4 the result is that the accumulator will contain 40 after the instruction.
SUB number	32	00100000	This instruction subtracts the number from the one already in the accumulator. For example, if the accumulator register already contains 10, and the processor executes SUB 3 the result is that the accumulator will contain 7 after the instruction.

Instructions Using the Accumulator and Memory

These instructions are followed by a number in brackets. This number refers to the location, or address in memory where the actual operand is located. So, if the number following the instruction is [100], it means that the instruction will use whatever number is stored at 100. A simple analogy might help here. Think of the difference between these two statements:

"Please read the book The Little Prince."

and the statement

"Please read the book from the library, with Call Number PQ2637.A274 P4613 2000".

Both statements refer to reading the same book. The first one refers to the book directly. The instructions in the section above operate similarly with their operands. The second statement refers to the book indirectly, by giving you its address in the library. The instructions in this section perform the same way. By putting brackets around the numbers that follow the instructions, we indicate that the numbers used are not the actual numbers we want to combine with the accumulator, but the address of the cells where we will find the numbers of interest.

This may still be a bit obscure, but read on the description for each instruction and this will hopefully become a bit clearer.

Instruction	Code (decimal)	Code ( binary)	Description
ADD [address]	26	00011010	This instruction is similar to ADD number, except that now the number to add to the accumulator is located in the memory at the address specified in the instruction. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction ADD [20] adds 4 to 10, resulting in 14, which becomes the new contents of the accumulator.
DIV [address]	46	00101110	This instruction is similar to DIV number, except that now the the accumulator is divided by the number located in the memory at the address specified in the instruction. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction DIV [20] divides 10 by 4, which results in 2. Fractional parts are not kept by our processor. In fact this is true also of real processors such as Intel's Pentium: only integers are stored in registers. Numbers with a decimal part require more sophisticated instructions and binary systems. This is beyond what we want to explore in this course.
LOAD [address]	6	00000110	This instruction loads the number stored in memory at the address specified in the instruction, and puts it in the accumulator. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction LOAD [20] replaces 10 in the accumulator by the number 4.
MUL [address]	42	00101010	This instruction multiplies the contents of the accumulator by the number stored in memory at the specified address. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction MUL [20] replaces the contents of the accumulator by 4 x 10, or 40.
STORE [address]	18	00010010	This instruction makes a copy of the contents of the accumulator and stores it in memory at the address specified. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction STORE [20] replaces the contents of the memory cell at Address 20 with the number 10. The accumulator value does not change.
SUB [address]	34	00100010	This instruction subtracts the number stored in memory at the specified address from the number stored in the accumulator. For example, if the memory cell at Address 20 contains 10, and if the accumulator contains 40, then the instruction SUB [20] replaces the contents of the accumulator with 40 - 10, or 30.

Instructions Manipulating the Index Register

The Index, IX in the simulator, is a register in the processor that contains numbers, just as the Accumulator does. However, the numbers in the index represent addresses of cells containing numbers. The Index is useful is situations where we have several numbers in consecutive memory locations, and we want to perform the same operation on each one, say add 1 to each of the numbers. In this case we store in the Index the address of the first number, say, 100, and operate on that number through the Index. We'll need new instructions for that, but for right now we just want to see how we can load numbers in the index.

Instruction	Code (decimal)	Code ( binary)	Description
ADDX number	28	00011100	This instruction adds a number to the contents of the Index register. For example, if the Index register contains the number 10, then ADDX 1 will add 1 to 10, and the Index will contain 11 after the instruction is executed.
ADDX [address]	30	00011110	This instruction is similar to the one above, except that the value that is added to the contents of IX comes from a memory cell whose address is given in the instruction. For example, if IX contains 10, and the memory cell at Address 20 contains 5, then ADDX [20] will result in replacing the contents of IX with 10+5, or 15.
LOADX number	8	00001000	This instruction sets the contents of the Index to the number. For example, LOADX 10 will result in the number 10 appearing inside the Index register.
STOREX [address]	22	00010110	This instruction makes a copy of the contents of the Index register and saves it in a cell whose address is the one specified in the instruction. If IX contains 10, then the instruction STOREX [20] will copy the number 10 in the memory cell at Address 20. This does not affect the contents of IX. It does not get change by the copy operation.
SUBX number	36	00100100	This instruction subtracts a number from the contents of the Index register. For example, if the Index register contains the number 10, then SUBX 1 will subtract 1 from 10, and the Index will contain 9 after the instruction is executed.
SUBX [address]	38	00100110	Similarly to the way ADDX [address], this instruction takes the quantity found in memory at the location specified by address and subtracts it from the contents of the IX register.

The Jump instruction

The jump instruction forces the processor to continue executing instructions at the address specified in the instruction. For example, JUMP 30 forces the processor to go to Address 30 and take the instruction it finds there as the new instruction to execute. It will then continue on with the executions that sequentially follow the one at Address 30.

Instruction	Code (decimal)	Code ( binary)	Description
JUMP address	64	01000000	Forces the processor to continue execution at the location specified: address.

Compare and Jump-If Instructions

The compare and jump-If instructions operate together. We always want to use them together to test conditions and execute one sequence of instruction or another. When programming, when we want to test something we need to create two paths for the execution of the program. One path will be taken if the test is true (say, is the contents of the accumulator less than 10), and another path if it is false.

For example, imagine that we do not know if the number in the Accumulator contains a number greater than 100. If so, we'll want to stop the program, otherwise we'll want to continue with some more computation

...
10: COMP  100
12: JLT 16
14: HALT
16: some more computation
...

The instruction at Address 10 compares the contents of the accumulator to 100. Some information about this comparison is kept inside the processor. The next instruction, at Address 12, is JLT 16. Its behavior is to force the processor to jump to Address 16 if, and only if, the result of the previous comparison is true, i.e. the accumulator is less than 100. If the accumulator is actually less than 100, the processor will jump to Address 16 and execute some more instructions. Otherwise, if the accumulator contains a number equal to or greater than 100, then it simply does not jump. And since a processor always execute instuctions in sequence, it moves on to the next instruction which is HALT and which forces it to stop.

Instruction	Code (decimal)	Code ( binary)	Description
COMP number	84	01010100	This instruction compares the number to the one already in the accumulator. For example, if the accumulator register already contains 10, and the processor executes COMP 3 the result is the comparison of 10 to 3. 10 is greater, and is not equal to 3. This will prevent a JLT (jump if less than) to jump to its target, and will prevent a JEQ instruction from jumping. On the other hand, if the accumulator had contained 2, then a COMP 2 would have allowed a subsequent JEQ instruction to jump to its target.
COMP [address]	86	01010110	This instruction is similar to COMP number, except that now the number which is compared to the accumulator is located in the memory at the address specified in the instruction. For example, if the memory cell at Address 20 contains 4, and if the accumulator contains 10, then the instruction COMP [20] compares 10 to 4.
COMPX number	92	01011100	This instruction is similar to COMP number , except that the comparison is performed between IX and the number.
COMPX address	94	01011110	This instruction is similar to COMP [address] , except that the comparison is performed between IX and the number stored at the given address in memory.
JEQ address	68	01000100	If the result of the previous comparison is that the two quantities were equal, then this instruction makes the processor jump to the address specified. If the result of the comparison is that the two quantities were different, the processor moves on to the next instruction in memory.
JLT address	72	01001000	If the result of the previous comparison is that the contents of the Accumulator is less than the quantity it is compared to, then this instruction makes the processor jump to the address specified. If the result of the comparison is that the value in the Accumulator is equal to, or greather than the second quantity, then the processor moves on to the next instruction in memory.

Register-Exchange Instructions

These instructions allow the programmer to copy the contents of the Accumulator in the Index register, and vice versa.

Instruction	Code (decimal)	Code ( binary)	Description
TAX	79	01001111	Transfer Accumulator into Index. The contents of the Index register is erased and the value contained in the Accumulator is copied there.
TXA	83	01010011	Transfer Index to Accumulator. The contents of the Accumulator register is erased and the value contained in the Index is copied there.

Other Instructions

These instructions are not essential for writing programs that solve problems. However, they might make it easier for the programmer in some cases. We list them all together here, but provide them only for those interested in writing more sophisticated programs than we feel is necessary in this course.

Instruction	Code (decimal)	Code ( binary)	Description
ADDX [X], number	29	00011101
ADDx	25	00011001
COMPXx	93	01011101
DIVx	45	00101101
LOADXm	10	00001010
LOADXx	9	00001001
LOADx	5	00000101
MULx	41	00101001
STOREXx	21	00010101
STOREx	17	00010001
SUBXx	37	00100101
SUBx	33	00100001

Miscellaneous Instructions

Most processor supports an instruction that doesn't do anything. It is often used for padding programs.

Instruction	Code (decimal)	Code ( binary)	Description
NOP	0	00000000