I'm developing an optimiser for the new version of win32forth that
employs the method of simulating at compile time (using smart compile,)
the stack effects of basic blocks. Anton has several papers that discuss
this method (the RAFTS papers) and I believe VFX using a similar (the
same?) technique.

http://www.complang.tuwien.ac.at/papers/ertl&pirker96.ps.gz

I've grasped the idea of "before" and "after" stacks, and building a
data flow graph from the primitives, with the following fairly simple
classes of words;

Class 1. execute stack manipulation words that have no side effects
(such as modifying memory) such as DUP SWAP etc.
Class 2. don't execute, but add to the DFG by popping/pushing based on
the word's stack effects and point to the operands on the stack.
Class 3. terminate at other words and build a DFG for the basic block

The bit I can't get my noddle around are parsing words like TO and S" .
Here's the output from my intelligent compile, parse tree for TO

0 value y ok
: x 10 to y ;

outputs the tree for x of

Alex McDonald wrote:

Elizabeth D Rather wrote:

Alex McDonald rivadpm.com> writes:

You just treat them as roots in the graph. The order in which your
process the various roots is (partially) determined by the dependences
through memory.

- anton

Alex McDonald rivadpm.com> writes:

For the modern Intel/AMD CPUs I would probably leave the instruction
scheduling away for simplicity (the hardware performs scheduling, and
instruction scheduling tends to increase the register pressure). I
might be tempted to leave the graph away and generate code directly,
but that may cost quite a bit of performance (no instruction
selection, only register allocation); one could get a part of
instruction selection back through some variant of peephole
optimization.

Anton Ertl wrote: