MINSK-2/MINSK-22 INSTRUCTION SET
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Data format:
The memory of the Minsk-2 machine consists of 4096 37-bit words (the topmost bit
is always used as a sign). The 0th memory cell is hard-wired to 0, writes
have no effect.
The Minsk-22 machine has 2 banks of 4096 37-bit words each.
Fixed-point numbers: sign and 36 significant bits
Binary floating-point numbers (from top to bottom bit):
sign of mantissa
28 bits of mantissa
1 bit unused
sign of exponent
6 bits of exponent
Decimal floating-point numbers (used only for printing):
sign of mantissa
28 bits of mantissa (7 decimal digits in BCD)
1 bit unused
sign of exponent
1 bit unused
5 bits of exponent (2 decimal digits in BCD, the former one truncated to 1 bit)
Registers:
Minsk-2/Minsk-22 has 3 registers:
accumulator usually keeps the result of the previous arithmetic operation
R1 usually copies one of the operand of the instruction
R2 contains the value of acc
(most programs use only the accumulator)
Generic instruction format: (by octal digits; some instructions deviate)
sop mm xxxx yyyy
| | | |
| | | +--- operand2
| | +----- operand1
| +------ indexing mode
+------- signed operation code
Indexing mode bits:
aa iiii
| |
| +---- index register: when non-zero, lower 12 bits of the memory
| cell #iiii are added to yyyy, next 12 bits are added to xxxx
+----- address extension (supported only on Minsk-22)
Address extension:
In Minsk-22 mode, the address extension bits can be used to access the second
bank of memory in the machine. Each of the bits selects the memory bank
(either 0 or 1) that one of the operands operate on:
The first (high) bit selects the memory bank for operand1 (x)
The second (low) bit selects the memory bank for operand2 (y)
The instruction pointer always operates on bank 0. This extends to situations
where a (jump) instruction sets the instruction pointer to either x or y; the
address extension bits are effectively ignored in those cases.
Similarly, the indexing word is always read from bank 0.
In Minsk-2 mode, setting the address extension bits to anything but 0 is an
error in all cases.
For arithmetic instructions, the lower 2 bits of encode addressing mode:
0?: arg_a = mem[y], arg_b = mem[x]
1?: arg_a = previous value of accumulator, arg_b = mem[x]
?0: store result to accumulator
?1: store result to both accumulator and mem[y]
Instructions:
+00 NOP
+04-07 a^b
+10-13 Fixed-point a+b
+14-17 Floating-point a+b
+20-23 Fixed-point a-b
+24-27 Floating-point a-b
+30-33 Fixed-point a*b
+34-37 Floating-point a*b
+40-43 Fixed-point a/b
+44-47 Floating-point a/b
+50-53 Fixed-point abs(a)-abs(b)
+54-57 Floating-point abs(a)-abs(b)
+60-63 a << b (b may be negative)
+64-67 a << b (b may be negative)
+70-73 a&b
+74-77 a|b
-00 HALT, store x to R1 and y to accumulator
-03 Magnetic tape I/O -- NOTIMP
-04 Disable rounding -- NOTIMP
-05 Enable rounding -- NOTIMP
-06 Interrupt control -- NOTIMP
-07 Reverse tape -- NOTIMP
-10 Move: mem[y] = acc = mem[x]
-11 Move negative: mem[y] = acc = -mem[x]
-12 Move absolute: mem[y] = acc = abs(mem[x])
-13 Read from keyboard -- NOTIMP
-14 Copy sign of mem[x] to mem[y]
-15 Read code from R1 (obscure) -- NOTIMP
-16 Copy exponent of mem[x] to mem[y]
-17 Teletype I/O -- NOTIMP
-20 Loop: uses the index register mem[i] for loop control:
mem[i] is divided to 3 12-bit fields nnnn pppp qqqq,
mem[y] is likewise diveded to fields rrrr ssss tttt.
If n=0, the instruction does nothing
otherwise, mem[i] is written back with:
n' = n-1
p' = p+s mod 4096
q' = q+t mod 4096
and jump to address x.
-30 Jump: mem[y]=acc and jump to address x
-31 Jump to subroutine at address x, store backward jump instruction to mem[y]
-32 Jump by sign: if acc>=0, jump to x, else jump to y
-33 Jump by overflow: if overflow, jump to y, else jump to x
(we always halt on overflow, so this is rather trivial)
-34 Jump by zero: if acc==0, jump to y, else jump to x
-35 Jump by keypress: if key pressed, jump to x, else jump to y
(no keys are emulated)
-36 Interrupt masking -- NOTIMP
-37 Tape I/O -- NOTIMP
-40-47 Various I/O -- NOTIMP
-60-61 Various I/O -- NOTIMP
-62 Printing instructions, depending on x:
0aaa put decimal float mem[y] at position aaa in the buffer
1aaa put octal integer mem[y]
2aaa put decimal integer mem[y]
3aaa put decimal integer mem[y], leading zeroes changed to spaces
4aaa put one Russian symbol stored in 6 topmost bits of mem[y]
5aaa put Russian text in mem[y] (6 6-bit characters)
6aaa put one Latin symbol stored in 6 topmost bits of mem[y]
7aaa put Latin text in mem[y] (6 6-bit characters)
z400 print contents of the buffer
bit 0 of z: perform line feed afterwards
bit 1 of z: clear buffer afterwards
bit 2 of z: if 0, nothing is printed
Hence, 2400 just clears the buffer, 5400 is a linefeed with
no effect on the contents of the buffer etc.
-63 I/O -- NOTIMP
-70 Fixed-point a*b, take bottom part; result always to acc
(what is the sign? the book is silent...)
-71 acc = a%b
-72 Add exponent of mem[x] to mem[y], copy mem[y] to acc
-73 Sub exponent of mem[x] from mem[y], copy mem[y] to acc
-74 Addition in one's complement: mem[y] = mem[x] + mem[y]
-75 Normalization: convert fixed-point mem[x] to floating-point mem[y]
-76 Population count: set mem[y] to number of bits in mem[x]