Issues in the design of a code generator

Code generator converts the intermediate representation of source code

into a form that can be readily executed by the machine. A code generator
is expected to generate the correct code. Designing of the code generator
should be done in such a way that it can be easily implemented, tested,
and maintained.

The following issue arises during the code generation phase:

Input to code generator – The input to the code generator is the

intermediate code generated by the front end, along with information in
the symbol table that determines the run-time addresses of the data
objects denoted by the names in the intermediate representation.
Intermediate codes may be represented mostly in quadruples, triples,
indirect triples, Postfix notation, syntax trees, DAGs, etc. The code
generation phase just proceeds on an assumption that the input is free
from all syntactic and state semantic errors, the necessary type checking
has taken place and the type-conversion operators have been inserted
wherever necessary.

 Target program: The target program is the output of the code

generator. The output may be absolute machine language,
relocatable machine language, or assembly language.

o Absolute machine language as output has the advantages that

it can be placed in a fixed memory location and can be
immediately executed. For example, WATFIV is a compiler that
produces the absolute machine code as output.

o Relocatable machine language as an output allows

subprograms and subroutines to be compiled separately.
Relocatable object modules can be linked together and loaded
by a linking loader. But there is added expense of linking and
loading.

o Assembly language as output makes the code generation

easier. We can generate symbolic instructions and use the
macro-facilities of assemblers in generating code. And we
need an additional assembly step after code generation.

 Memory Management – Mapping the names in the source

program to the addresses of data objects is done by the front end
and the code generator. A name in the three address statements
refers to the symbol table entry for the name. Then from the symbol
table entry, a relative address can be determined for the name.
 Instruction selection – Selecting the best instructions will improve the
efficiency of the program. It includes the instructions that should be
complete and uniform. Instruction speeds and machine idioms also play a
major role when efficiency is considered. But if we do not care about the
efficiency of the target program then instruction selection is
straightforward. For example, the respective three-address statements
would be translated into the latter code sequence as shown below:

P:=Q+R

S:=P+T

MOV Q, R0

ADD R, R0

MOV R0, P

MOV P, R0

ADD T, R0

MOV R0, S

Here the fourth statement is redundant as the value of the P is loaded

again in that statement that just has been stored in the previous
statement. It leads to an inefficient code sequence. A given intermediate
representation can be translated into many code sequences, with
significant cost differences between the different implementations. Prior
knowledge of instruction cost is needed in order to design good
sequences, but accurate cost information is difficult to predict.

 Register allocation issues – Use of registers make the

computations faster in comparison to that of memory, so efficient
utilization of registers is important. The use of registers is
subdivided into two subproblems:

1. During Register allocation – we select only those sets of variables

that will reside in the registers at each point in the program.

2. During a subsequent Register assignment phase, the specific

register is picked to access the variable.

To understand the concept consider the following three address code

sequence

t:=a+b

t:=t*c
t:=t/d

Their efficient machine code sequence is as follows:

MOV a,R0

ADD b,R0

MUL c,R0

DIV d,R0

MOV R0,t

1. Evaluation order – The code generator decides the order in which

the instruction will be executed. The order of computations affects
the efficiency of the target code. Among many computational
orders, some will require only fewer registers to hold the
intermediate results. However, picking the best order in the general
case is a difficult NP-complete problem.

2. Approaches to code generation issues: Code generator must

always generate the correct code. It is essential because of the
number of special cases that a code generator might face. Some of
the design goals of code generator are:

 Correct

 Easily maintainable

 Testable

 Efficient

Disadvantages in the design of a code generator:

Limited flexibility: Code generators are typically designed to produce a

specific type of code, and as a result, they may not be flexible enough to
handle a wide range of inputs or generate code for different target
platforms. This can limit the usefulness of the code generator in certain
situations.

Maintenance overhead: Code generators can add a significant

maintenance overhead to a project, as they need to be maintained and
updated alongside the code they generate. This can lead to additional
complexity and potential errors.

Debugging difficulties: Debugging generated code can be more difficult

than debugging hand-written code, as the generated code may not always
be easy to read or understand. This can make it harder to identify and fix
issues that arise during development.
Performance issues: Depending on the complexity of the code being
generated, a code generator may not be able to generate optimal code
that is as performant as hand-written code. This can be a concern in
applications where performance is critical.

Learning curve: Code generators can have a steep learning curve, as

they typically require a deep understanding of the underlying code
generation framework and the programming languages being used. This
can make it more difficult to onboard new developers onto a project that
uses a code generator.

Over-reliance: It’s important to ensure that the use of a code generator

doesn’t lead to over-reliance on generated code, to the point where
developers are no longer able to write code manually when necessary.
This can limit the flexibility and creativity of a development team, and
may also result in lower quality code overall.