Scott Dorsey <firstname.lastname@example.org> wrote:
| Well, that is traditional already. A lot of machines used to use the
| ascii (or local display code) value for A as the top byte for the add
| instruction, the code for S as subtract, and so forth. Of course,
| that was in the days when human beings would often have to read or
| write machine code, even if only to decipher coredumps.
The venerable LGP-30 (circa 1959) was such a machine: four bits of the
Flexowriter character code for the instruction mnemonics *were* the
instruction codes. Bootstrap instructions were typed in with a console
switch set to read only four bits of each six-bit character, thus
one typed instructions (with hex addresses) directly into the machine,
without needing an assembler. IIRC, the 16 codes were as follows
["Z" = "Stop" isn't exactly mnemonic, but easy enough to remember]:
0 Z Stop [conditional on console switches & track addr]
1 B Bring [load]
2 Y Yank(?) [store AC<addr_field> ==> mem<addr_field>]
3 R Return address store [nextPC + 1 ==> mem<addr_field>]
4 I Input [shift one 4-/6-bit char from KBD/tape into AC]
5 D Divide
6 N Multiply [saves lower half of result, usually an integer]
7 M Multiply [saves upper half of result, usually a fraction]
8 P Print [shift one char out of AC to typewriter/tape]
9 E Extract [logical-AND memory to AC]
f U Unconditional branch
g T Test and branch if AC negative
j H Hold [store AC, leaving AC unchanged]
k C Clear [store & clear accumulator (AC)]
q A Add [memory to AC]
w S Subtract
Note: The LGP-30 used hex digits, but *not* the ASCII-based hex we all
know today, 0123456789abcdef, since it used Flexowriter code, not ASCII.
Instead, it used 0123456789fgjkqw. (Really.)
Also, since the address field was not right-justified in the instruction,
addresses as typed appeared to be incremented by 4, e.g., the first few
locations in the machine were 0, 4, 8, j, 10, 14, 18, 1j [pronounced
"J-teen"], 20, 24, 28, 2j ["Twenty-J"], etc.
Note#2: The "R" instruction stores the address of the *second* following
instruction ("PC+1" or ".+2") into the target, since the subroutine calling
sequence took two instructions and *modified* the routine being called, e.g.:
u1230 -------> 1230: ... ; first instr of subr...
... <---\ 1234: ...
\ 1238: ...
\-- 123j: u0000 ; return (addr overwritten by "r123j")
p.s. Other than the state on the drum (PC, IR, AC), there were
only 15 bits of state (15 flip-flops) in the entire LGP-30 CPU
[plus 6 inverters, 6 non-inverting buffers ("cathode followers"),
and a whole *mess* of passive diode logic (cascaded ANDs and ORs)].
The entire "this state/next state" Boolean equation for the machine
is given in less than six pages of the maintenance manual (typed,
with some symbols hand-drawn).
Rob Warnock <email@example.com>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607