RISC (Reduced Instruction-Set Chip) vs. CISC

[Martin Weitzel]

In article <72969 at eerie.acsu.Buffalo.EDU> jones at acsu.buffalo.edu (terry a jones) writes:

>	One thing to keep in mind also, is the fact that RISC compiled objects
>are generally larger than their CISC counterparts would be.  Makes good sense
>to me, since there are fewer instructions for the compiler implementer to
>use, his code sequences will generally require more of them.  I don't have
>any hard figures available at the moment.  I'm sure that I could come up
>with some if the need arose.  I recall figures of approx. 30% in some of the
>recent literature that I have read.

IMHO that depends on the compiler. A little more than ten years ago, when I
started to get in touch with some UNIX-like system, it was on a 6809-
microprocessor (the name of this particular OS was UniFLEX, if anyone on
the net cares).

The other popular microprocessors in this time were the 8080 and Z80. I think
it's not wrong to say the 6809 was more like a RISC, the 8080 and the 8086
were more like CISC processors. In these days there existed a very decent C-
Compiler for the 6809 (written by James McCosh) which produced fairly
efficient code for the 6809. As I was told this was due to the 'orthogonal
structure' of the machine instructions of the 6809 (again compared to
its competitors) which meant that the compiler could use every instruction
whith each of the available adressing modes.

For a compiler the problem with the 8080 and Z80 was that the numerous
instructions could only combined with certain adressing modes. Because
it was difficult to teach the compilers which instructions could be
used with which adressing modes, the compiler writers 'played safe', ie.
they only used some percentage of the possible instructions. (Note
that - unless you take cross-compilers into consideration - on a micro-
processor with limited resources you couldn't make the compilers super-
smart!)

On the other hand, the 6809 lend itself very much to compilers, because
every machine instruction could be combined with every adressing mode.
It was much pleisure to see how the McCosh-C-Compiler compiled a section
of source which read more or less like:

	int (*ftab[256])(), i, z;
	....
	z = (*ftab[i])();

Again: If some compiler fully exploits the capabilities of a CISC-machine,
the size of code may be less (if the length of the machine instructions
were tuned against typical usage frequence - which again depends on the
application), but in general RISC-machines are not that much worse than
it might seem.
-- 
Martin Weitzel, email: martin at mwtech.UUCP, voice: 49-(0)6151-6 56 83