FAST Forth Native-Language Embedded Computers

Figure Five. Examples of rectifying the stack state and Voffs value for various control-structure jumps. I
{ssX, VoffsX) = stack state #X;
Voffs value vX
I -LBL-nnn:
To implement the combining of machine instructions,
the compiler looks for sequences of simple Forth words
that could potentially generate combinable instructions. In
practice, an array is used to retain up to some maximum
number of entries that contain tokens for words that have
been recently parsed off during compilation, but for which
no machine code has yet been generated. When the array
is full, a pattern-matching scan is started on the array,
beginning with the first entry. A set of code-generating
patterns is matched, one pattern at a time, against the
array's contents. Longer patterns are scanned before
shorter ones, but the matched pattern must always begin
with the first entry in the array. Since patterns are defined
for all possible single tokens, at least one token in the array
is guaranteed to be matched.
When a matching pattern is found in the array, the
-~- -
In order to avoid the overhead of actually moving array entries down after
earlier entrtes have been removed, thearray should, in practice, beimplemented
as acircular queue. The length of the array should be at least equal to the length
of the longest code-generating pattern. However, the use of "tokens" permits
the individual entries in both the array and the patterns to be reduced down to
one or two bytes apiece: it also speeds up the process of matching patterns to
the array's contents.
In the case of literal or constant values (including the starting addresses of
arrays), the associated values may be kept in a separate, parallel array, where
each entry is 32 bits (four bytes). For certain commonly used constants, such
as 0, 1,2, and -1, special "tokens" may be used that permit generation of code
that can be optimized for the presence of such constants.
I matched entries are removed from the array, and the
remaining entries are moved down to fill in the vacated
entries.' (If computations involving literals or constants
are involved, the removed entries may instead be replaced
by a smaller number of entries.) The matched pattern is
associated with the code to be generated for that pattern.
Since at least one entry will now be vacant at the end of
the array, the compiler can then continue to parse off at
least one additional word. Note that pattern-matching on
the array is performed only when it is full, or when the
compiler must force the entire array to be compiled into
code and then emptied. The latter situation may occur
when a non-simple word (such as another compiled
word) is called from the currently compiled word, when
an exit is encountered, or when a branch target is
reached. Figure Six illustrates an example of the patternmatching
process for a simple (if contrived) setup.8
8 There are two additional areas where optimizations may have a significant
impact. The first area is in replacing multiplications by "small" constants with
sequences of shifts, additions, and/or subtractions. The second area involves
the multiplication of a loop index by a constant value; the multiplication of the
index can be replaced by maintenance of a "shadow" index in parallel with the
"regular" loop index. (Multiple "shadow" indexes may be associated with a
single "regular" index.)
Both of these areas of optimization are beyond the scope of this article.
Interested readers are referred to the sections on code optimization in the book
Principles of Compiler Design by Aho and Ullman, published by Addison-
Wesley. (Computer science students may recognize this book as the infamous
"dragon book" because of the cover design.)
Forth Dimensions 39 March 1994 April