What is the origin of different styles of assembly language mnemonics?

Question

As exemplified in answers to this question (I hope that closed questions that are linked to, don't get purged), the instruction mnemonics in early assembly languages had a 1-to-1 correspondence to the machine instructions they denoted.

For example, if the memory access instructions have different opcodes depending on the direction of the data transfer, there will be assembly instructions with an abbreviation of "load" and of "store" in their names, like LDA for "load accumulator" and STA for "store accumulator".

On the other hand, one of the x86 assembly languages could use the same mnemonic MOV for the whole group of data transfer instructions which encompass several different bit patterns in their opcodes, be it a load or a store. The actual meaning of the instruction is then represented by the order and the type of the operands. This can be thought of as a step up in the level of the language, sparing the programmer from remembering the gory details of the instruction set architecture.

Which architecture/platform was the first to have this kind of a "smart" assembly language?

Also, at the bottom of this answer there seems to be an example of an assembly language program for the IAS machine with formulas serving as mnemonics, e. g. S(x)->R for loading from memory. It appears that this style was used in the IAS emulator, but it is unclear if there was an assembler program on the actual machine that understood these mnemonics (doubtful, as in the late 1940s or early 1950s is would be too wasteful to use a 7-character mnemonic where a 2-character one would do).

Were there actual assembly languages that used formula-style instruction mnemonics rather than abbreviations of words, e. g. something like MTR (Memory To register R) instead of what would be LDR as a "conventional" mnemonic, and RTM (register R To Memory) instead of what would be STR, etc.?

Answer 1

The CDC 6000 series, starting with the CDC 6600 introduced in September 1964 (13 years before the Z80), had a somewhat unique assembly format: The "opcode field" consisted of a prefix denoting a function followed by a register name, and the "operand field" consisted of one or two arguments (register names or constants), combined with +, *, - or / like a mathematical formula. There were three sets of registers, A (address), B (increment) and X (data).

Here is an example taken from page 67 (page 74 of the PDF) of Ralph Grishman: Assembly Language Programming for the Control Data 600 and Cyber Series, that implements the standard Fortran funcion IDIM (truncated subtraction):

        IDENT   IDIM
        ENTRY   IDIM
IDIM    BSS     1
        SA2     A1+1      X2 = address of second argument
        SA1     X1        X1 = first argument
        SA2     X2        X2 = second argument
        IX6     X1-X2     X6 = ARG1-ARG2
        PL      X6,IDIM   if ARG1-ARG2 positive, return
        SX6     B0        else set result=0
        EQ      IDIM      and return
        END

And different combinations of symbols and register would get assembled to different opcodes, e.g. (octal opcode in first column):

50   SAi  Aj+K      Set Ai to Aj + K
51   SAi  Bj+K      Set Ai to Bj + K
...
74   SXi  Aj+Bk     Set Xi to Aj + Bk
75   SXi  Aj-Bk     Set Xi to Aj - Bk

A full summary can be found on page 2 of the Reference Manual.

A complete assembly environment called COMPASS with macros and pseudo-instructions was available.

Answer 2

Most probably it was the Z80 that actually tried to (and succeeded to) orthoginalize an already existing assembler language, that of the Intel 8080.

8080 assembly language used mnemonics that were different all over the place:

• MOV, STA and LDA for register moves, Accumulator Load and Store
• LXI for register pair load and store
• MVI for moving immediate data into registers

On the Z80, this was all just flattened to LD (Load) plus appropriate arguments, while using the very same opcodes. Similar changes were done to other mnemonics.

Other quirks were

• ADD and SUB looked different whether the operands were immediate or registers
• and quite some more quirky and hard to remember mnemonics...

which were also "fixed" and straightened in Z80 assembly.

So LXI B,0FFH, MOV A,B, STAX , MVI A,0ffh were all different ways on the 8080 to move data into or from registers or register pairs.

Z80 assembly translated all of these to a simple LD <destination>,<source>

So for the very same opcode, compatible with the 8080, the Z80 used different (and much more systematically built) assembler mnemonics that could actually fulfil the promise of their name and be memorizable. This most probably made the assembler quite a bit more complicated (after all, it had to find out what the operand types were in order to find the proper opcode, while the 8080 had the operand types embedded in the mnemonics), but made life way easier for the programmer.

Beyond that, the Z80 did have quite some operations the 8080 didn't have, like relative jumps and quite a number of very useful block transfer commands (but that was not the question)