Documentation

Possible, but temporarily punted for the sake of expediency.

Impossible without a discussion about implementation strategy.

Hack to allow us to splice string literals into C AST

State maintained while compiling a top-level SSM function.

The information here is populated while generating the step function, so that should be computed first, before this information is used to generate the act struct and enter definitions.

Translation monad for procedures, with derived typeclass instances.

We declare GenFn as a newtype so that we can implement MonadFail for it, allowing us to use monadic pattern matching.

Run a GenFn computation on a procedure.

Lookup some information associated with a type constructor.

Lookup some information associated with a data constructor.

Read and increment the number of cases in a procedure, i.e., fnCases++.

Obtain fresh integer in the GenFn monad

Bind a variable to a C expression.

Register a new local variable, to be declared in activation record.

Bind a variable to a C expression only while computing the given monad.

Register a local variable and bind its C expression during a monad.

Register number of wait statements track of number of triggers needed.

Generate a fresh label.

Generate anonymous local variable in activation record for storage.

Translate a list of SSM parameters to C parameters.

Translate a list of SSM local declarations to C declarations.

Generate declarations for numTrigs triggers.

The constant unit value, the singleton inhabitant of the type Unit.

Fake undefined value used for expressions of type Void.

Generate a C compilation from an SSM program.

Each top-level function in a program is turned into three components:

1. a struct (the activation record);
2. an initialization function (the enter function); and
3. a step function, which corresponds to the actual procedure body.

Items 2 and 3 include both declarations and definitions.

Include statements in the generated C file.

Setup the entry point of the program.

Generate struct definition for an SSM procedure.

This is where local variables, triggers, and parameter values are stored.

Generate the enter function for an SSM procedure and its signature.

Its struct is allocated and initialized (partially; local variables' values are left uninitialized).

Generate static closure for top-level function

Generate the step function for an SSM procedure.

This function just defines the function definition and switch statement that wraps the statements of the procedure. The heavy lifting is performed by genExpr.

Helper to generate yield point in step function.

Translate an SSM expression into a C expression and statements.

SSM IR is a side-effectful expression language, with two implications when translating to C:

1. every expression has a value (even if it is an uninhabited type), so this must be reflected in C; and
2. some of the side effects in SSM cannot be implemented in C using expressions alone.

These two implications roughly translate to the C.Exp and [C.BlockItem] in genExpr's return type. When we translate an SSM expression e:

(val, stms) <- genExpr e

val represents the C expression that corresponds to the value of e upon evaluation, while stms represents the list of preceding statements that compute val.

A further consideration upon point 2 is that SSM expressions may yield control at any point. Thus, the C expression returned by genExpr must accommodate the step function suspending and resuming. For instance, consider the following SSM IR expression:

(let x = 3 in x) + (wait r; 6)

The x in the let-binding in the left operand cannot just be a local variable in the step function, because it would be "uninitialized" by the yield in the right operand:

  // let x = 3 in x
  // stms:
  int x = 3;
  // exp: x

  // (wait r; 6)
  // stms:
  ssm_sensitize(r);
  actg->pc = N;
  return;
case N:
  ssm_desensitize(r);
  // exp: 6

  // After the return, x is no longer initialized, so the following is
  // undefined behavior:
  x + 6

To ensure this is cannot happen, we conservatively declare x as a local variable in the activation record, so that its value is preserved between yields, even if this is not usually necessary. We leave it to later compiler passes to optimize this.

Generate code for SSM primitive; see genExpr for extended discussion.

Generate C value for SSM literal, marshalled.

Generate C value for SSM literal, unmarshalled.

Generate C expression for SSM primitive operation.

Helper for sequencing across binary operations.

Compute priority and depth arguments for a par fork of given width.

How much the depth should be decreased when par forking given width.