LinearScan.Hoopl.DSL

Compiling Assembly programs

compile

Arguments

:: (NonLocal n, HooplNode n)

=> String

Entry label name

-> Program n

The assembly language program

-> SimpleUniqueMonad (Graph n C C, Label)

Returns the Hoopl Graph and its entry Label

When a program is compiled, the result is a closed Hoopl Graph, and the label corresponding to the requested entry label name. This is done within a SimpleUniqueMonad so that unique labels may be created.

Programs

data ProgramF n

A ProgramF abstracts a generic basic block: a series of Nodes, associated with a label, that ends in a final node.

Constructors

FreeBlock

Fields

labelEntry :: Label

labelBody :: EndNode n

type Program n = FreeT ((,) (ProgramF n)) Asm ()

A Program abstracts a sequence of basic blocks generated from an Asm environment.

Labels

type Labels = Map String Label

Labels is the type of a mapping from label names to Hoopl labels.

getLabel :: String -> Asm Label

Assembly nodes

type Asm = StateT Labels SimpleUniqueMonad

The Asm static monad allows for the creation labels by name, and referencing them later.

type Nodes n a = Free ((,) (n O O)) a

A series of Nodes is a set of assembly instructions that ends with some kind of closing operation, such as a jump, branch or return. The Free monad is used as a convenient way to describe a list that must result in a closing operation at the end.

nodesToList :: Nodes n a -> (a, [n O O])

nodesToList renders a set of nodes as a list of operations followed by a final value a.

type BodyNode n = Nodes n ()

A BodyNode represents an instruction within a program.

bodyNode :: n O O -> BodyNode n

Construct a BodyNode from a Hoopl graph node.

type EndNode n = Nodes n (Asm (n O C))

An EndNode represents a program with a final instruction. This instruction is generated from an Asm environment, so that it may refer to and create labels for other blocks.

endNode :: Asm (n O C) -> EndNode n

Construct an EndNode from a Hoopl final node generated from an Asm environment.

label :: String -> EndNode n -> Program n

Create and associate a label with an series of instructions, creating a Program for that block.

jump :: HooplNode n => String -> EndNode n

Create a final jump instruction to the given label.

Spill stack

data SpillStack

Constructors

SpillStack

Fields

stackPtr :: Int

Offset to the beginning of the spill stack. This can have whatever meaning the user of this library desires; it is not used directly by the allocation code.

stackSlotSize :: Int

The size of a stack slot in bytes. This should be the same or larger than the size of a register.

stackSlots :: Map (Maybe VarId) Int

A mapping of variables to their stack slot offsets. The special variable Nothing is used for temporary storage, for example when swapping registers through the stack.

Instances

Eq SpillStack

Show SpillStack

newSpillStack :: Int -> Int -> SpillStack

Create a new SpillStack, given an offset and slot size.

getStackSlot :: Maybe VarId -> Env Int

Given a variable identifier, determine its spill stack offset. The value Nothing refers to the temporary stack slot.

type Env = State ([Int], SpillStack)