clash-lib-1.8.4: Clash: a functional hardware description language - As a library

Copyright | (C) 2012-2016 University of Twente 2021-2024 QBayLogic B.V.
License | BSD2 (see the file LICENSE)
Maintainer | QBayLogic B.V. <devops@qbaylogic.com>
Safe Haskell | None
Language | Haskell2010

Clash.Normalize.Util

Description

Utility functions used by the normalisation transformations

Synopsis

- data ConstantSpecInfo = ConstantSpecInfo {
  - csrNewBindings :: [(Id, Term)]
  - csrNewTerm :: !Term
  - csrFoundConstant :: !Bool
  }
- isConstantArg :: Text -> Int -> RewriteMonad NormalizeState Bool
- shouldReduce :: Context -> RewriteMonad NormalizeState Bool
- alreadyInlined :: Id -> Id -> NormalizeMonad (Maybe Int)
- addNewInline :: Id -> Id -> NormalizeMonad ()
- isRecursiveBndr :: Id -> NormalizeSession Bool
- callGraph :: BindingMap -> Id -> CallGraph
- collectCallGraphUniques :: CallGraph -> HashSet Unique
- classifyFunction :: Term -> TermClassification
- isCheapFunction :: Term -> Bool
- isNonRecursiveGlobalVar :: Term -> NormalizeSession Bool
- constantSpecInfo :: TransformContext -> Term -> RewriteMonad NormalizeState ConstantSpecInfo
- normalizeTopLvlBndr :: Bool -> Id -> Binding Term -> NormalizeSession (Binding Term)
- rewriteExpr :: (String, NormRewrite) -> (String, Term) -> (Id, SrcSpan) -> NormalizeSession Term
- mkInlineTick :: Id -> TickInfo
- substWithTyEq :: Term -> Term
- tvSubstWithTyEq :: Type -> Type

# Documentation

data ConstantSpecInfo Source #

Constructors

ConstantSpecInfo |

Fields

- csrNewBindings :: [(Id, Term)]

  New let-bindings to be created for all the non-constants found

- csrNewTerm :: !Term

  A term where all the non-constant constructs are replaced by variable references (found in `csrNewBindings`)

- csrFoundConstant :: !Bool

  Whether the algorithm found a constant at all. (If it didn't, it's no use creating any new let-bindings!)

#### Instances

Instances details

Show ConstantSpecInfo Source # |
Instance details Defined in Clash.Normalize.Util Methods showsPrec :: Int -> ConstantSpecInfo -> ShowS Source # show :: ConstantSpecInfo -> String Source # showList :: [ConstantSpecInfo] -> ShowS Source #

isConstantArg Source #

Arguments

:: Text | Primitive name
-> Int | Argument number
-> RewriteMonad NormalizeState Bool | Yields `DontCare` for if given primitive name is not found, if the argument does not exist, or if the argument was not mentioned by the blackbox.

Determine if argument should reduce to a constant given a primitive and an argument number. Caches results.

shouldReduce Source #

Arguments

:: Context | ..in the current transformcontext
-> RewriteMonad NormalizeState Bool |

Given a list of transformation contexts, determine if any of the contexts indicates that the current arg is to be reduced to a constant / literal.

alreadyInlined Source #

Arguments

:: Id | Function we want to inline
-> Id | Function in which we want to perform the inlining
-> NormalizeMonad (Maybe Int) |

Determine if a function is already inlined in the context of the `NetlistMonad`

addNewInline Source #

Arguments

:: Id | Function we're inlining
-> Id | Function in which we're inlining it
-> NormalizeMonad () |

Record a new inlining in the `inlineHistory`

isRecursiveBndr :: Id -> NormalizeSession Bool Source #

Assert whether a name is a reference to a recursive binder.

callGraph :: BindingMap -> Id -> CallGraph Source #

Create a call graph for a set of global binders, given a root

collectCallGraphUniques :: CallGraph -> HashSet Unique Source #

Collect all binders mentioned in CallGraph into a HashSet

classifyFunction :: Term -> TermClassification Source #

Give a "performance/size" classification of a function in normal form.

isCheapFunction :: Term -> Bool Source #

Determine whether a function adds a lot of hardware or not.

It is considered expensive when it has 2 or more of the following components:

- functions
- primitives
- selections (multiplexers)

isNonRecursiveGlobalVar :: Term -> NormalizeSession Bool Source #

Test whether a given term represents a non-recursive global variable

constantSpecInfo :: TransformContext -> Term -> RewriteMonad NormalizeState ConstantSpecInfo Source #

Calculate constant spec info. The goal of this function is to analyze a given term and yield a new term that:

- Leaves all the constant parts as they were.
- Has all _variable_ parts replaced by a newly generated identifier.

The result structure will additionally contain:

- Whether the function found any constant parts at all
- A list of let-bindings binding the aforementioned identifiers with the term they replaced.

This can be used in functions wanting to constant specialize over partially constant data structures.

normalizeTopLvlBndr :: Bool -> Id -> Binding Term -> NormalizeSession (Binding Term) Source #

rewriteExpr Source #

Arguments

:: (String, NormRewrite) | Transformation to apply
-> (String, Term) | Term to transform
-> (Id, SrcSpan) | Renew current function being rewritten
-> NormalizeSession Term |

Rewrite a term according to the provided transformation

mkInlineTick :: Id -> TickInfo Source #

A tick to prefix an inlined expression with it's original name. For example, given

foo = bar -- ... bar = baz -- ... baz = quuz -- ...

if bar is inlined into foo, then the name of the component should contain the name of the inlined component. This tick ensures that the component in foo is called bar_baz instead of just baz.

substWithTyEq :: Term -> Term Source #

Turn type equality constraints into substitutions and apply them.

So given:

    /\dom . \(eq : dom ~ "System") . \(eta : Signal dom Bool) . eta

we create the substitution [dom := System] and apply it to create:

    \(eq : "System" ~ "System") . \(eta : Signal "System" Bool) . eta

NB: Users of this function should ensure it's only applied to TopEntities

tvSubstWithTyEq :: Type -> Type Source #

The type equivalent of `substWithTyEq`