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]