Re: Why VAX Was the Ultimate CISC and Not RISC

Stephen Fuld <sfuld@alumni.cmu.edu.invalid> writes:

I wonder if the different preferences is at least partially due to
whether the person has a hardware or a software background?  The idea is
that when hardware guys see the instruction, they think in terms of
register ports (read versus write), what is required of the memory
system (somewhat different for loads versus stores), etc.  However
software guys think of a language construct, e.g. X = Y, which is
logically a move.  I don't know if this is right, but I think it is
interesting.

I am a software person.  When talking about register-memory copies, I
prefer to talk about load and store operations, whether I talk about
assembly language (even one where the mnemonic for these operations is
MOV) or C; in Forth the spoken names for these operations are "fetch"
(written: @) and "store" (written: !).

My first programming was on the TI-58C programmable calculator, which
has RCL (recall) and STO (store).

Then some BASIC, where you write A = Expr.

Then some 6502 assembly language, which has, e.g., LDA (load into
accumulator) and STA (store from accumulator).

In his HOPL paper Ritchie describes a number of competitors of C
(e.g., BLISS), most of which make the use of addresses explicit,
unlike C.  So copying from one variable to another in one of these
languages was along the lines of

a = .b

where a and b are addresses of variables, and "." fetches the value
from the address (i.e., C's *).  C won out over these languages, and
it seems to me that Ritchie thought that the different approach in C
with lexprs and (value) exprs was a major contributing factor.

Back to assembly languages:

In PDP-11-style architectures (e.g., 8086, IA-32, AMD64, 68000), where
you have instructions of the form

op r  ,m/r
op m/r,r

it's pretty obvious that you implement load, store, and
register-register copy as special cases of this scheme.  And the
common mnemonic for these three operations in all these architectures
is MOV.  This does not come out of higher-level software
considerations, this comes out of the architecture, and how to
implement the assembler and disassembler for it in the simplest way.

By contrast, RISC architectures do not follow this scheme, so they
have mnemonics starting with L (for load) and S (for store).

Looking at <https://www.righto.com/2023/08/datapoint-to-8086.html>,
the Datapoint 2200 and the 8008 called both LAM (load A from M(emory))
and LMA (store A to M(emory)) a load.  This continues in the 8008.
The 8080 assembly language replaces LAM with MOV A,M and LMA with
MOV A,M.  On the 8086 they are replaced with MOV AL,[BX] and
MOV [BX],AL.

A somewhat related question, if one wants to copy the contents of R3
into R2, is that a load or a store? :-)

It's a register-register copy.

- anton
--
'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
  Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>