Cooper K.Engineering a compiler

the array, the lower bound of each dimension, and all but one of the dimension sizes. With the address polynomial based on the false zero, the lower bound information is unnecessary. As long as the compiler always uses the same form of the polynomial, it can generate code to build the dope vectors as part of the prologue code for the procedure call.

A given procedure can be invoked from multiple call sites. At each call site, a di erent array might be passed. The pl/i fragment in figure 8.7 illustrates this. The program main contains two statements that call fee. The first passes array x, while the second passes y. Inside fee, the actual parameter (x or y) is bound to the formal parameter A. To allow the code for fee to reference the appropriate location, it needs a dope vector for A. The respective dope vectors are shown on the right hand side of the figure.

As a subtle point, notice that the cost of accessing an array-valued parameter is higher than the cost of accessing an array declared locally. At best, the dope vector introduces additional memory references to access the relevant entries. At worst, it prevents the compiler from performing certain optimizations that rely on complete knowledge of the array’s declaration.

8.5.4Range Checking

Most programming language definitions assume, either explicitly or implicitly, that a program only refers to array elements within the defined bounds of the array. A program that references an out-of-bounds element is, by definition, not well formed. Many compiler-writers have taken the position that the compiler should detect out-of-bounds array accesses and report them in a graceful fashion to the user.

array reference. The test verifies that each index value falls in the valid range for the dimension in which it will be used. In an array-intensive program, the overhead of such checking can be significant. Many improvements on this simple scheme are possible.

If the compiler intends to perform range checking on array-valued parameters, it may need to include additional information in the dope vectors. For example, if the compiler uses the address polynomial based on the array’s false zero, it will have lengths for each dimension, but not upper and lower bound information. An imprecise test might be done by checking the o set against the total array size; to perform the precise test would require passing upper and lower bounds for each dimension.

When the compiler generates run-time code for range checking, it must insert many copies of the code that reports the error. Typically, this involves a branch to a run-time error routine. During normal execution, these branches are rarely taken; if the error handler stops execution, then it can run at most once execution. If the target machine provides a mechanism that lets the compiler predict the likely direction of a branch, these exception branches should be predicted as not taken. Furthermore, the compiler may want to annotate its internal representation to show that these branches lead to an abnormal termination. This allows subsequent phases of the compiler to di erentiate between the “normal” execution path and the “error” path; the compiler may be able to use this knowledge to produce better code along the non-error path.

8.6Character Strings

The operations provided for character-based data are often quite di erent from those provided for string data. The level of programming language support ranges from c, where most manipulation takes the form of calls to library routines, to pl/i, where assignment of individual characters, arbitrary substrings of characters, and even concatenation of strings occur as first-class operators in the language. To present the issues that arise in string implementation, this section discusses the implementation of assigning substrings, of concatenating two strings, and of computing a string’s length.

String operations can be costly. Older cisc architectures, such as the ibm s/370 and the digital vax, provided strong support for string manipulation. Modern risc machines rely more heavily on the compiler to encode these complex operations into a set of simpler interactions. The basic operation, copying bytes from one location to another, arises in many di erent contexts.

8.6.1String Representation

The compiler writer must choose a representation for strings; the details of the string representation have a strong impact on the cost of various string operations.

Consider, for example, the di erence between the two possible string representations. The one on the left is used by c. It uses a simple vector of characters,

With longer strings, the code is similar. Pl/i has a string assignment operator. The programmer can write an operation such as a = b;, where a and b have been declared as character strings. Assuming that a has enough room to hold b, the following simple loop will move the characters on a machine with byte-oriented load and store operations:

Notice that this code tests the length of a and b to avoid overrunning a. The label Lsov represents a run-time error handler for string overflow conditions.

With null-terminated strings, the code changes somewhat:

This code implements the classic character copying loop used in c programs. It does not test for overrunning a. That would require a computation of the length of both a and b (see Section 8.6.4).

The compiler treats the concatenation as a pair of assignments and generates code as shown in Section 8.6.2.

In either case, the compiler should ensure that length(a||b) is not greater the space allocated to hold the result. In practice, this requires that either the compiler or the run-time system record the allocated length of each string. If the lengths are known at compile-time, the compiler can perform the check during code generation and avoid emitting code for a run-time check. Often, however, the compiler cannot know the length of a and b, so it must generate code to compute the lengths at run-time and to perform the appropriate test and branch.

8.6.4String Length

Some applications need to compute the length of a character string. In c programs, the function strlen in the standard library takes a string as its argument and returns the string’s length, expressed as an integer. In pl/i, the built-in function length performs the same function. The two string representations described earlier lead to radically di erent costs for the length computation.

Null-terminated string The length computation must start at the beginning of the string and examine each character, in order, until it reaches the null character. The code is quite similar to the c character copying loop. This requires time proportional to the length of the string.

Explicit length field The length computation is a memory reference. In iloc, this requires a loadI of the string address and a loadAI to obtain the length. The cost is constant and small.

The tradeo between these representations is simple; null-termination saves space, while an explicit length field makes the length computation inexpensive.

The classic example of a string optimization problem is reporting the length that would result from the concatenation of two strings, a and b. In a pl/i-like notation, this would be written as length(a||b). In c, it would be written as either strlen(strcat(a,b)) or strlen(a)+strlen(b). The desired solution avoids building the concatenated string to measure its length. The two distinct ways of writing it in c expose the di erence and leave it up to the programmer to determine which is used. Of course, with c’s representation for the string, the computation must still touch each character in each string. With a pl/i- style representation, the operation can be optimized to use two loads and an add. (Of course, the programmer could directly write the form that produced e cient code—length(a)+length(b) in pl/i.)

8.7Structure References

The other kind of complex data structure that occurs in most programming languages is a structure, or some variation on it. In c, a structure aggregates together individually named elements, often of di ering types. A list implementation, in c, might use the structures

Using these two nodes, the programmer can construct lisp-like s-expressions. A ConstructorNode can point to a pair of Nodes. A Node can be either a

ValueNode or a ConstructorNode.

Working with structures in c requires the use of pointer values. In the declaration of ConstructorNode, both Head and Tail are pointers to data items of type Node. The use of pointers introduces two distinct problems for the compiler: anonymous objects and structure layout.

Loading and Storing Anonymous Values A c program creates an instance of a structure in one of two ways. It can declare a structure instance; NilNode in the example above is a declared instance of ValueNode. Alternatively, it can dynamically allocate a structure instance. In c, this looks like:

NIL = (NODE *) malloc(sizeof(ValueNode));

The instance of ValueNode that this creates has no variable name associated with it—the only access is through a pointer.

Because the only “name” for an anonymous value is a pointer, the compiler cannot easily determine whether or not two pointer references specify the same memory location. Consider the code fragment.

1.p1 = (NODE *) malloc(sizeof(ConstructorNode));

2.p2 = (NODE *) malloc(sizeof(ConstructorNode));

3.if (...)

4.then p3 = p1;

5.else p3 = p2;

6.p1->Head = ...;

7.p3->Head = ...;

8. ... = p1->Head;

The first two lines create anonymous ConstructorNodes. Line six initializes the node reachable through p1. Line seven either initializes the node reachable through p2 or overwrites the value recorded by line six. Finally, line eight references the value stored in p1->Head.

To implement the sequence of assignments in lines six through eight, the compiler would like to keep the value that is reused in a register. Unfortunately, the compiler cannot easily determine whether line eight refers to the value generated in line six or the value generated in line seven. To understand

the answer to that question, the compiler must be able to determine, with certainty, the value of the conditional expression evaluated in line three. While this may be possible in certain specific instances (i.e., 1>2), it is undecidable in the general case. Thus, the compiler must emit conservative code for this sequence of assignments. It must load the value used in line eight from memory, even though it had the value in a register quite recently (in either line six or line seven).

This degree of uncertainty that surrounds references to anonymous objects forces the compiler to keep values used in pointer-based references in memory. This can make statements involving pointer-based references less e cient than corresponding computations on local variables that are stored unambiguously in the procedure’s ar. Analyzing pointer values and using the results of that analysis to disambiguate references—that is, to rewrite references in ways that let the compiler keep some values in registers—is a major source of improvement for pointer intensive programs. (A similar e ect occurs with code that makes intensive use of arrays. Unless the compiler performs an in-depth analysis of the array subscripts, it may not be able to determine whether or not two array references overlap. When the compiler cannot distinguish between two references, such as a[i,j,k] and a[i,j,l], it must treat both references conservatively.)

Understanding Structure Layouts To emit code for structure references, the compiler must know both the starting address of the structure instance and the o set and length of each element. To maintain this information, the compiler typically builds a separate table of structure layouts. The table must include the textual name for each structure element, its o set within the structure, and its source-language data type. For the list example, the compiler might build the following structures:

Entries in the element table use fully qualified name. This avoids conflicts due to reuse of a name in several distinct structures. (Few languages insist that programs use unique element names inside structures.)

With this information, the compiler can easily generate code for structure references. The reference p1->Head might translate into the iloc sequence

Here, the compiler found the o set of Head by following the table from the ConstructorNode entry in the structure table to the Head entry in the element table. The start address of p1->Head resides in p1.

Many programming languages allow the user to declare an array of structures. If the user is allowed to take the address of a structure-valued element of this array, then the compiler must lay out the data in memory as multiple copies of the structure layout. If the programmer cannot take the address of a structure-valued element of the array, the compiler might lay out the structure as if it were a structure composed of elements that were, themselves, arrays. Depending on how the surrounding code accesses the data, these two strategies might have strikingly di erent performance on a system with cache memory.

To address an array of structures, laid out as multiple copies of the structure, the compiler uses the array address polynomials described in the previous section. The overall length of the structure becomes the element size, w, in the address polynomial. The polynomial generates the address of the start of the structure instance. To obtain the value of a specific element, the element’s o set is added to the instance address.

If the compiler has laid out the structure with elements that are arrays, it must compute the starting location of the element array using the o set table information and the array dimension. This address can then be used as the starting point for an address calculation using the appropriate polynomial.

Unions and Run-time Tags For notational convenience, some programming languages allow union types. This allows a single memory location to be interpreted in di erent ways. The Node declaration given earlier allows a single pointer to refer to an object of type ValueNode or an object of type ConstructorNode. The meaning of any reference is clear, because the two structures have no common element names.

In general, the compiler (and the programming language) must make provision for the case when the meaning of a union-type reference is unclear. In practice, two alternatives arise: additional syntax and run-time tags. The language can place the burden for disambiguating union references on the programmer, by requiring fully qualified names. In the Node example, the programmer would need to write p1->ConstructorNode.Head or p2->ValueNode.Value.

The alternative is to include a run-time tag in each allocated instance of the union. Pl/i required that the programmer explicitly declare the tag and its values. Other systems have relied on the translator to insert both the run-time tag and the appropriate code to check for correct use at each reference to an anonymous object. In fact, much of the practical motivation for stronger type systems and compile-time algorithms that can prove type-correctness arose from the desire to eliminate these automatically generated checks on run-time tags. The overhead of run-time tag checking can be significant.