Jones N.D.Partial evaluation and automatic program generation.1999

Data structures and their binding-time separation 241

11.4.2 Struct specialization

Consider a word count program counting the number of occurrences of words in an input stream.7 A natural data representation is an array of structs

struct key f char *word; int count; g keytab[NKEYS];

Suppose that the words are static but the number of occurrences is dynamic. If the struct key is treated as a single entity, the staticness of word will be lost, and we thus have to split the data structure into two separate arrays:

char *keyword[NKEYS]; int keycount[NKEYS];

in order to recover the static information.8

To avoid this it seems desirable to assign to each eld in a struct an individual binding time, and then to specialize the struct type to the static elds. References to static elds are evaluated during partial evaluation, while all others are suspended to run time.

Example 11.9 Assume that we employ a binary search routine to look up the index of a word in the keytab.

struct key f char *word; int count; g; struct key keytab[NKEYS];

/* Update word with count and return count */ int update(char *word, int count)

f

int n = binsearch(word); /* Find index of word */ return keytab[n].count = count;

g

When specializing the update() function to a static word, the call to binsearch() can be fully evaluated since it depends on nothing but the static word in keytab. Only references to the dynamic count eld appear in residual program.

struct key_word f int count; g keytab[NKEYS]; int update_word(int count)

f return keytab[13].count = count; g

2

Postprocessing can remove singleton structs such as struct f int count; g. Another strategy is to split structs into separate variables. Notice, however, that it is in general unsound to perform online splitting of structs that encapsulate arrays, since this may change the parameter passing semantics from call-by-value to call-by-reference.

7See Kernighan and Ritchie, Section 6.3 [147].

8Recall the two-list representation of the environment in the owchart mix, Chapter 4.

242Partial Evaluation for the C Language

11.4.3The taming of pointers

A pointer is classi ed as static if it solely points to objects with a specialization time known location. Otherwise a pointer is said to be dynamic. For example, if x is a local variable, then p in p = &x can be classi ed as static, even though x may be dynamic. Let all dynamic objects contain their symbolic address, for instance, x could contain the symbolic address (or run time address) loc-x. Consider partial evaluation of the following lines of code:

The rst expression can be evaluated completely, and thus p can be bound to the specialization time address of x. Dereferencing p subsequently yields the symbolic run time address loc-x which can be used to generate the residual expression x = 2 as expected.

Example 11.10 In the program fragment below the pointer p must necessarily be classi ed as dynamic.

int a[10], *p;

p = &a[ dynamic expression]

Even though a exists during specialization, the assignment cannot be evaluated

Similarly, objects of struct type contain their symbolic run time addresses. For example, a variable struct key s can be bound to loc-s. The expression s.word can be evaluated completely at specialization time since word is static. In the case of a selector expression s.count, a residual expression s.count can be generated from the symbolic address loc-s and count.9

The same technique carries over to pointers. Let static p be a pointer to a struct key with symbolic address loc-s1. The expression p->count, which is semantically equivalent to (*p).count, can then be reduced to s1.count. First *p is evaluated to the struct object loc-s1, and then the residual struct indexing expression is generated.

Example 11.11 Pointers to non-local objects must be treated with care. Suppose that a global pointer p is assigned the address of a local dynamic variable x, and then a function foo() is called. In foo(), any dereferencing of p will evaluate to loc-x and thus x will appear in the residual version of foo(), which is clearly wrong. Similar problems occur when partially static variables are passed using call- by-reference. Hence pointers to variables otherwise out of scope must be suspended,

9Recall that a partially static struct is not split but specialized.

244 Partial Evaluation for the C Language

During specialization the list has been allocated and in the residual program the nodes appear as separate variables. Moreover, struct Node has been specialized to the static key and next elds. All pointer chaining has been resolved, so the

The bene t of the optimization is two fold. The expensive calls to alloc() are replaced by cheaper static allocation, and all pointer indirections are performed during specialization.

If the result of an alloc() is assigned a dynamic pointer, the call is suspended. For example, suppose that a next eld is assigned a dynamic pointer. Then the allocation of the whole list would be suspended. This is reasonable because then the list cannot be traversed at specialization time.

11.4.5Improving the separation of binding times

Without detailed knowledge of pointer usage, binding-time analysis must implement the most conservative assumption | that any pointer potentially can point to all objects of its type. For example, consider variable declarations struct key k, l, *p. If the word eld in k is dynamic then also the word eld in l must be classi ed as dynamic, as it could be that p might point to either of the two variables. However, if it can be revealed that p at most can point to one of them, for example k, then word in l can be classi ed as static.

As a variable can be characterized by its name, a heap-allocated object can be named from the alloc() from which it originates.

Let all alloc() calls be labelled uniquely. A call allocl(S) is said to be the l'th birthplace of an S object. Generalizer such that the birthplace of a statically allocated variable is its (unique) name.

Example 11.13 Let P(p) mean the set of objects, identi ed by their birthplaces, that pointer variable p may point to during program execution. We have: P(p) = P(list) f0; 1g, P(q) f2g, P(1:next) f1g,

list = p = alloc0(Node);

for (; n--; ) f p = p->next = alloc1(Node); . . . ; g list = list->next;

q = alloc2(Node);

The binding-time congruence principle can then be re ned to read: for all pointer variables p it holds that any variable in P(p) possesses the same binding time.12 A analysis in which pointer analysis and binding-time analysis are partly intermingled is outlined in Section 11.6.

12This is similar to the use of closure analysis in higher-order partial evaluation (Chapter 10).

248 Partial Evaluation for the C Language

The meaning of a jump is to continue (two-level) program execution at the target label. The meaning of a goto is to generate a residual goto and to specialize the target statements to the current values of the static variables. The meaning of a call statement is to execute the function (which must be completely static), and the meaning of a call is to specialize the call.

To indicate the desired processing of function calls, the two-level language is furthermore extended with the forms:

rcall and ucall.

In the former case, the function is specialized under the assumption that no static side-e ects under dynamic control occur in the called function (cf. Section 11.3).13 The ucall form indicates that the function is to be unfolded.

11.5.3Well-annotated two-level Core C

Not all two-level Core C program specialize well. The indispensable congruence requirement, that static computation must be independent of dynamic values, is not captured by the purely syntactic de nition of the two-level language. A program ful lling this principle is said to be well-annotated. A set of rules is needed such that if a program satis es them, then no binding time error can occur during specialization.

Binding times can be seen as types in the two-level language. For instance, a constant has type static S, an expression depending on a dynamic value has type dynamic D. This can be formalized by the means of a two-level binding-time type system. A binding-time type (BTT) T is given inductively by the grammar:

T ::= S j D j T T j T

where S and D are ground types. The constructor describes the components of a value of struct type. For example, a struct f int x, y; g could be assigned the binding time S D meaning that x is static but y dynamic. Finally, the star constructor T denotes a static pointer to an object of binding time T.

Example 11.16 Consider the struct Node de ned in Section 11.4, and suppose that key and next are static elds but data dynamic. Thus the type TNode is

TNode = S D TNode

where the recursive de nition is due to the fact that the struct Node is recursively de ned. Formally we would have to add a xed-point operator to the two-level type system, de ned by T:T = T [ T:T =T ], but this is omitted for simplicity. 2

13This is an example of a well-annotatedness requirement which is treated in the next subsection.

Partial evaluation for C by two-level execution 249

Figure 11.3: Well-annotatedness rules for two-level expressions.

Let : Id ! BTT be a type assignment mapping identi ers to binding-time types. For example, (base) = D in case of the power() function. Moreover, let O : OId ! BTT ! BTT map operators and external functions to their static binding-time types. For example, `+' maps static base values to a static base value: O(+) = (S; S) ! S.

Suppose that e is a two-level expression and that all identi ers in e are in the domain of . Then e is well-annotated i there exists a binding-time type T such that ` e : T where the relation ` is de ned in Figure 11.3.

A constant is static and the binding-time type of a variable is given by the environment . The lift operator converts a static base value to a dynamic constant.14

In any indexing of a dynamic struct, the subexpression must be dynamic. Otherwise the type of the result is given by the corresponding eld. An index expression is static if its left expression is of static pointer type and the index expression is static. Otherwise both the subexpressions must be dynamic and the indexing suspended. In the case of a deference operator, the subexpression must be of static

14Notice that values of struct or pointer type are not allowed to be lifted.

250 Partial Evaluation for the C Language

pointer type for the application to be non-underlined.

The cases for application of unary and binary operators and external functions are all similar. Either the arguments are static as given by the type assignment, or all the arguments are dynamic and the application is suspended. The alloc call returns a static pointer, and an assignment is non-underlined if both the subexpressions are non-dynamic.

The rules for structs are more liberal than assumed in the previous sections. Recall that we do not want to split structs but to specialize their static elds. We could therefore additionally require any struct expression whose relevant eld is non-static to be underlined.

Given the de nition of well-annotatedness of expressions, well-annotatedness of statements can be de ned. For example, an if is static if the test expression is static. A function de nition is static if it does not contain a dynamic statement. In a dynamic function, every return must be dynamic since a residual function is supposed to return a value at run time | not at specialization time. The last step is to impose conditions regarding the treatment of recursive functions and non-local side-e ects: e.g. to make all assignments to non-local variables dynamic [6,10]. To this end the output of a pointer analysis is useful to detect whether and | in the a rmative case | which non-local variables a function may refer to.

11.5.4Two-level execution of Core C

In this section we present the core of a specializer for two-level Core C. It comes in two parts: the two-level execution of statements, and the surrounding kernel for polyvariant specialization of program points.

Two-level execution of statements

Let the value of parameters, local variables, and global variables be represented by three separate arrays pstore, lstore, and gstore respectively. The heap is represented by an array heap, which alloc() administrates.

The program representation is assumed to be encapsulated via external functions. An example is stmt kind(), which returns the tag of a particular statement in a function. The whole program is represented by the variable pgm.

The residual code is generated by external library functions such as which adds a statement to the residual function currently being made.

The two-level execution of two-level statements is given in Figure 11.4. The variable pp is the current program point, and func the current function index. Given the label of a statement, all following statements up to the next dynamic control statement (goto, if, call, return) are specialized.

The function eval() evaluates an expression yielding a value, and the function reduce() reduces an expression giving a residual expression.15

15We assume that suitable data types for representation of expressions and values exist.