Download BASIC COMPILATION TECHNIQUES It is useful to understand how

BASIC COMPILATION TECHNIQUES
It is useful to understand how a high-level language program is translated into
instructions. Since implementing an embedded computing system often requires
controlling the instruction sequences used to handle interrupts, placement of data
and instructions in memory, and so forth, understanding how the compiler works
can help you know when you cannot rely on the compiler. Next, because many
applications are also performance sensitive, understanding how code is generated
can help you meet your performance goals, either by writing high-level code that
gets compiled into the instructions you want or by recognizing when you must
write your own assembly code. Compilation combines translation and
optimization. The high-level language program is translated into the lower-level
form of instructions; optimizations try to generate better instruction sequences than
would be possible if the brute force technique of independently translating source
code statements were used.
Optimization techniques focus on more of the program to ensure that compilation
decisions that appear to be good for one statement are not unnecessarily
problematic for other parts of the program. The compilation process is summarized
in Figure 5.11. Compilation begins with high-level language code such as C and
generally produces assembly code. (Directly producing object code simply
duplicates the functions of an assembler, which is a very desirable stand-alone
program to have.) The high-level language program is parsed to break it into
statements and expressions. In addition, a symbol table is generated, which
includes all the named objects in the program. Some compilers may then perform
higher-level optimizations that can be viewed as modifying the high-level language
program input without reference to instructions. Simplifying arithmetic expressions
is one example of a machine-independent optimization. Not all compilers do such
optimizations, and compilers can vary widely regarding which combinations of
machine-independent optimizations they do perform. Instruction-level
optimizations are aimed at generating code. They may work directly on real
instructions or on a pseudo-instruction format that is later mapped onto the
instructions of the target CPU. This level of optimization also helps modularize the
compiler by allowing code generation to create simpler code that is later optimized.
Statement Translation
In this section, we consider the basic job of translating the high-level language
program with little or no optimization. Let’s first consider how to translate an
expression. A large amount of the code in a typical application consists of
arithmetic and logical expressions. We made an arbitrary allocation of variables to
registers for simplicity. When we have large programs with multiple expressions,
we must allocate registers more carefully since CPUs have a limited number of
registers we also need to be able to translate control structures. Since conditionals
are controlled by expressions, the code generation techniques of the last example
can be used for those expressions, leaving us with the task of generating code for
the flow of control itself.
Procedures
Another major code generation problem is the creation of procedures. Generating
code for procedures is relatively straightforward once we know the procedure
linkage appropriate for the CPU. At the procedure definition, we generate the code
to handle the procedure call and return. At each call of the procedure, we set up the
procedure parameters and make the call.
The CPU’s subroutine call mechanism is usually not sufficient to directly support
procedures in modern programming languages. The linkage mechanism provides a
way for the program to pass parameters into the program and for the procedure to
return a value. It also provides help in restoring the values of registers that the
procedure has modified. All procedures in a given programming language use the
same linkage mechanism (although different languages may use different
linkages). The mechanism can also be used to call handwritten assembly language
routines from compiled code. Procedure stacks are typically built to grow down
from high addresses. A stack pointer (sp) defines the end of the current frame,
while a frame pointer (fp) defines the end of the last frame. (The fp is technically
necessary only if the stack frame can be grown by the procedure during execution.)
The procedure can refer to an element in the frame by addressing relative to sp.
When a new procedure is called, the sp and fp are modified to push another frame
onto the stack.
The ARM Procedure Call Standard (APCS) is a good illustration of a typical
procedure linkage mechanism. Although the stack frames are in main memory,
understanding how registers are used is key to understanding the mechanism, as
explained below.
■ r0_r3 are used to pass parameters into the procedure. r0 is also used to hold the
return value. If more than four parameters are required, they are put on the stack
frame.
■ r4 _ r7 hold register variables.
■ r11 is the frame pointer and r13 is the stack pointer.
■ r10 holds the limiting address on stack size, which is used to check for stack
overflows. Other registers have additional uses in the protocol.