🚀 go-pugleaf

From article <BRUCE.89Jul18181114@heather.pooh.com>, by bruce@heather.pooh.com (Bruce Robertson):
> These optimizations have been mentioned:
> [1]	Value propagation (get values from where cheapest, remember what
> 	values appear where and which quantities are equivalent)
> [2]	Constant folding (also uses value prop.:  A=5; B=A*A; would get
> 	coded as if it were A=5; B=25;)
> [3]	Common subexpression elimination
> [4]	Dead code elimination (get rid of dead stores, etc.)

They may have been mentioned, but I didn't mention them.  All the
above are machine independent (except perhaps [1], which relates
to register allocation).  The optimizations I mentioned were:

(A)   Instruction selection (if several different sequences of instructions
      can perform a given action - which is best?)

(B)   Register allocation (store intermediate results in registers if at
      all possible).

(C)   Code ordering (issue the instructions in the order which best uses
      pipelining or other parellelism in the archetecture).

Any one of the above is fairly easy to do in isolation.  Any two of the
above are difficult to do because they interfere with each other.  Only
CISC archetectures even have to consider (A) since, in a RISC, this
step is _very_ simple.  I claim that CISC compilers must do all three
of the above in order to be competitive.  Hence, my claim that CISC is
harder to compile for than RISC.