Revised implementation of static allocation/initialization of globals

[MatthewFluet]

#328 introduced static allocation/initialization of globals, but some complexities and issues with the implementation were noted during review:

• Add static allocation support in Rssa through codegen #328 (comment)
• Add static allocation support in Rssa through codegen #328 (comment)
• Add static allocation support in Rssa through codegen #328 (comment)

This revised implementation tries to simplify the complexities and address the issues:

• The RSSA IR loses the Operand.Static {static: Var.t Static.t, ty: Type.t} variant and gains a statics: {dst: Var.t * Type.t, obj: Object.t} vector field in Program.T. The PackedRepresentation and Ssa2ToRssa passes are simplified, because the initial RSSA program is created with an empty statics field. The rssaShrink1 pass takes care of constant-folding and copy-propagating of object initialization. New collectStatics.{Globals,{WordXVector,Real}Consts} passes introduce objects into the statics field.

• The Machine IR gains a staticsHeaps: StaticHeap.Kind -> StaticHeap.Object.t vector field in Program.T. Each "kind" of static heap is emitted to the main .c file as a statically initialized data definition that "looks" like an ML heap. There are four kinds of heaps:

  • Immutable: for immutable objects; such objects need never be traversed by the GC. (Note that global unit ref objects can be placed in the Immutable static heap, since they will never actually be mutated.)
  • Mutable: for objects with mutable non-objptr fields; such objects may be mutated, but need never be traversed by the GC. (Note that global empty mutable sequences can be placed in the Mutable static heap, since, even if they have mutable objptr fields, since the elements will never actually be mutated.)
  • Root: when the mutator does not mark cards, for objects with mutable objptr fields; such objects may be mutated and need to be traversed by the GC (because they may be updated to point to objects in the runtime heap). However, if card marking is used by the mutator, then the Root static heap cannot be used, because the write barrier with a base object in the Root static heap will attempt to write to an invalid card slot index. It would be possible to make the write barrier more expensive, by dynamically checking if the base is in the Root static heap.
  • Dynamic: when the mutator marks cards, for objects with mutable objptr fields, such objects may be mutated and need to be traversed by the GC. The Dynamic static heap is copied to the initial runtime heap at runtime initialization.

  In Backend, each RSSA static is placed in an appropriate "kind" of static heaps. For objects placed in the Dynamic static heap, they are accessed by the rest of the program via Global operands (and incur a level of indirection).

• The Mutable and Root heaps are properly saved and loaded by MLton.World.

Other notable aspects of the PR:

• The SSA2 IR gains an Exp.Sequence of {args: Var.t vector vector} variant to represent direct allocation of arrays and vectors, including initialization of elements. At toSsa2, the Vector_vector primitive is translated to SsaTree2.Exp.Sequence, rather than being translated to an Array_alloc Array_update Array_toVector sequence. At Ssa2ToRssa, a SsaTree2.Exp.Sequence is translated to an Rssa.Object.Sequence (via updates to PackedRepresentation). This allows global Vector_vector objects to be collected to statics.

• A new Array_array primitive for literal arrays was introduced. The intention is that compilation might find opportunities to optimize explicit array allocation and initialization into the Array_array primitive.

Currently, there is not support for "empty" static objects. In the previous static allocation/initialization implementation, a global Array_alloc (necessarily with a constant length operand) would be translated to a special kind of static that would be placed in the BSS segment of the executable and dynamically initialized. A future PR could restore this functionality as follows:

• Introduce MutableEmpty, RootEmpty, and DynamicEmpty static heap kinds that simply specify a heap size, along with mutableEmptyInit, rootEmptyInit, and dynamicEmptyInit data to properly initialize the headers.

• Don't lower Array_alloc prims in Ssa2ToRssa. After rssaShrink1, it will be possible to read off the Array_alloc's with constant size. All such Array_allocs in the initGlobals function can be lifted to RSSA statics. Meanwhile, such Array_allocs in other functions can be more cheaply implemented via direct allocation by the mutator, rather than via the GC_sequenceAllocate runtime call (which induces a GC safe point).

However, "empty" static objects are only created with the (non-default) -globalize-arrays true, and so weren't exercised by default in the previous implementation.