ghc-7.8.3: The GHC API

Safe HaskellNone
LanguageHaskell98

CmmNode

Synopsis

Documentation

data CmmNode e x where Source

Constructors

CmmEntry :: !Label -> CmmNode C O 
CmmComment :: FastString -> CmmNode O O 
CmmAssign :: !CmmReg -> !CmmExpr -> CmmNode O O 
CmmStore :: !CmmExpr -> !CmmExpr -> CmmNode O O 
CmmUnsafeForeignCall :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> CmmNode O O 
CmmBranch :: !Label -> CmmNode O C 
CmmCondBranch :: CmmExpr -> !Label -> !Label -> CmmNode O C 

Fields

cml_pred :: CmmExpr
 
cml_true :: !Label
 
cml_false :: !Label
 
CmmSwitch :: CmmExpr -> [Maybe Label] -> CmmNode O C 
CmmCall :: CmmExpr -> Maybe Label -> [GlobalReg] -> ByteOff -> ByteOff -> ByteOff -> CmmNode O C 

Fields

cml_target :: CmmExpr
 
cml_cont :: Maybe Label
 
cml_args_regs :: [GlobalReg]
 
cml_args :: ByteOff
 
cml_ret_args :: ByteOff
 
cml_ret_off :: ByteOff
 
CmmForeignCall :: ForeignTarget -> [CmmFormal] -> [CmmActual] -> !Label -> ByteOff -> ByteOff -> Bool -> CmmNode O C 

Fields

tgt :: ForeignTarget
 
res :: [CmmFormal]
 
args :: [CmmActual]
 
succ :: !Label
 
ret_args :: ByteOff
 
ret_off :: ByteOff
 
intrbl :: Bool
 

Instances

type CmmFormal = LocalReg Source

type CmmActual = CmmExpr Source

type UpdFrameOffset = ByteOff Source

data Convention Source

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

data ForeignConvention Source

Constructors

ForeignConvention CCallConv [ForeignHint] [ForeignHint] CmmReturnInfo 

Instances

data ForeignTarget Source

Constructors

ForeignTarget CmmExpr ForeignConvention 
PrimTarget CallishMachOp 

Instances

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

data CmmReturnInfo Source

Constructors

CmmMayReturn 
CmmNeverReturns 

Instances

mapExp :: (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x Source

mapExpDeep :: (CmmExpr -> CmmExpr) -> CmmNode e x -> CmmNode e x Source

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

foldExp :: (CmmExpr -> z -> z) -> CmmNode e x -> z -> z Source

foldExpDeep :: (CmmExpr -> z -> z) -> CmmNode e x -> z -> z Source

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

mapExpM :: (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x) Source

mapExpDeepM :: (CmmExpr -> Maybe CmmExpr) -> CmmNode e x -> Maybe (CmmNode e x) Source

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

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