Clash.Normalize.Util

Utility functions used by the normalisation transformations

Documentation

data ConstantSpecInfo

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

Show ConstantSpecInfo

Defined in Clash.Normalize.Util

Methods

showsPrec :: Int -> ConstantSpecInfo -> ShowS

show :: ConstantSpecInfo -> String

showList :: [ConstantSpecInfo] -> ShowS

isConstantArg

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

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

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

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

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

callGraph :: BindingMap -> Id -> CallGraph

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

collectCallGraphUniques :: CallGraph -> HashSet Unique

Collect all binders mentioned in CallGraph into a HashSet

classifyFunction :: Term -> TermClassification

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

isCheapFunction :: Term -> Bool

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

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

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

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)

rewriteExpr

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

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

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

The type equivalent of substWithTyEq