1 MINSK-2/MINSK-22 INSTRUCTION SET
2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5 The memory of the Minsk-2 machine consists of 4096 37-bit words (the topmost bit
6 is always used as a sign). The 0th memory cell is hard-wired to 0, writes
9 The Minsk-22 machine has 2 banks of 4096 37-bit words each.
11 Fixed-point numbers: sign and 36 significant bits
13 Binary floating-point numbers (from top to bottom bit):
21 Decimal floating-point numbers (used only for printing):
24 28 bits of mantissa (7 decimal digits in BCD)
28 5 bits of exponent (2 decimal digits in BCD, the former one truncated to 1 bit)
33 Minsk-2/Minsk-22 has 3 registers:
35 accumulator usually keeps the result of the previous arithmetic operation
36 R1 usually copies one of the operand of the instruction
37 R2 contains the value of acc
39 (most programs use only the accumulator)
42 Generic instruction format: (by octal digits; some instructions deviate)
48 | +------ indexing mode
49 +------- signed operation code
56 | +---- index register: when non-zero, lower 12 bits of the memory
57 | cell #iiii are added to yyyy, next 12 bits are added to xxxx
58 +----- address extension (supported only on Minsk-22)
63 In Minsk-22 mode, the address extension bits can be used to access the second
64 bank of memory in the machine. Each of the bits selects the memory bank
65 (either 0 or 1) that one of the operands operate on:
67 The first (high) bit selects the memory bank for operand1 (x)
68 The second (low) bit selects the memory bank for operand2 (y)
70 The instruction pointer always operates on bank 0. This extends to situations
71 where a (jump) instruction sets the instruction pointer to either x or y; the
72 address extension bits are effectively ignored in those cases.
74 Similarly, the indexing word is always read from bank 0.
76 In Minsk-2 mode, setting the address extension bits to anything but 0 is an
80 For arithmetic instructions, the lower 2 bits of <sop> encode addressing mode:
82 0?: arg_a = mem[y], arg_b = mem[x]
83 1?: arg_a = previous value of accumulator, arg_b = mem[x]
84 ?0: store result to accumulator
85 ?1: store result to both accumulator and mem[y]
92 +10-13 Fixed-point a+b
93 +14-17 Floating-point a+b
94 +20-23 Fixed-point a-b
95 +24-27 Floating-point a-b
96 +30-33 Fixed-point a*b
97 +34-37 Floating-point a*b
98 +40-43 Fixed-point a/b
99 +44-47 Floating-point a/b
100 +50-53 Fixed-point abs(a)-abs(b)
101 +54-57 Floating-point abs(a)-abs(b)
102 +60-63 a << b (b may be negative)
103 +64-67 a << b (b may be negative)
106 -00 HALT, store x to R1 and y to accumulator
107 -03 Magnetic tape I/O -- NOTIMP
108 -04 Disable rounding -- NOTIMP
109 -05 Enable rounding -- NOTIMP
110 -06 Interrupt control -- NOTIMP
111 -07 Reverse tape -- NOTIMP
112 -10 Move: mem[y] = acc = mem[x]
113 -11 Move negative: mem[y] = acc = -mem[x]
114 -12 Move absolute: mem[y] = acc = abs(mem[x])
115 -13 Read from keyboard -- NOTIMP
116 -14 Copy sign of mem[x] to mem[y]
117 -15 Read code from R1 (obscure) -- NOTIMP
118 -16 Copy exponent of mem[x] to mem[y]
119 -17 Teletype I/O -- NOTIMP
120 -20 Loop: uses the index register mem[i] for loop control:
121 mem[i] is divided to 3 12-bit fields nnnn pppp qqqq,
122 mem[y] is likewise diveded to fields rrrr ssss tttt.
123 If n=0, the instruction does nothing
124 otherwise, mem[i] is written back with:
128 and jump to address x.
129 -30 Jump: mem[y]=acc and jump to address x
130 -31 Jump to subroutine at address x, store backward jump instruction to mem[y]
131 -32 Jump by sign: if acc>=0, jump to x, else jump to y
132 -33 Jump by overflow: if overflow, jump to y, else jump to x
133 (we always halt on overflow, so this is rather trivial)
134 -34 Jump by zero: if acc==0, jump to y, else jump to x
135 -35 Jump by keypress: if key pressed, jump to x, else jump to y
136 (no keys are emulated)
137 -36 Interrupt masking -- NOTIMP
138 -37 Tape I/O -- NOTIMP
139 -40-47 Various I/O -- NOTIMP
140 -60-61 Various I/O -- NOTIMP
141 -62 Printing instructions, depending on x:
142 0aaa put decimal float mem[y] at position aaa in the buffer
143 1aaa put octal integer mem[y]
144 2aaa put decimal integer mem[y]
145 3aaa put decimal integer mem[y], leading zeroes changed to spaces
146 4aaa put one Russian symbol stored in 6 topmost bits of mem[y]
147 5aaa put Russian text in mem[y] (6 6-bit characters)
148 6aaa put one Latin symbol stored in 6 topmost bits of mem[y]
149 7aaa put Latin text in mem[y] (6 6-bit characters)
150 z400 print contents of the buffer
151 bit 0 of z: perform line feed afterwards
152 bit 1 of z: clear buffer afterwards
153 bit 2 of z: if 0, nothing is printed
154 Hence, 2400 just clears the buffer, 5400 is a linefeed with
155 no effect on the contents of the buffer etc.
157 -70 Fixed-point a*b, take bottom part; result always to acc
158 (what is the sign? the book is silent...)
160 -72 Add exponent of mem[x] to mem[y], copy mem[y] to acc
161 -73 Sub exponent of mem[x] from mem[y], copy mem[y] to acc
162 -74 Addition in one's complement: mem[y] = mem[x] + mem[y]
163 -75 Normalization: convert fixed-point mem[x] to floating-point mem[y]
164 -76 Population count: set mem[y] to number of bits in mem[x]