Compiling to Slux: Implementation Strategies

Local variables

Register allocation

Each variable can be assigned to its own register, since registers are private to each function frame.

Heap allocation

At entry to a function, you can allocate a static-struct, and store that in a register. Accesses into static structs are encoded efficiently and accessed at very high speeds (potentially without any checking by the terp), although of course this is notably slower than storing variables in registers.

If more than 256 heap-allocated variables are needed, allocate multiple static-structs. (One could try to use an array to get past the 256-item limit, but using an array is implausible, as it would require storing somewhere all the literal integer indices used to index into the array, which is difficult.)

Support for more than 125 local variables

Slux only allows 125 registers; if more than 125 local variables and compiler-generated temporary registers are needed, some of the variables should be heap allocated. Classical register-allocation strategies can be employed to avoid constantly saving/loading all the variables that aren't permanently register allocated.

Continuations

You can define nested blocks of code which can be passed around as functions by simply defining them as their own functions. If the containing function has some values that are accessed by the nested code-- parameters or registers--which are constant for the life of the nested function, these can be shared with the nested function by using currying.

If there are variables in the containing function which can be modified by the the nested function (they "escape"), they can be allocated as heap-allocated variables, and the static-struct or array containing them can be curried in.

For example, consider the following hypothetical language which supports arbitrary iterators using continuations:

 countProperty(object o, name p)
 {
    int n=0;
    o->children(
       func(x)
       {
          if (x->p())
             n = n+1;
       }
    );
    return n;
 }

An implementation can break this up into two different functions:

 countProperty(object o, name p)
 {
    static-struct a = [ 0 ];   // n
    func f = curry(countProperty#nested, a, p);
    o->children(f);
    return a[0];
 }

 countProperty#nested(static-struct a, name p, element x)
 {
    if (x->p())
       a[0] = a[0]+1;
 }

Constants

Literal Pool

Heap-allocated literals

note for future reference

Global Variables

Global Object implementation

Static-Struct Implementation