The Univac Solid State Computer 90, the instructions.


                       Printout of a program-simulation. (This quality of printing was normal.)

The CPU instructions.

A program of the USSC consisted out of a chain of instructions, each instruction pointing to the one succeeding.
Each instruction existed of one word of ten digits with a sign.
From the left these digits contained:
1 & 2  :    ic,       - the instruction code
3 - 6    :    m,      - the operand address  M, (M-memory)
7 - 10  :    c,       - the address of the next instruction C, (C-continuation).

Notation:
  M  C    			= address parts of the instructions.
 (M) or m 		= The operand address, digits 3 to 6 of the instruction-word.
 (m)				= The operand, the value stored in the address M, a signed ten digit number 
 (C) or c			= The address containing the next instruction.
  rA, rx and rL		= the three registers in which the calculations and the comparisons took place.
 (rA),(rX),(rL)		= the contents of the registers.


A program in machine-code could look like this:
(a=address of the instruction, ic=instruction code,  (m)=operand address, (c)=address of next instruction) 

   a    ic   M      C        meaning:
0200 72 0301 0204    Feed and read punch-card
0204 96 4000 0399    Transfer buffer to interlace adresses in the 4000-band
0399 25 4001 0203    Load register A, rA with first card-word from 4001
0203 05 4006 0208    Load rX with lower part of first card-word from 4006
0208 12 0000 0211    Translate (rA&rX) into machine code to rA
0211 31 0214 0000    Load zero's into rL
0214 82 0300 0500    Compare, when the card-word was empty or contained zeroes, then continue at 0300, else 0500
etc.

While the instruction
25  m  c          loaded register rA with the contents of  memory-adress (m)  and the program continued in (c), 
it had several derivates for different functions obtained by altering single bits:

  26 m -           - loaded rA with zeros and the program continued on (m), not on (c).
  29 m c          - used operand-address (m)+(IR0)      (+indexregister 0).
 -25 m c          - used operand-address (m)+(IR1)      (+indexregister 1).
 -29 m c          - used operand-address (m)+(IR2)      (+indexregister 2).
  25 000K c     - transferred (rX) to rA, since 000K was the adress of rX.


program form.
German programmers manual
An executable program existed of a sequence of 10 digit words in memory, linked in order of execution by the continuation-adresses.

List of the instruction set of the USSC90

00 - adress of the next instruction in M, jump to (M) 02 - load indexregister with (M), with the address-part of the instruction. 05 - load rX with (m), with the number in memory-address m. 06 - load rX with zeroes 07 - increment indexregister with (M), copy result to M of rA 11 - printer: print line from memory after paper advance 12 - translate RR-card-code to machine-code, translate RR in (rA & rX) to MC in rA 16 - printer: paper advance only 17 - translate machine-code to card/print-code, translate MC in (rA) to RR in rA & rX 20 - logical: (m) OR (rA) to rA 22 - Read-Punch: test read-buffer being written, if yes: call subroutine 23 - call subroutine, (rC) > rA, the instruction is duplicated in rA. 25 - load rA with (m) 26 - load zeroes into rA 27 - Printer: test buffer being printed, if yes: call subroutine 30 - load rL with (m) 31 - load zeroes into rL 32 - shift (rX) & (rA) right N places, rA and rX behave as a circle 35 - logical: (rA) AND (m) to rA 37 - shift (rA) left N places 42 - Card-reader: test buffer loaded, if yes: call subroutine 46 - Read-Punch: transfer read-buffer into memory in the interlace adresses 47 - Card-reader: select stacker 50 - store (rL) to (m) 55 - divide (m) by (rL) 57 - Read-Punch: select stacker 60 - store (rA) to (m) 62 - zero suppress of RR-code in (rA & rX), take away zeroes and commas left of the most significant digit 65 - store (rX) to (m) 67 - stop 70 - add (m) to (rA) 72 - Card-reader: feed one card, read and write to buffer 73 - return from subroutine, jump to (C), the address in the C-part. 75 - substract (m) from (rA) 77 - move (rA) to rL 81 - Read-Punch: execute cycle (read, punch and read), transfer interlace adresses to buffer and punch buffer 82 - compare (rA)=(rL) and branch to (M) or (C) 85 - multiply (rL) x (m) MSD to rA and LSD to rX (Most Significant Digit and Least Significant Digit) 87 - compare (rA) > (rL) and branch to (M) or (C) 96 - Card-reader: transfer buffer into memory to the interlace adresses
Menu:
.Home .CPU .Punchcards .Software .Calculations .Indexregisters .Codecard