GHC.Cmm.Node

Documentation

data CmmNode (e :: Extensibility) (x :: Extensibility) where

Constructors

CmmEntry :: !Label -> CmmTickScope -> CmmNode 'Closed 'Open

CmmComment :: FastString -> CmmNode 'Open 'Open

CmmTick :: !CmmTickish -> CmmNode 'Open 'Open

CmmUnwind :: [(GlobalReg, Maybe CmmExpr)] -> CmmNode 'Open 'Open

CmmAssign :: !CmmReg -> !CmmExpr -> CmmNode 'Open 'Open

CmmStore :: !CmmExpr -> !CmmExpr -> !AlignmentSpec -> CmmNode 'Open 'Open

CmmUnsafeForeignCall :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> CmmNode 'Open 'Open

CmmBranch :: !Label -> CmmNode 'Open 'Closed

CmmCondBranch

Fields

• :: { cml_pred :: CmmExpr
•    , cml_true :: !Label
•    , cml_false :: !Label
•    , cml_likely :: Maybe Bool
•    } -> CmmNode 'Open 'Closed

CmmSwitch :: CmmExpr -> SwitchTargets -> CmmNode 'Open 'Closed

CmmCall

Fields

• :: { cml_target :: CmmExpr
•    , cml_cont :: Maybe Label
•    , cml_args_regs :: [GlobalReg]
•    , cml_args :: ByteOff
•    , cml_ret_args :: ByteOff
•    , cml_ret_off :: ByteOff
•    } -> CmmNode 'Open 'Closed

CmmForeignCall

Fields

• :: { tgt :: ForeignTarget
•    , res :: [CmmFormal]
•    , args :: [CmmActual]
•    , succ :: !Label
•    , ret_args :: ByteOff
•    , ret_off :: ByteOff
•    , intrbl :: Bool
•    } -> CmmNode 'Open 'Closed

Instances

NonLocal CmmNode

Defined in GHC.Cmm.Node

Methods

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

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

OutputableP Platform CmmGraph

Defined in GHC.Cmm

Methods

pdoc :: Platform -> CmmGraph -> SDoc

DefinerOfRegs GlobalReg (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

foldRegsDefd :: Platform -> (b -> GlobalReg -> b) -> b -> CmmNode e x -> b

DefinerOfRegs LocalReg (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

foldRegsDefd :: Platform -> (b -> LocalReg -> b) -> b -> CmmNode e x -> b

UserOfRegs GlobalReg (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

foldRegsUsed :: Platform -> (b -> GlobalReg -> b) -> b -> CmmNode e x -> b

UserOfRegs LocalReg (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

foldRegsUsed :: Platform -> (b -> LocalReg -> b) -> b -> CmmNode e x -> b

OutputableP Platform (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> CmmNode e x -> SDoc

OutputableP Platform (Block CmmNode C C)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> Block CmmNode C C -> SDoc

OutputableP Platform (Block CmmNode C O)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> Block CmmNode C O -> SDoc

OutputableP Platform (Block CmmNode O C)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> Block CmmNode O C -> SDoc

OutputableP Platform (Block CmmNode O O)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> Block CmmNode O O -> SDoc

OutputableP Platform (Graph CmmNode e x)

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> Graph CmmNode e x -> SDoc

Eq (CmmNode e x)

Defined in GHC.Cmm.Node

Methods

(==) :: CmmNode e x -> CmmNode e x -> Bool

(/=) :: CmmNode e x -> CmmNode e x -> Bool

type CmmFormal = LocalReg

type CmmActual = CmmExpr

type CmmTickish = GenTickish 'TickishPassCmm

Tickish in Cmm context (annotations only)

type UpdFrameOffset = ByteOff

data Convention

A convention maps a list of values (function arguments or return values) to registers or stack locations.

Constructors

NativeDirectCall

top-level Haskell functions use NativeDirectCall, which maps arguments to registers starting with R2, according to how many registers are available on the platform. This convention ignores R1, because for a top-level function call the function closure is implicit, and doesn't need to be passed.

NativeNodeCall

non-top-level Haskell functions, which pass the address of the function closure in R1 (regardless of whether R1 is a real register or not), and the rest of the arguments in registers or on the stack.

NativeReturn

a native return. The convention for returns depends on how many values are returned: for just one value returned, the appropriate register is used (R1, F1, etc.). regardless of whether it is a real register or not. For multiple values returned, they are mapped to registers or the stack.

Slow

Slow entry points: all args pushed on the stack

GC

Entry to the garbage collector: uses the node reg! (TODO: I don't think we need this --SDM)

Instances

Outputable Convention

Defined in GHC.Cmm.Node

Methods

ppr :: Convention -> SDoc

Eq Convention

Defined in GHC.Cmm.Node

Methods

(==) :: Convention -> Convention -> Bool

(/=) :: Convention -> Convention -> Bool

data ForeignConvention

Constructors

ForeignConvention CCallConv [ForeignHint] [ForeignHint] CmmReturnInfo

Instances

Outputable ForeignConvention

Defined in GHC.Cmm.Node

Methods

ppr :: ForeignConvention -> SDoc

Eq ForeignConvention

Defined in GHC.Cmm.Node

Methods

(==) :: ForeignConvention -> ForeignConvention -> Bool

(/=) :: ForeignConvention -> ForeignConvention -> Bool

data ForeignTarget

Constructors

ForeignTarget CmmExpr ForeignConvention

PrimTarget CallishMachOp

Instances

Eq ForeignTarget

Defined in GHC.Cmm.Node

Methods

(==) :: ForeignTarget -> ForeignTarget -> Bool

(/=) :: ForeignTarget -> ForeignTarget -> Bool

(Ord r, UserOfRegs r CmmReg) => UserOfRegs r ForeignTarget

Defined in GHC.Cmm.Node

Methods

foldRegsUsed :: Platform -> (b -> r -> b) -> b -> ForeignTarget -> b

OutputableP Platform ForeignTarget

Defined in GHC.Cmm.Node

Methods

pdoc :: Platform -> ForeignTarget -> SDoc

foreignTargetHints :: ForeignTarget -> ([ForeignHint], [ForeignHint])

data CmmReturnInfo

Constructors

CmmMayReturn

CmmNeverReturns

Instances

Outputable CmmReturnInfo

Defined in GHC.Cmm.Node

Methods

ppr :: CmmReturnInfo -> SDoc

Eq CmmReturnInfo

Defined in GHC.Cmm.Node

Methods

(==) :: CmmReturnInfo -> CmmReturnInfo -> Bool

(/=) :: CmmReturnInfo -> CmmReturnInfo -> Bool

mapExp :: forall (e :: Extensibility) (x :: Extensibility). (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x

mapExpDeep :: forall (e :: Extensibility) (x :: Extensibility). (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x

wrapRecExp :: (CmmExpr -> CmmExpr) -> CmmExpr -> CmmExpr

foldExp :: forall z (e :: Extensibility) (x :: Extensibility). (CmmExpr -> z -> z) -> CmmNode e x -> z -> z

foldExpDeep :: forall z (e :: Extensibility) (x :: Extensibility). (CmmExpr -> z -> z) -> CmmNode e x -> z -> z

wrapRecExpf :: (CmmExpr -> z -> z) -> CmmExpr -> z -> z

mapExpM :: forall (e :: Extensibility) (x :: Extensibility). (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x)

mapExpDeepM :: forall (e :: Extensibility) (x :: Extensibility). (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x)

wrapRecExpM :: (CmmExpr -> Maybe CmmExpr) -> CmmExpr -> Maybe CmmExpr

mapSuccessors :: (Label -> Label) -> CmmNode O C -> CmmNode O C

mapCollectSuccessors :: (Label -> (Label, a)) -> CmmNode O C -> (CmmNode O C, [a])

Tick scopes

data CmmTickScope

Tick scope identifier, allowing us to reason about what annotations in a Cmm block should scope over. We especially take care to allow optimisations to reorganise blocks without losing tick association in the process.

Constructors

GlobalScope

The global scope is the "root" of the scope graph. Every scope is a sub-scope of the global scope. It doesn't make sense to add ticks to this scope. On the other hand, this means that setting this scope on a block means no ticks apply to it.

SubScope !Unique CmmTickScope

Constructs a new sub-scope to an existing scope. This allows us to translate Core-style scoping rules (see tickishScoped) into the Cmm world. Suppose the following code:

tick1 case ... of A -> tick2 ... B -> tick3 ...

We want the top-level tick annotation to apply to blocks generated for the A and B alternatives. We can achieve that by generating tick1 into a block with scope a, while the code for alternatives A and B gets generated into sub-scopes a/b and a/c respectively.

CombinedScope CmmTickScope CmmTickScope

A combined scope scopes over everything that the two given scopes cover. It is therefore a sub-scope of either scope. This is required for optimisations. Consider common block elimination:

A -> tick2 case ... of C -> [common] B -> tick3 case ... of D -> [common]

We will generate code for the C and D alternatives, and figure out afterwards that it's actually common code. Scoping rules dictate that the resulting common block needs to be covered by both tick2 and tick3, therefore we need to construct a scope that is a child to *both* scope. Now we can do that - if we assign the scopes ac and bd to the common-ed up blocks, the new block could have a combined tick scope ac+bd, which both tick2 and tick3 apply to.

Instances

Outputable CmmTickScope

Defined in GHC.Cmm.Node

Methods

ppr :: CmmTickScope -> SDoc

Eq CmmTickScope

Defined in GHC.Cmm.Node

Methods

(==) :: CmmTickScope -> CmmTickScope -> Bool

(/=) :: CmmTickScope -> CmmTickScope -> Bool

Ord CmmTickScope

Defined in GHC.Cmm.Node

Methods

compare :: CmmTickScope -> CmmTickScope -> Ordering

(<) :: CmmTickScope -> CmmTickScope -> Bool

(<=) :: CmmTickScope -> CmmTickScope -> Bool

(>) :: CmmTickScope -> CmmTickScope -> Bool

(>=) :: CmmTickScope -> CmmTickScope -> Bool

max :: CmmTickScope -> CmmTickScope -> CmmTickScope

min :: CmmTickScope -> CmmTickScope -> CmmTickScope

isTickSubScope :: CmmTickScope -> CmmTickScope -> Bool

Checks whether two tick scopes are sub-scopes of each other. True if the two scopes are equal.

combineTickScopes :: CmmTickScope -> CmmTickScope -> CmmTickScope

Combine two tick scopes. The new scope should be sub-scope of both parameters. We simplify automatically if one tick scope is a sub-scope of the other already.