Hoopl.Block

Documentation

data Extensibility

Used at the type level to indicate "open" vs "closed" structure.

Constructors

Open

An "open" structure with a unique, unnamed control-flow edge flowing in or out. Fallthrough and concatenation are permitted at an open point.

Closed

A "closed" structure which supports control transfer only through the use of named labels---no "fallthrough" is permitted. The number of control-flow edges is unconstrained.

type O = 'Open

type C = 'Closed

data MaybeO ex t where

Maybe type indexed by open/closed

Constructors

JustO :: t -> MaybeO O t

NothingO :: MaybeO C t

Instances

Functor (MaybeO ex)

Defined in Hoopl.Block

Methods

fmap :: (a -> b) -> MaybeO ex a -> MaybeO ex b

(<$) :: a -> MaybeO ex b -> MaybeO ex a

type family IndexedCO (ex :: Extensibility) (a :: k) (b :: k) :: k

Either type indexed by closed/open using type families

Instances

type IndexedCO O (_a :: k) (b :: k)

Defined in Hoopl.Block

type IndexedCO O (_a :: k) (b :: k) = b

type IndexedCO C (a :: k) (_b :: k)

Defined in Hoopl.Block

type IndexedCO C (a :: k) (_b :: k) = a

data Block n e x where

A sequence of nodes. May be any of four shapes (OO, OC, CO, CC). Open at the entry means single entry, mutatis mutandis for exit. A closedclosed block is a basic/ block and can't be extended further. Clients should avoid manipulating blocks and should stick to either nodes or graphs.

Constructors

BlockCO :: n C O -> Block n O O -> Block n C O

BlockCC :: n C O -> Block n O O -> n O C -> Block n C C

BlockOC :: Block n O O -> n O C -> Block n O C

BNil :: Block n O O

BMiddle :: n O O -> Block n O O

BCat :: Block n O O -> Block n O O -> Block n O O

BSnoc :: Block n O O -> n O O -> Block n O O

BCons :: n O O -> Block n O O -> Block n O O

Instances

NonLocal n => NonLocal (Block n)

Defined in Hoopl.Graph

Methods

entryLabel :: forall (x :: Extensibility). Block n C x -> Label

successors :: forall (e :: Extensibility). Block n e C -> [Label]

Outputable (Block CmmNode C C)

Defined in PprCmm

Methods

ppr :: Block CmmNode C C -> SDoc

pprPrec :: Rational -> Block CmmNode C C -> SDoc

Outputable (Block CmmNode C O)

Defined in PprCmm

Methods

ppr :: Block CmmNode C O -> SDoc

pprPrec :: Rational -> Block CmmNode C O -> SDoc

Outputable (Block CmmNode O C)

Defined in PprCmm

Methods

ppr :: Block CmmNode O C -> SDoc

pprPrec :: Rational -> Block CmmNode O C -> SDoc

Outputable (Block CmmNode O O)

Defined in PprCmm

Methods

ppr :: Block CmmNode O O -> SDoc

pprPrec :: Rational -> Block CmmNode O O -> SDoc

Outputable (Graph CmmNode e x)

Defined in PprCmm

Methods

ppr :: Graph CmmNode e x -> SDoc

pprPrec :: Rational -> Graph CmmNode e x -> SDoc

blockAppend :: Block n e O -> Block n O x -> Block n e x

blockCons :: n O O -> Block n O x -> Block n O x

blockFromList :: [n O O] -> Block n O O

blockJoin :: n C O -> Block n O O -> n O C -> Block n C C

blockJoinHead :: n C O -> Block n O x -> Block n C x

blockJoinTail :: Block n e O -> n O C -> Block n e C

blockSnoc :: Block n e O -> n O O -> Block n e O

blockSplit :: Block n C C -> (n C O, Block n O O, n O C)

Split a closed block into its entry node, open middle block, and exit node.

blockSplitHead :: Block n C x -> (n C O, Block n O x)

blockSplitTail :: Block n e C -> (Block n e O, n O C)

blockToList :: Block n O O -> [n O O]

emptyBlock :: Block n O O

firstNode :: Block n C x -> n C O

foldBlockNodesB :: forall n a. (forall e x. n e x -> a -> a) -> forall e x. Block n e x -> IndexedCO x a a -> IndexedCO e a a

foldBlockNodesB3 :: forall n a b c. (n C O -> b -> c, n O O -> b -> b, n O C -> a -> b) -> forall e x. Block n e x -> IndexedCO x a b -> IndexedCO e c b

foldBlockNodesF :: forall n a. (forall e x. n e x -> a -> a) -> forall e x. Block n e x -> IndexedCO e a a -> IndexedCO x a a

isEmptyBlock :: Block n e x -> Bool

lastNode :: Block n x C -> n O C

mapBlock :: (forall e x. n e x -> n' e x) -> Block n e x -> Block n' e x

map a function over the nodes of a Block

mapBlock' :: (forall e x. n e x -> n' e x) -> Block n e x -> Block n' e x

A strict mapBlock

mapBlock3' :: forall n n' e x. (n C O -> n' C O, n O O -> n' O O, n O C -> n' O C) -> Block n e x -> Block n' e x

map over a block, with different functions to apply to first nodes, middle nodes and last nodes respectively. The map is strict.

replaceFirstNode :: Block n C x -> n C O -> Block n C x

replaceLastNode :: Block n x C -> n O C -> Block n x C