Futhark.Representation.AST.Attributes

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

Documentation

module Futhark.Representation.AST.Attributes.Reshape

module Futhark.Representation.AST.Attributes.Rearrange

module Futhark.Representation.AST.Attributes.Types

module Futhark.Representation.AST.Attributes.Constants

module Futhark.Representation.AST.Attributes.TypeOf

module Futhark.Representation.AST.Attributes.Patterns

module Futhark.Representation.AST.Attributes.Names

module Futhark.Representation.AST.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

funDefByName :: Name -> Prog lore -> Maybe (FunDef lore)

Find the function of the given name in the Futhark program.

asBasicOp :: Exp lore -> Maybe (BasicOp lore)

If the expression is a BasicOp, return that BasicOp, 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 BasicOp is a Var return the variable name.

shapeVars :: Shape -> [VName]

Return the variable dimension sizes. May contain duplicates.

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 :: attr -> StmAux attr

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 attr => PatternT attr -> [ExtType]

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

patternFromParams :: [Param attr] -> PatternT attr

Create a pattern corresponding to some parameters.

class (Eq op, Ord op, Show op, TypedOp op, Rename op, Substitute op, FreeIn op, Pretty 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.Representation.AST.Attributes

Methods

safeOp :: () -> Bool

cheapOp :: () -> Bool

Attributes lore => IsOp (SOAC lore)

Defined in Futhark.Representation.SOACS.SOAC

Methods

safeOp :: SOAC lore -> Bool

cheapOp :: SOAC lore -> Bool

Attributes lore => IsOp (KernelExp lore)

Defined in Futhark.Representation.Kernels.KernelExp

Methods

safeOp :: KernelExp lore -> Bool

cheapOp :: KernelExp lore -> Bool

Attributes lore => IsOp (Kernel lore)

Defined in Futhark.Representation.Kernels.Kernel

Methods

safeOp :: Kernel lore -> Bool

cheapOp :: Kernel lore -> Bool

IsOp inner => IsOp (MemOp inner)

Defined in Futhark.Representation.ExplicitMemory

Methods

safeOp :: MemOp inner -> Bool

cheapOp :: MemOp inner -> Bool

IsOp inner => IsOp (HostOp lore inner)

Defined in Futhark.Representation.Kernels.Kernel

Methods

safeOp :: HostOp lore inner -> Bool

cheapOp :: HostOp lore inner -> Bool

class (Annotations lore, PrettyLore lore, Renameable lore, Substitutable lore, FreeAttr (ExpAttr lore), FreeIn (LetAttr lore), FreeAttr (BodyAttr lore), FreeIn (FParamAttr lore), FreeIn (LParamAttr lore), FreeIn (RetType lore), FreeIn (BranchType lore), IsOp (Op lore)) => Attributes 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

Attributes SOACS

Defined in Futhark.Representation.SOACS

Methods

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

Attributes InKernel

Defined in Futhark.Representation.Kernels

Methods

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

Attributes Kernels

Defined in Futhark.Representation.Kernels

Methods

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

Attributes InKernel

Defined in Futhark.Representation.ExplicitMemory

Methods

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

Attributes ExplicitMemory

Defined in Futhark.Representation.ExplicitMemory

Methods

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

(Attributes lore, CanBeRanged (Op lore)) => Attributes (Ranges lore)

Defined in Futhark.Representation.Ranges

Methods

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

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

Defined in Futhark.Representation.Aliases

Methods

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

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

Defined in Futhark.Optimise.Simplify.Lore

Methods

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