clash-lib-1.2.0: CAES Language for Synchronous Hardware - As a Library

Clash.Normalize.Util

Description

Utility functions used by the normalisation transformations

Synopsis

# Documentation

Constructors

 ConstantSpecInfo FieldscsrNewBindings :: [(Id, Term)]New let-bindings to be created for all the non-constants foundcsrNewTerm :: !TermA term where all the non-constant constructs are replaced by variable references (found in csrNewBindings)csrFoundConstant :: !BoolWhether the algorithm found a constant at all. (If it didn't, it's no use creating any new let-bindings!)
Instances
 Source # Instance detailsDefined in Clash.Normalize.Util MethodsshowList :: [ConstantSpecInfo] -> ShowS #

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.

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.

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

Arguments

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

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

Determine if a term is closed

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

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

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

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)

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

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.

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

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.

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

The type equivalent of substWithTyEq