FAST Forth Native-Language Embedded Computers

MOV
MOV
EBX, offset v16
EBX, [EBXI
These instructions can be
replaced by the single code
instruction:
MOV EBX, vl
Another common situation
occurs where a variable's contents
are accessed, then consumed
by the following word.
For example, the sequence vl
@ + might generate the following
code without combining:
MOV EBX, offset vl
MOV EBX, [EBXI
ADD EAX, EBX
When combining is used,
the above three-machine-code
instructions are replaced with a
single instruction:
ADD EAX, vl
Other combinations are possible
as well. For example, an
index may be scaled, then added
to the base address of an array
of 32-bit values; the indexed
element is then accessed. An
example is the sequence
arrayl vl @ 4* + @ (where
array 1 returns the starting
address of an array of 32-bit
values). The resulting generated
code could take advantage
of the indexed addressing mode
to allow otherwise-separate instructions
to be combined:
MOV EBX, vl
MOV EBX, arrayll4*EBXl
Figure Three. Code generated by swap with and without preceding drop. I
state = 1 state =6 state = 1 state =6
ldrop]
I=]
(drop generates no code itself, but it
changes the stack state to 0 before
swap generates its code!)
It also makes sense to perform
computations involving
literals during code generation.
For example, the word sequence
c 1 4 * 1+ + (where c 1
is defined by the phrase 30
constant c 1) may generate the code instruction:
ADD 121 (cl = 30, so4 * cl + 1 = 121)
This also applies to address calculations, such as for the
sequence arrayl 20 + @:
MOV EBX, arrayl+20
Another situation where combining code instructions is
particularly useful occurs when a test is followed immediately
by a control-structure word such as i f or until. The
need to generate an explicit flag is thus eliminated, and the
test plus control-structure branch can often be reduced to
For those of you not familiar with lnlel assembler notation, the use of offset
before an address value causes the address value to be treated as a literal. If
an address value is not preceded by offset, the corresponding memory
location is accessed instead. However, a non-address value does not need
offset to be treated as a literal.
Figure Four. Illustration of the virtual offset.
Initial Voffs (virtual offset) = zero
new
value
Initial Push 2 items Pop 1 item Pop 2 items Pop 1 item Update
to memor from memory from memory from memory pointer
(~offs-=EY (Voffs+=.l) (Voffs +=8) (Voffs +=4) (Voff s=O)
from two to four instructions. For example, the sequence =
if ... then might generate the following code:
MOV EBX, (ED11
ADD EDI, 4
CMP EAX, EBX
JNE -LBL-nnn
(-LBL-nnn is a compiler-generated jump label)
Of course, a comparison with a literal or constant value
generates even simpler code. For example, the sequence
8 < if ... then might generate the following code:
CMP EAX, 8
JNL - LBL-nnn
...
March 1994 April 38 Forth Dimensions