Futhark.IR.Prop

This module provides various simple ways to query and manipulate fundamental Futhark terms, such as types and values. The intent is to keep Futhark.IRrsentation.AST.Syntax simple, and put whatever embellishments we need here. This is an internal, desugared representation.

Documentation

module Futhark.IR.Prop.Reshape

module Futhark.IR.Prop.Rearrange

module Futhark.IR.Prop.Types

module Futhark.IR.Prop.Constants

module Futhark.IR.Prop.TypeOf

module Futhark.IR.Prop.Patterns

module Futhark.IR.Prop.Names

module Futhark.IR.RetType

Built-in functions

isBuiltInFunction :: Name -> Bool

isBuiltInFunction k is True if k is an element of builtInFunctions.

builtInFunctions :: Map Name (PrimType, [PrimType])

A map of all built-in functions and their types.

Extra tools

asBasicOp :: Exp lore -> Maybe BasicOp

If the expression is a BasicOp, return it, otherwise Nothing.

safeExp :: IsOp (Op lore) => Exp lore -> Bool

An expression is safe if it is always well-defined (assuming that any required certificates have been checked) in any context. For example, array indexing is not safe, as the index may be out of bounds. On the other hand, adding two numbers cannot fail.

subExpVars :: [SubExp] -> [VName]

Return the variable names used in Var subexpressions. May contain duplicates.

subExpVar :: SubExp -> Maybe VName

If the SubExp is a Var return the variable name.

commutativeLambda :: Lambda lore -> Bool

Does the given lambda represent a known commutative function? Based on pattern matching and checking whether the lambda represents a known arithmetic operator; don't expect anything clever here.

entryPointSize :: EntryPointType -> Int

How many value parameters are accepted by this entry point? This is used to determine which of the function parameters correspond to the parameters of the original function (they must all come at the end).

defAux :: dec -> StmAux dec

A StmAux with empty Certificates.

stmCerts :: Stm lore -> Certificates

The certificates associated with a statement.

certify :: Certificates -> Stm lore -> Stm lore

Add certificates to a statement.

expExtTypesFromPattern :: Typed dec => PatternT dec -> [ExtType]

Construct the type of an expression that would match the pattern.

attrsForAssert :: Attrs -> Attrs

Keep only those attributes that are relevant for Assert expressions.

type ASTConstraints a = (Eq a, Ord a, Show a, Rename a, Substitute a, FreeIn a, Pretty a)

A handy shorthand for properties that we usually want to things we stuff into ASTs.

class (ASTConstraints op, TypedOp op) => IsOp op where

A type class for operations.

Methods

safeOp :: op -> Bool

Like safeExp, but for arbitrary ops.

cheapOp :: op -> Bool

Should we try to hoist this out of branches?

Instances

IsOp ()

Defined in Futhark.IR.Prop

Methods

safeOp :: () -> Bool

cheapOp :: () -> Bool

IsOp SizeOp

Defined in Futhark.IR.Kernels.Kernel

Methods

safeOp :: SizeOp -> Bool

cheapOp :: SizeOp -> Bool

ASTLore lore => IsOp (SOAC lore)

Defined in Futhark.IR.SOACS.SOAC

Methods

safeOp :: SOAC lore -> Bool

cheapOp :: SOAC lore -> Bool

IsOp inner => IsOp (MemOp inner)

Defined in Futhark.IR.Mem

Methods

safeOp :: MemOp inner -> Bool

cheapOp :: MemOp inner -> Bool

(ASTLore lore, ASTConstraints lvl) => IsOp (SegOp lvl lore)

Defined in Futhark.IR.SegOp

Methods

safeOp :: SegOp lvl lore -> Bool

cheapOp :: SegOp lvl lore -> Bool

(ASTLore lore, IsOp op) => IsOp (MCOp lore op)

Defined in Futhark.IR.MC.Op

Methods

safeOp :: MCOp lore op -> Bool

cheapOp :: MCOp lore op -> Bool

(ASTLore lore, IsOp op) => IsOp (HostOp lore op)

Defined in Futhark.IR.Kernels.Kernel

Methods

safeOp :: HostOp lore op -> Bool

cheapOp :: HostOp lore op -> Bool

class (Decorations lore, PrettyLore lore, Renameable lore, Substitutable lore, FreeDec (ExpDec lore), FreeIn (LetDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (RetType lore), FreeIn (BranchType lore), IsOp (Op lore)) => ASTLore lore where

Lore-specific attributes; also means the lore supports some basic facilities.

Methods

expTypesFromPattern :: (HasScope lore m, Monad m) => Pattern lore -> m [BranchType lore]

Given a pattern, construct the type of a body that would match it. An implementation for many lores would be expExtTypesFromPattern.

Instances

ASTLore Seq

Defined in Futhark.IR.Seq

Methods

expTypesFromPattern :: (HasScope Seq m, Monad m) => Pattern Seq -> m [BranchType Seq]

ASTLore SOACS

Defined in Futhark.IR.SOACS

Methods

expTypesFromPattern :: (HasScope SOACS m, Monad m) => Pattern SOACS -> m [BranchType SOACS]

ASTLore MCMem

Defined in Futhark.IR.MCMem

Methods

expTypesFromPattern :: (HasScope MCMem m, Monad m) => Pattern MCMem -> m [BranchType MCMem]

ASTLore MC

Defined in Futhark.IR.MC

Methods

expTypesFromPattern :: (HasScope MC m, Monad m) => Pattern MC -> m [BranchType MC]

ASTLore SeqMem

Defined in Futhark.IR.SeqMem

Methods

expTypesFromPattern :: (HasScope SeqMem m, Monad m) => Pattern SeqMem -> m [BranchType SeqMem]

ASTLore Kernels

Defined in Futhark.IR.Kernels

Methods

expTypesFromPattern :: (HasScope Kernels m, Monad m) => Pattern Kernels -> m [BranchType Kernels]

ASTLore KernelsMem

Defined in Futhark.IR.KernelsMem

Methods

expTypesFromPattern :: (HasScope KernelsMem m, Monad m) => Pattern KernelsMem -> m [BranchType KernelsMem]

(ASTLore lore, CanBeAliased (Op lore)) => ASTLore (Aliases lore)

Defined in Futhark.IR.Aliases

Methods

expTypesFromPattern :: (HasScope (Aliases lore) m, Monad m) => Pattern (Aliases lore) -> m [BranchType (Aliases lore)]

(ASTLore lore, CanBeWise (Op lore)) => ASTLore (Wise lore)

Defined in Futhark.Optimise.Simplify.Lore

Methods

expTypesFromPattern :: (HasScope (Wise lore) m, Monad m) => Pattern (Wise lore) -> m [BranchType (Wise lore)]