Clash.Netlist.Util

Utilities for converting Core Type/Term to Netlist datatypes

Documentation

isVoid :: HWType -> Bool

mkIdentifier :: IdType -> Identifier -> NetlistMonad Identifier

extendIdentifier :: IdType -> Identifier -> Identifier -> NetlistMonad Identifier

splitNormalized :: Fresh m => HashMap TyConOccName TyCon -> Term -> m (Either String ([Id], [LetBinding], Id))

Split a normalized term into: a list of arguments, a list of let-bindings, and a variable reference that is the body of the let-binding. Returns a String containing the error is the term was not in a normalized form.

unsafeCoreTypeToHWType :: SrcSpan -> String -> (HashMap TyConOccName TyCon -> Bool -> Type -> Maybe (Either String HWType)) -> HashMap TyConOccName TyCon -> Bool -> Type -> HWType

Converts a Core type to a HWType given a function that translates certain builtin types. Errors if the Core type is not translatable.

unsafeCoreTypeToHWTypeM :: String -> Type -> NetlistMonad HWType

Converts a Core type to a HWType within the NetlistMonad; errors on failure

coreTypeToHWTypeM :: Type -> NetlistMonad (Maybe HWType)

Converts a Core type to a HWType within the NetlistMonad; Nothing on failure

synchronizedClk

Arguments

:: HashMap TyConOccName TyCon

TyCon cache

-> Type

-> Maybe (Identifier, Integer)

Returns the name and period of the clock corresponding to a type

coreTypeToHWType :: (HashMap TyConOccName TyCon -> Bool -> Type -> Maybe (Either String HWType)) -> HashMap TyConOccName TyCon -> Bool -> Type -> Either String HWType

Converts a Core type to a HWType given a function that translates certain builtin types. Returns a string containing the error message when the Core type is not translatable.

mkADT

Arguments

:: (HashMap TyConOccName TyCon -> Bool -> Type -> Maybe (Either String HWType))

Hardcoded Type -> HWType translator

-> HashMap TyConOccName TyCon

TyCon cache

-> String

String representation of the Core type for error messages

-> Bool

Keep Void

-> TyConName

The TyCon

-> [Type]

Its applied arguments

-> Either String HWType

Converts an algebraic Core type (split into a TyCon and its argument) to a HWType.

isRecursiveTy :: HashMap TyConOccName TyCon -> TyConName -> Bool

Simple check if a TyCon is recursively defined.

representableType

Arguments

:: (HashMap TyConOccName TyCon -> Bool -> Type -> Maybe (Either String HWType))

-> Bool

Allow zero-bit things

-> Bool

String considered representable

-> HashMap TyConOccName TyCon

-> Type

-> Bool

Determines if a Core type is translatable to a HWType given a function that translates certain builtin types.

typeSize :: HWType -> Int

Determines the bitsize of a type

conSize :: HWType -> Int

Determines the bitsize of the constructor of a type

typeLength :: HWType -> Int

Gives the length of length-indexed types

termHWType :: String -> Term -> NetlistMonad HWType

Gives the HWType corresponding to a term. Returns an error if the term has a Core type that is not translatable to a HWType.

termHWTypeM :: Term -> NetlistMonad (Maybe HWType)

Gives the HWType corresponding to a term. Returns Nothing if the term has a Core type that is not translatable to a HWType.

mkUniqueNormalized :: Maybe (Maybe TopEntity) -> ([Id], [LetBinding], Id) -> NetlistMonad ([(Identifier, HWType)], [Declaration], [(Identifier, HWType)], [Declaration], [LetBinding], TmName)

Uniquely rename all the variables and their references in a normalized term

mkUniqueArguments :: Maybe (Maybe TopEntity) -> [Id] -> NetlistMonad ([(Identifier, HWType)], [Declaration], [(TmOccName, Term)])

mkUniqueResult :: Maybe (Maybe TopEntity) -> Id -> NetlistMonad ([(Identifier, HWType)], [Declaration], Id, (TmOccName, Term))

idToPort :: Id -> NetlistMonad (Identifier, HWType)

repName :: String -> Name a -> Name a

mkUnique

Arguments

:: [(TmOccName, Term)]

Existing substitution

-> [Id]

IDs to make unique

-> NetlistMonad ([Id], [(TmOccName, Term)])

(Unique IDs, update substitution)

Make a set of IDs unique; also returns a substitution from old ID to new updated unique ID.

mkUniqueIdentifier :: IdType -> Identifier -> NetlistMonad Identifier

preserveVarEnv :: NetlistMonad a -> NetlistMonad a

Preserve the Netlist _varEnv and _varCount when executing a monadic action

dcToLiteral :: HWType -> Int -> Literal

TopEntity Annotations

extendPorts :: [PortName] -> [Maybe PortName]

appendNumber :: (Identifier, HWType) -> Int -> (Identifier, HWType)

portName :: String -> Identifier -> Identifier

appendIdentifier :: (Identifier, HWType) -> Int -> NetlistMonad (Identifier, HWType)

uniquePortName :: String -> Identifier -> NetlistMonad Identifier

mkInput :: Maybe PortName -> (Identifier, HWType) -> NetlistMonad ([(Identifier, HWType)], [Declaration], Expr, Identifier)

filterVoid :: HWType -> HWType

mkVectorChain :: Int -> HWType -> [Expr] -> Expr

Create a Vector chain for a list of Identifiers

mkRTreeChain :: Int -> HWType -> [Expr] -> Expr

Create a RTree chain for a list of Identifiers

genComponentName :: [Identifier] -> (IdType -> Identifier -> Identifier) -> TmName -> Identifier

mkOutput :: Maybe PortName -> (Identifier, HWType) -> NetlistMonad ([(Identifier, HWType)], [Declaration], Identifier)

Generate output port mappings

mkTopUnWrapper

Arguments

:: TmName

Name of the TopEntity component

-> Maybe TopEntity

(maybe) a corresponding TopEntity annotation

-> Manifest

a corresponding Manifest

-> (Identifier, HWType)

The name and type of the signal to which to assign the result

-> [(Expr, HWType)]

The arguments

-> NetlistMonad [Declaration]

Instantiate a TopEntity, and add the proper type-conversions where needed

argBV

Arguments

:: Maybe Identifier

(maybe) Name of the _TopEntity_

-> Either Identifier (Identifier, HWType)

Either: * A normal argument * An argument with a PortName

-> Expr

-> Declaration

Convert between BitVector for an argument

resBV

Arguments

:: Maybe Identifier

(mabye) Name of the _TopEntity_

-> Either Identifier (Identifier, HWType)

Either: * A normal result * A result with a PortName

-> Expr

Convert between BitVector for the result

doConv

Arguments

:: HWType

We only need it for certain types

-> Maybe (Maybe Identifier)

• Nothing: No _given_ TopEntity, no need for conversion, this happens when we have a _TestBench_, but no _TopEntity_ annotation.
• Just Nothing: Converting to/from a BitVector for one of the internally defined types.
• Just (Just top): Converting to/from a BitVector for one of the types defined by top.

-> Bool

• True: convert to a BitVector
• False: convert from a BitVector

-> Expr

The expression on top of which we have to add conversion logic

-> Expr

Add to/from-BitVector conversion logic

mkTopInput

Arguments

:: Maybe Identifier

(maybe) Name of the _TopEntity_

-> [(Identifier, Identifier)]

Rendered input port names and types

-> Maybe PortName

(maybe) The PortName of a _TopEntity_ annotation for this input

-> (Identifier, HWType)

-> NetlistMonad ([(Identifier, Identifier)], ([(Identifier, Identifier, HWType)], [Declaration], Either Identifier (Identifier, HWType)))

Generate input port mappings for the TopEntity

mkTopOutput

Arguments

:: Maybe Identifier

(maybe) Name of the _TopEntity_

-> [(Identifier, Identifier)]

Rendered output port names and types

-> Maybe PortName

(maybe) The PortName of a _TopEntity_ annotation for this output

-> (Identifier, HWType)

-> NetlistMonad ([(Identifier, Identifier)], ([(Identifier, Identifier, HWType)], [Declaration], Either Identifier (Identifier, HWType)))

Generate output port mappings for the TopEntity

concatPortDecls3 :: [([(Identifier, Identifier, HWType)], [Declaration], Either Identifier (Identifier, HWType))] -> ([(Identifier, Identifier, HWType)], [Declaration], [Either Identifier (Identifier, HWType)])