clash-prelude 1.8.5 → 1.10.0

raw patch · 103 files changed

+3404/−6136 lines, 103 filesdep +adjunctionsdep +data-defaultdep +distributivedep −data-default-classdep −integer-gmpdep ~QuickCheckdep ~basedep ~containersPVP ok

version bump matches the API change (PVP)

Dependencies added: adjunctions, data-default, distributive

Dependencies removed: data-default-class, integer-gmp

Dependency ranges changed: QuickCheck, base, containers, doctest-parallel, ghc, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat, ghc-typelits-natnormalise, hedgehog, template-haskell, th-abstraction

API changes (from Hackage documentation)

Files

• CHANGELOG.md +101/−1
• LICENSE +1/−1
• README.md +2/−2
• clash-prelude.cabal +36/−44
• src/Clash/Annotations/BitRepresentation.hs +11/−2
• src/Clash/Annotations/BitRepresentation/Deriving.hs +7/−17
• src/Clash/Annotations/BitRepresentation/Internal.hs +14/−3
• src/Clash/Annotations/SynthesisAttributes.hs +3/−4
• src/Clash/Annotations/TH.hs +1/−33
• src/Clash/Annotations/TopEntity.hs +0/−4
• src/Clash/CPP.hs +0/−4
• src/Clash/Class/AutoReg/Internal.hs +0/−10
• src/Clash/Class/BitPack/Internal.hs +144/−37
• src/Clash/Class/Counter/Internal.hs +33/−0
• src/Clash/Class/Counter/TH.hs +0/−4
• src/Clash/Class/Exp.hs +3/−6
• src/Clash/Class/HasDomain.hs +3/−1
• src/Clash/Class/HasDomain/Common.hs +1/−2
• src/Clash/Class/HasDomain/HasSingleDomain.hs +3/−4
• src/Clash/Class/HasDomain/HasSpecificDomain.hs +3/−3
• src/Clash/Class/NumConvert.hs +44/−0
• src/Clash/Class/NumConvert/Internal/Canonical.hs +48/−0
• src/Clash/Class/NumConvert/Internal/MaybeNumConvert.hs +161/−0
• src/Clash/Class/NumConvert/Internal/NumConvert.hs +228/−0
• src/Clash/Class/Resize.hs +45/−13
• src/Clash/Clocks/Internal.hs +1/−1
• src/Clash/Explicit/BlockRam.hs +36/−36
• src/Clash/Explicit/BlockRam/Blob.hs +1/−2
• src/Clash/Explicit/BlockRam/File.hs +2/−4
• src/Clash/Explicit/BlockRam/Model.hs +0/−3
• src/Clash/Explicit/DDR.hs +182/−58
• src/Clash/Explicit/Prelude.hs +9/−5
• src/Clash/Explicit/Prelude/Safe.hs +0/−2
• src/Clash/Explicit/RAM.hs +1/−2
• src/Clash/Explicit/ROM.hs +1/−2
• src/Clash/Explicit/ROM/Blob.hs +1/−2
• src/Clash/Explicit/ROM/File.hs +1/−2
• src/Clash/Explicit/Signal.hs +50/−13
• src/Clash/Explicit/Signal/Delayed.hs +1/−1
• src/Clash/Explicit/SimIO.hs +20/−82
• src/Clash/Explicit/Synchronizer.hs +0/−1
• src/Clash/Explicit/Testbench.hs +5/−10
• src/Clash/Explicit/Verification.hs +1/−2
• src/Clash/Intel/ClockGen.hs +4/−70
• src/Clash/Intel/DDR.hs +63/−64
• src/Clash/Magic.hs +12/−22
• src/Clash/NamedTypes.hs +0/−1
• src/Clash/Prelude.hs +12/−15
• src/Clash/Prelude/BlockRam.hs +9/−40
• src/Clash/Prelude/DataFlow.hs +0/−574
• src/Clash/Prelude/ROM.hs +1/−2
• src/Clash/Prelude/ROM/Blob.hs +1/−2
• src/Clash/Prelude/ROM/File.hs +1/−2
• src/Clash/Prelude/Safe.hs +3/−4
• src/Clash/Prelude/Synchronizer.hs +0/−88
• src/Clash/Promoted/Nat.hs +41/−34
• src/Clash/Promoted/Nat/Unsafe.hs +1/−2
• src/Clash/Promoted/Symbol.hs +0/−4
• src/Clash/Signal.hs +70/−696
• src/Clash/Signal/BiSignal.hs +7/−8
• src/Clash/Signal/Bundle.hs +1/−2
• src/Clash/Signal/Bundle/Internal.hs +0/−8
• src/Clash/Signal/Delayed.hs +1/−12
• src/Clash/Signal/Delayed/Bundle.hs +0/−4
• src/Clash/Signal/Delayed/Internal.hs +3/−3
• src/Clash/Signal/Internal.hs +305/−57
• src/Clash/Signal/Internal/Ambiguous.hs +5/−10
• src/Clash/Signal/Trace.hs +7/−14
• src/Clash/Sized/Fixed.hs +2/−18
• src/Clash/Sized/Index.hs +1/−1
• src/Clash/Sized/Internal/BitVector.hs +80/−303
• src/Clash/Sized/Internal/Index.hs +76/−107
• src/Clash/Sized/Internal/Mod.hs +0/−162
• src/Clash/Sized/Internal/Signed.hs +48/−100
• src/Clash/Sized/Internal/Unsigned.hs +47/−221
• src/Clash/Sized/RTree.hs +10/−43
• src/Clash/Sized/Vector.hs +171/−204
• src/Clash/Sized/Vector/ToTuple.hs +0/−17
• src/Clash/Sized/Vector/ToTuple/TH.hs +1/−15
• src/Clash/Tutorial.hs +20/−2500
• src/Clash/XException.hs +13/−24
• src/Clash/XException.hs-boot +3/−2
• src/Clash/XException/MaybeX.hs +0/−3
• src/Clash/Xilinx/ClockGen.hs +2/−4
• src/Clash/Xilinx/DDR.hs +64/−63
• src/Language/Haskell/TH/Compat.hs +0/−13
• tests/Clash/Tests/BitVector.hs +21/−4
• tests/Clash/Tests/BlockRam.hs +1/−1
• tests/Clash/Tests/Index.hs +25/−0
• tests/Clash/Tests/Laws/Num.hs +51/−0
• tests/Clash/Tests/Laws/SaturatingNum.hs +10/−1
• tests/Clash/Tests/MaybeNumConvert.hs +350/−0
• tests/Clash/Tests/MaybeX.hs +0/−3
• tests/Clash/Tests/NumConvert.hs +403/−0
• tests/Clash/Tests/Ram.hs +1/−1
• tests/Clash/Tests/Reset.hs +0/−1
• tests/Clash/Tests/Resize.hs +170/−8
• tests/Clash/Tests/Signal.hs +34/−140
• tests/Clash/Tests/Signed.hs +22/−0
• tests/Clash/Tests/TopEntityGeneration.hs +0/−14
• tests/Clash/Tests/Unsigned.hs +16/−0
• tests/doctests.hs +2/−1
• tests/unittests.hs +9/−1

@@ -1,5 +1,105 @@ # Changelog for the Clash project +## 1.10.0 *Apr 23rd, 2026*++Release highlight:+* `Clash.Class.NumConvert`: Utilities for safely converting between various Clash number types [#2915](https://github.com/clash-lang/clash-compiler/pull/2915)++Added:+* Added GHC 9.12 support+* `Clash.Class.NumConvert`: Utilities for safely converting between various Clash number types [#2915](https://github.com/clash-lang/clash-compiler/pull/2915)+* Add `Clash.XException.ShowX` instance for `Foreign.C.Types.CUShort`. [#2397](https://github.com/clash-lang/clash-compiler/pull/2397)+* Introduced various new types to `Clash.Signal` to more easily represent time and its relation to your clock domain. New types: `Seconds`, `Milliseconds`, `Microseconds`, `Nanoseconds`, `Picoseconds`, `DomainToHz`, `HzToPeriod`, `PeriodToHz`, `PeriodToCycles`, `ClockDivider`. [#2734](https://github.com/clash-lang/clash-compiler/pull/2734)+* `Distributive` and `Representable` instances for `Vec`+* Resize functions `maybeResize` and `maybeTruncateB` to `Clash.Class.Resize`. Can be used to resize without loss of information. [#2779](https://github.com/clash-lang/clash-compiler/issues/2779)+* Alongside the existing Eq-like and Ord-like signal operators like `.==.` and `.<=.` etc., there are now new functions for comparing with constants: `.==`, `==.`, `./=`, `/=.`, `.<=`, `<=.`, `.>=`, `>=.`, `.>`, `>.`, `.<`, `<.`, `.&&`, `&&.`, `.||`, `||.`. These are useful for comparing signals with constants in a more readable way. For example, `a .==. pure True` can now be replaced with `a .== True`. [#2545](https://github.com/clash-lang/clash-compiler/pull/2545)+* instance `HasField f (Signal dom r) (Signal dom a)`. This means record dot accesses will be passed to the underlying type. For example, this will work:++  ```haskell+  data MyRecord = MyRecord { myField :: Int }++  a :: Signal dom MyRecord+  a = pure (MyRecord 3)++  b :: Signal dom Int+  b = a.myField+  ```+* `BitPack` instance for `Data.Proxy.Proxy`+* `apEn`, which is a `mux` that optionally applies an update function to a value. [#3029](https://github.com/clash-lang/clash-compiler/pull/3029)+* `regEnN`, which is a chain of `regEn`s. [#3029](https://github.com/clash-lang/clash-compiler/pull/3029)+* `Index 0` instances for `BitPack`, `Bits`, `Counter`, `FiniteBits`, `Parity`, and `SaturatingNum`. [#2784](https://github.com/clash-lang/clash-compiler/pull/2784)+* Zero-sized block RAM implementations for `blockRam1` and `blockRamU`. [#2784](https://github.com/clash-lang/clash-compiler/pull/2784)+* `Counter a => Counter (Vec 0 a)` instance. [#2784](https://github.com/clash-lang/clash-compiler/pull/2784)+* `SaturatingNum` and `Bounded` instances for `Signal dom a`. The `sat` family (`satAdd`, `satSucc`, ...) can now be used on `Signal`s and `{min,max}Bound` can be used to construct them [#2931](https://github.com/clash-lang/clash-compiler/issues/2931)+* `-fclash-no-concurrent-topentity-compilation` flag to disable concurrent compilation of top entities. This is mostly useful to get a consistent debug output.+* `SomeBoundedSNat` and Hedgehog generators [#3183](https://github.com/clash-lang/clash-compiler/pull/3183)+* `Eq`, `NFData`, `ShowX` and `BitPack` instances for `RamOp`.+* `smapWithBounds` extending `smap` via offering a proof witness for the upper bound of the vector size to the mapping function. [#2686](https://github.com/clash-lang/clash-compiler/pull/2686)+* The function `Clash.Explicit.DDR.ddrForwardClock`, which uses a DDR output primitive to forward a clock signal to a DDR-capable output pin. [#2876](https://github.com/clash-lang/clash-compiler/pull/2876)++Removed:+* Support for GHC versions 9.4 and older+* Newer Verilators (> v5) can deal with delay statements, hence removing the need for Clash specific workarounds. If you relied on Clash-generated Verilator shims, consider using `verilator --build --binary` instead.+* Experimental feature "multiple hidden domains" [#2750](https://github.com/clash-lang/clash-compiler/pull/2750)+* The deprecated module `Clash.Prelude.DataFlow` was removed. The `clash-protocols` package provides dataflow-based protocols and circuits. [#3181](https://github.com/clash-lang/clash-compiler/pull/3181)+* The deprecated functions `altpll` and `alteraPll` were removed from the `Clash.Intel.ClockGen` module. Clash 1.8 introduced the new functions `altpllSync`, `alteraPllSync`, `unsafeAltpll` and `unsafeAlteraPll`. A name for the IP instantiation, handled by the _name_ argument to `altpll` and `alteraPll`, can be provided with the `Clash.Magic.setName` function. [#3181](https://github.com/clash-lang/clash-compiler/pull/3181)++Changed:+* `dfold` now offers a proof witness for the upper bound of the vector size to the folding function. Note that this change may require additional type annotations, as solutions working in the past may complain with an untouchable type error now. [#2686](https://github.com/clash-lang/clash-compiler/pull/2686)+* You can now only create an `SDomainConfiguration` when the `period` of the domain is at least `1`. Pattern matching on an `SDomainConfiguration` bring the `1 <= period` into scope. This in turns enables the following code to typecheck:+  ```+  import Clash.Prelude+  import Data.Proxy++  f ::+    forall dom .+    KnownDomain dom =>+    Proxy dom ->+    SNat (PeriodToCycles dom (Milliseconds 1))+  f Proxy = case knownDomain @dom of+      SDomainConfiguration {} -> SNat+  ```+  where the `DivRU` in+  ```+  type PeriodToCycles (dom :: Domain) (period :: Nat) =  period `DivRU` DomainPeriod dom+  ```+  requires that the `DomainPeriod dom` is at least `1`. [#2740](https://github.com/clash-lang/clash-compiler/pull/2740)+* `select` and `selectI` now use `<=` constraints instead of `CmpNat`. [#2873](https://github.com/clash-lang/clash-compiler/pull/2873)+* `ResetStrategy` now contains the reset function, to avoid dummy arguments on `NoClearOnReset` [#2849](https://github.com/clash-lang/clash-compiler/pull/2849)+* `Clash.Explicit.DDR`, `Clash.Intel.DDR` and `Clash.Xilinx.DDR`: [#2833](https://github.com/clash-lang/clash-compiler/pull/2833)+    - The constraints for the functions have been rewritten to use `DomainPeriod`, which makes them more readable and relaxes unnecessary constraints on the virtual DDR domain. The type-level variables for the domains have been renamed. `dom` is a real domain, `domDDR` is the virtual DDR domain.+    - The Xilinx and Intel primitives only support domains where the rising edge is the active edge. This is now enforced at the type level by adding a constraint.+    - The Xilinx and Intel primitives now directly support any data type that has a `BitPack` instance.+* Order of type arguments for functions in `clash-prelude-hedgehog` now follows _size_, _domain_, _monad_. [#2880](https://github.com/clash-lang/clash-compiler/pull/2880)+* The Clash Prelude now exports the `Default` class from the package `data-default` instead of from the now superseded `data-default-class`. If you import the `Default` class name or the `def` function from the `data-default-class` package _older than version 0.2_, or one of your dependencies does, you might get a bewildering error message. You might get the error "No instance for (Default T)" even though there appears to be such an instance. The best solution is to make sure all your packages and dependencies use the `data-default` package and not the `data-default-class` package. The next most obvious solution is to make sure `data-default-class` is of version 0.2 or higher, for instance by depending on it in your own package. If this creates a dependency conflict, another solution is to import the correct module. `Default` and `def` from `Clash.Prelude` or `Data.Default` are for the new `data-default` package. `Data.Default.Class` is for the `data-default-class` package. There are situations where this will still not be enough, but luckily the `Default` class is not used all that much. [#2891](https://github.com/clash-lang/clash-compiler/pull/2891)+* Changed implementation of `(+>>)` to no longer require `KnownNat`+* The `clash-prelude` package now uses `PolyKinds` by default, meaning all its type class instances are now more general than before. As an example, without `PolyKinds`, `BitPack (Proxy a)` would only be defined when `a :: Type`, with the extension it would be defined for any  `a :: k`. After this change, some instances in user code might now overlap. [#2994](https://github.com/clash-lang/clash-compiler/pull/2994)+* When generating (System)Verilog, Clash now resets the default net type from none to the verilog default after the generated module. [#3005](https://github.com/clash-lang/clash-compiler/pull/3005)+* The content from the `Clash.Tutorial` module and from https://clash-lang.readthedocs.io/ has been split and moved to two new locations.+  1. The actual tutorial parts has been moved to: https://docs.clash-lang.org/tutorial/+  2. Parts that fit better in the clash compiler user guide have been moved to: https://docs.clash-lang.org/compiler-user-guide/++  Moving the documentation to these locations makes it easier to update their content as it is no longer needed to release a new version of the `clash-prelude` package for the publication of this content.+* Vector functions in Verilog now have indices consistent with the Vec inputs/outputs (before they were reversed). This is convenient when writing design constraints, which can now be referenced consistently like `imap[0],imap[1],..`. See [#3088](https://github.com/clash-lang/clash-compiler/issues/3088).++Fixed:+* Clash no longer gives `Dubious primitive instantiation warning` when using `unpack` [#2386](https://github.com/clash-lang/clash-compiler/issues/2386).+* Clash now generates more intuitive names for specialized binders. See [#2508](https://github.com/clash-lang/clash-compiler/issues/2508).+* `foldl` on `Vec` is now strict. See [this GitHub discussion](https://github.com/hasura/graphql-engine/pull/2933#discussion_r328821960) and [this blog post](https://well-typed.com/blog/90/) for more information. [#2482](https://github.com/clash-lang/clash-compiler/issues/2482)+* Type families that appear in GHC core types are now normalized before being translated into their Clash core equivalent. See [#3063](https://github.com/clash-lang/clash-compiler/issues/3063).+* Added an evaluator rule for `bigNatEq#` with compile-time constant arguments [#3084](https://github.com/clash-lang/clash-compiler/issues/3084)+* Reduce constants to NF before specialization [#3129](https://github.com/clash-lang/clash-compiler/issues/3129)+* `rotateL` and `rotateR` no longer error when used on `BitVector 0` [#2980](https://github.com/clash-lang/clash-compiler/issues/2980)+* Behavior of `shiftR` is now documented for `Unsigned`, `BitVector`, `Index`, and `Signed` [#2959](https://github.com/clash-lang/clash-compiler/issues/2959)+* Clash will no longer error if it finds the same data file more than once due to duplicate `-i` flags [#3141](https://github.com/clash-lang/clash-compiler/issues/3141)+* Higher order blackboxes not propagating usage metadata for generated results [#3147](https://github.com/clash-lang/clash-compiler/issues/3147)+* Run `caseCon` after post-normalization `inlineCleanup` [#3159](https://github.com/clash-lang/clash-compiler/issues/3159)+* Failure to generate binder assignments in very specific cases [#3185](https://github.com/clash-lang/clash-compiler/issues/3185)+* Clash won't create (invalid) netlist cases on Integer and Natural constructors anymore [#3157](https://github.com/clash-lang/clash-compiler/issues/3157)+* Post-normalization flattening could leave a `Just` constructor as the scrutinee of a `case` after simplifying tuple projections [#3204](https://github.com/clash-lang/clash-compiler/issues/3204)+* Clash no longer crashes on false positive free variable introduction in `reduceConst` and `constantSpec`. Fixes [#3206](https://github.com/clash-lang/clash-compiler/issues/3206).+* `negate` for `Num Bit` is now defined as the additive inverse, i.e., `negate = id`. [#2999](https://github.com/clash-lang/clash-compiler/issues/2999)+ ## 1.8.5 *Mar 24th, 2026*  Added:@@ -358,7 +458,7 @@   * Don't overflow the range of VHDL's natural type in shift/rotate, leading to simulation issues. Shift now saturates to a 31-bit shift amount. For rotate, in simulation only, the rotate amount is modulo the word width of the rotated value [#1874](https://github.com/clash-lang/clash-compiler/pull/1874)   * `shiftL` for Clash datatypes does not cause a crash anymore when running Clash code with a really large shift amount [#1874](https://github.com/clash-lang/clash-compiler/pull/1874)   * VHDL generated for `Signed.fromInteger` now truncates, like the Clash simulation, when the result is smaller than the argument [#1874](https://github.com/clash-lang/clash-compiler/pull/1874)-  * Clash now preserves boolean combinatorial logic better when generating HDL [#1881](https://github.com/clash-lang/clash-compiler/issues/1881)+  * Clash now preserves boolean combinational logic better when generating HDL [#1881](https://github.com/clash-lang/clash-compiler/issues/1881)   * `valid` field of `TemplateFunction` is now checked for includes [#1945](https://github.com/clash-lang/clash-compiler/issues/1945)   * Clash now generates clock generators that ensure that the amount of time between simulation start and the first active edge of the clock is equal to (/or longer than/) the period of the clock. The first active edges of the clocks do still occur simultaneously. [#2001](https://github.com/clash-lang/clash-compiler/issues/2001)   * Expected values in assert become undefined when using `-fclash-compile-ultra` [#2040](https://github.com/clash-lang/clash-compiler/issues/2040)

@@ -1,6 +1,6 @@ Copyright (c) 2013-2016, University of Twente,               2016-2019, Myrtle Software Ltd,-              2017-2019, QBayLogic B.V., Google Inc.+              2017-2025, QBayLogic B.V., Google Inc. All rights reserved.  Redistribution and use in source and binary forms, with or without

@@ -31,6 +31,6 @@  - [Discourse: long form discussions and questions](https://clash-lang.discourse.group/) - [Discord: short form discussions and community chat room](https://discord.gg/rebGq25FB4)-- [Slack: short form discussions and questions](https://functionalprogramming.slack.com/archives/CPGMJFF50)-  (Invite yourself at [fpslack.com](https://fpslack.com))+- [Fosstodon: microblogging and community chat room](https://fosstodon.org/@ClashHDL)+- [Bluesky: microblogging and community chat room](https://bsky.app/profile/clash-lang.bsky.social) - [Github: issue tracker](https://github.com/clash-lang/clash-compiler/issues)

@@ -1,6 +1,6 @@ Cabal-version:        2.2 Name:                 clash-prelude-Version:              1.8.5+Version:              1.10.0 Synopsis:             Clash: a functional hardware description language - Prelude library Description:   Clash is a functional hardware description language that borrows both its@@ -39,9 +39,10 @@     "Clash.Prelude" and "Clash.Explicit.Prelude" at the same time as they     have overlapping definitions.   .-  A preliminary version of a tutorial can be found in "Clash.Tutorial", for a-  general overview of the library you should however check out "Clash.Prelude".-  Some circuit examples can be found in "Clash.Examples".+  A preliminary version of a tutorial can be found at+  <https://docs.clash-lang.org/tutorial>, for a general overview of the library+  you should however check out "Clash.Prelude". Some circuit examples can be+  found in "Clash.Examples". Homepage:             https://clash-lang.org/ bug-reports:          https://github.com/clash-lang/clash-compiler/issues License:              BSD-2-Clause@@ -51,9 +52,13 @@ Copyright:            Copyright © 2013-2016, University of Twente,                                   2016-2017, Myrtle Software Ltd,                                   2017-2019, QBayLogic B.V., Google Inc.,-                                  2021-2025, QBayLogic B.V.+                                  2021-2026, QBayLogic B.V. Category:             Hardware Build-type:           Simple+tested-with:          GHC == 9.6.7,+                      GHC == 9.8.4,+                      GHC == 9.10.3,+                      GHC == 9.12.4  Extra-source-files:   README.md                       CHANGELOG.md@@ -90,15 +95,6 @@   default: False   manual: True -flag multiple-hidden-  description:-    Allow multiple hidden clocks, resets, and enables to be used. This is an-    experimental feature, possibly triggering confusing error messages. By-    default, it is enabled on development versions of Clash and disabled on-    releases.-  default: False-  manual: True- flag doctests   description:     You can disable testing with doctests using `-f-doctests`.@@ -140,6 +136,7 @@                       KindSignatures                       MagicHash                       NoStarIsType+                      PolyKinds                       PostfixOperators                       ScopedTypeVariables                       StandaloneDeriving@@ -155,12 +152,6 @@   ghc-options:        -Wall -Wcompat -fexpose-all-unfoldings -fno-worker-wrapper   CPP-Options:        -DCABAL -  -- See https://github.com/clash-lang/clash-compiler/pull/2511-  if impl(ghc >= 9.4)-    CPP-Options: -DCLASH_OPAQUE=OPAQUE-  else-    CPP-Options: -DCLASH_OPAQUE=NOINLINE-   if flag(large-tuples)     CPP-Options: -DLARGE_TUPLES @@ -170,12 +161,6 @@   if flag(strict-mapSignal)     CPP-Options: -DCLASH_STRICT_MAPSIGNAL -  if flag(multiple-hidden)-    CPP-Options: -DCLASH_MULTIPLE_HIDDEN--  if flag(multiple-hidden)-    Exposed-modules:  Clash.Prelude.Synchronizer-   Autogen-Modules:    Paths_clash_prelude    Exposed-modules:    Clash.Annotations.TopEntity@@ -204,6 +189,10 @@                       Clash.Class.HasDomain.CodeGen                       Clash.Class.HasDomain.Common                       Clash.Class.Num+                      Clash.Class.NumConvert+                      Clash.Class.NumConvert.Internal.NumConvert+                      Clash.Class.NumConvert.Internal.MaybeNumConvert+                      Clash.Class.NumConvert.Internal.Canonical                       Clash.Class.Parity                       Clash.Class.Resize @@ -252,7 +241,6 @@                       Clash.Prelude.BlockRam                       Clash.Prelude.BlockRam.Blob                       Clash.Prelude.BlockRam.File-                      Clash.Prelude.DataFlow                       Clash.Prelude.Mealy                       Clash.Prelude.Moore                       Clash.Prelude.RAM@@ -332,21 +320,24 @@                       TypeFamilies                       UndecidableInstances -  Build-depends:      array                     >= 0.5.1.0 && < 0.6,+  Build-depends:      adjunctions               >= 4.0     && < 5.0,+                      array                     >= 0.5.1.0 && < 0.6,                       arrows                    >= 0.4     && < 0.5,-                      base                      >= 4.11    && < 5,+                      base                      >= 4.18    && < 5,                       binary                    >= 0.8.5   && < 0.11,                       bytestring                >= 0.10.8  && < 0.13,                       constraints               >= 0.9     && < 1.0,-                      containers                >= 0.4.0   && < 0.8,+                      containers                >= 0.4.0   && < 0.9,                       data-binary-ieee754       >= 0.4.4   && < 0.6,-                      data-default-class        >= 0.1.2   && < 0.3,+                      data-default              >= 0.7     && < 0.9,                       deepseq                   >= 1.4.1.0 && < 1.6,+                      distributive              >= 0.1     && < 1.0,                       extra                     >= 1.6.17  && < 1.9,-                      ghc-prim                  >= 0.5.1.0 && < 0.13,-                      ghc-typelits-extra        >= 0.4     && < 0.6,-                      ghc-typelits-knownnat     >= 0.7.2   && < 0.9,-                      ghc-typelits-natnormalise >= 0.7.2   && < 0.10,+                      ghc-bignum                >= 1.0     && < 1.4,+                      ghc-prim                  >= 0.5.1.0 && < 0.14,+                      ghc-typelits-extra        >= 0.5.3   && < 0.6,+                      ghc-typelits-knownnat     >= 0.8.3   && < 0.9,+                      ghc-typelits-natnormalise >= 0.9.5   && < 0.10,                       hashable                  >= 1.2.1.0  && < 1.6,                       half                      >= 0.2.2.3 && < 1.0,                       infinite-list           ^>= 0.1,@@ -357,8 +348,8 @@                       singletons                >= 2.0     && < 3.1,                       string-interpolate        ^>= 0.3,                       tagged                    >= 0.8     && < 0.9,-                      template-haskell          >= 2.12.0.0 && < 2.23,-                      th-abstraction            >= 0.2.10 && < 0.8.0,+                      template-haskell          >= 2.20.0.0 && < 2.24,+                      th-abstraction            >= 0.3.0 && < 0.8.0,                       th-lift                   >= 0.7.0    && < 0.9,                       th-orphans                >= 0.13.1   && < 1.0,                       text                      >= 0.11.3.1 && < 2.2,@@ -368,13 +359,10 @@                       uniplate                  >= 1.6.12  && < 1.7,                       vector                    >= 0.11    && < 1.0,                       mtl                       >= 2.0     && < 3.0--  if impl(ghc >= 9.0.0)-    Build-Depends:    ghc-bignum                >= 1.0      && < 1.4-  else-    Build-Depends:    integer-gmp               >= 1.0.1.0  && < 2.0+  -- Depend on GHC to obtain the maximum tuple size via+  -- import GHC.Settings.Constants (mAX_TUPLE_SIZE)   if flag(large-tuples)-    Build-Depends:    ghc+    Build-Depends:    ghc                       >= 9.6.0 && < 9.13  test-suite doctests   type:             exitcode-stdio-1.0@@ -389,7 +377,7 @@     build-depends:       base,       clash-prelude,-      doctest-parallel >= 0.2 && < 0.5,+      doctest-parallel >= 0.3.1 && < 0.5,       filepath    if arch(x86_64) && flag(workaround-ghc-mmap-crash)@@ -446,10 +434,13 @@                  Clash.Tests.Clocks                  Clash.Tests.Counter                  Clash.Tests.DumpVCD+                 Clash.Tests.NumConvert                  Clash.Tests.DerivingDataRepr                  Clash.Tests.DerivingDataReprTypes                  Clash.Tests.Fixed                  Clash.Tests.FixedExhaustive+                 Clash.Tests.Index+                 Clash.Tests.MaybeNumConvert                  Clash.Tests.MaybeX                  Clash.Tests.NFDataX                  Clash.Tests.NumNewtypes@@ -465,6 +456,7 @@                  Clash.Tests.XException                   Clash.Tests.Laws.Enum+                 Clash.Tests.Laws.Num                  Clash.Tests.Laws.SaturatingNum                   Hedgehog.Extra

@@ -8,6 +8,7 @@  -} +{-# LANGUAGE CPP #-} {-# LANGUAGE RankNTypes #-}  {-# OPTIONS_GHC -Wno-orphans #-}@@ -28,7 +29,9 @@  ) where  import           Data.Data                  (Data)+#if __GLASGOW_HASKELL__ <= 910 import           Data.Typeable              (Typeable)+#endif import           Language.Haskell.TH.Instances () import qualified Language.Haskell.TH.Lift   () import qualified Language.Haskell.TH.Syntax as TH@@ -112,7 +115,10 @@     Size     -- Constructors:     [ConstrRepr]-      deriving (Show, Data, Typeable, Eq, Generic, TH.Lift)+      deriving (Show, Data, Eq, Generic, TH.Lift)+#if __GLASGOW_HASKELL__ <= 910+      deriving Typeable+#endif  -- | Annotation for constructors. Indicates how to match this constructor based -- off of the whole datatype.@@ -126,4 +132,7 @@     Value     -- Masks for fields. Indicates where fields are stored:     [FieldAnn]-      deriving (Show, Data, Typeable, Eq, Generic, TH.Lift)+      deriving (Show, Data, Eq, Generic, TH.Lift)+#if __GLASGOW_HASKELL__ <= 910+      deriving Typeable+#endif

@@ -74,7 +74,9 @@ import           Data.Containers.ListUtils    (nubOrd) import           Data.List   (mapAccumL, zipWith4, sortOn, partition, uncons)+#if __GLASGOW_HASKELL__ < 912 import           Data.Typeable                (Typeable)+#endif import qualified Data.Map                     as Map import           Data.Maybe                   (fromMaybe) import qualified Data.Set                     as Set@@ -93,7 +95,10 @@   -- ^ Constructor bit should be stored externally   | Embedded BitMask Value   -- ^ Constructor bit should be stored in one of the constructor's fields-    deriving (Show, Data, Typeable, Lift)+    deriving (Show, Data, Lift)+#if __GLASGOW_HASKELL__ < 912+    deriving (Typeable)+#endif  isExternal :: BitMaskOrigin -> Bool isExternal External = True@@ -162,15 +167,9 @@ bitsNeeded :: Integer -> Int bitsNeeded = integerLog2Ceil -#if MIN_VERSION_template_haskell(2,17,0) tyVarBndrName :: TyVarBndr f -> Name tyVarBndrName (PlainTV n _f) = n tyVarBndrName (KindedTV n _f _k) = n-#else-tyVarBndrName :: TyVarBndr -> Name-tyVarBndrName (PlainTV n) = n-tyVarBndrName (KindedTV n _k) = n-#endif  -- | Replace Vars types given in mapping resolve :: NameMap -> Type -> Type@@ -210,11 +209,7 @@       fail $ unwords [           "Could not find custom bit representation nor BitSize instance"         , "for", show typ ++ "." ]-#if MIN_VERSION_template_haskell(2,15,0)     [TySynInstD (TySynEqn _ _ (LitT (NumTyLit n)))] ->-#else-    [TySynInstD _ (TySynEqn _ (LitT (NumTyLit n)))] ->-#endif       [| n |]     [_impl] ->       [| fromIntegral $ natVal (Proxy :: Proxy (BitSize $(return typ))) |]@@ -895,11 +890,7 @@               (\v1 v2 -> [| $v1 ++# $v2 |])               (map (select $ map VarE fieldPackedNames) origins) -#if MIN_VERSION_template_haskell(2,18,0)   return $ Match (ConP name [] (VarP <$> fieldNames)) (NormalB vec) fieldPackedDecls-#else-  return $ Match (ConP name (VarP <$> fieldNames)) (NormalB vec) fieldPackedDecls-#endif  -- | Build a /pack/ function corresponding to given DataRepr buildPack@@ -922,8 +913,7 @@ -- This is used in the generated pack/unpack to not do anything in HDL. dontApplyInHDL :: (a -> b) -> a -> b dontApplyInHDL f a = f a--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE dontApplyInHDL #-}+{-# OPAQUE dontApplyInHDL #-} {-# ANN dontApplyInHDL hasBlackBox #-}  buildUnpackField

@@ -31,7 +31,9 @@ import qualified Data.Map                                 as Map import           Data.Maybe                               (fromMaybe) import qualified Data.Text                                as Text+#if __GLASGOW_HASKELL__ <= 910 import           Data.Typeable                            (Typeable)+#endif import qualified Language.Haskell.TH.Syntax               as TH import           GHC.Generics                             (Generic) import           GHC.Stack                                (HasCallStack)@@ -47,7 +49,10 @@   -- ^ Numeral literal (used in BitVector 10, for example)   | SymLitTy' Text.Text   -- ^ Symbol literal (used in for example (Signal "System" Int))-  deriving (Generic, NFData, Eq, Typeable, Hashable, Ord, Show)+  deriving (Generic, NFData, Eq, Hashable, Ord, Show)+#if __GLASGOW_HASKELL__ <= 910+  deriving Typeable+#endif  -- | Internal version of DataRepr data DataRepr' = DataRepr'@@ -58,7 +63,10 @@   , drConstrs :: [ConstrRepr']   -- ^ Constructors   }-  deriving (Show, Generic, NFData, Eq, Typeable, Hashable, Ord)+  deriving (Show, Generic, NFData, Eq, Hashable, Ord)+#if __GLASGOW_HASKELL__ <= 910+  deriving Typeable+#endif  -- | Internal version of ConstrRepr data ConstrRepr' = ConstrRepr'@@ -73,7 +81,10 @@   , crFieldAnns :: [FieldAnn]   -- ^ Indicates where fields are stored   }-  deriving (Show, Generic, NFData, Eq, Typeable, Ord, Hashable)+  deriving (Show, Generic, NFData, Eq, Ord, Hashable)+#if __GLASGOW_HASKELL__ <= 910+  deriving Typeable+#endif  constrReprToConstrRepr' :: Int -> ConstrRepr -> ConstrRepr' constrReprToConstrRepr' n (ConstrRepr name mask value fieldanns) =

@@ -1,6 +1,6 @@ {-|   Copyright   :  (C) 2018,      Google Inc.,-                     2021-2023, QBayLogic B.V.+                     2021-2025, QBayLogic B.V.   License     :  BSD2 (see the file LICENSE)   Maintainer  :  QBayLogic B.V. <devops@qbaylogic.com> @@ -13,7 +13,6 @@ {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE CPP #-} {-# LANGUAGE NoGeneralizedNewtypeDeriving #-}-{-# LANGUAGE PolyKinds #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskellQuotes #-} @@ -129,7 +128,7 @@ -- "Clash.Magic". annotate :: forall n dom a . Vec n (Attr String) -> Signal dom a -> Signal dom a annotate !_attrs !a = a-{-# CLASH_OPAQUE annotate #-}+{-# OPAQUE annotate #-} {-# ANN annotate hasBlackBox #-} {-# ANN annotate   let primName = show 'annotate@@ -243,5 +242,5 @@ -} annotateReg :: forall n dom a . Vec n (Attr String) -> Signal dom a -> Signal dom a annotateReg !_ x = x-{-# CLASH_OPAQUE annotateReg #-}+{-# OPAQUE annotateReg #-} {-# ANN annotateReg hasBlackBox #-}

@@ -51,7 +51,6 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE PolyKinds #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-}@@ -163,15 +162,7 @@  -- | Grab the 'Name's of type variables in a datatype datatypeVars' :: DatatypeInfo -> [Name]-#if MIN_VERSION_th_abstraction(0,3,0) datatypeVars' d = tvName <$> datatypeVars d-#else-datatypeVars' d = name <$> datatypeVars d- where-  name (VarT n) = n-  name (SigT n _) = name n-  name e = error $ "Unexpected datatype variable name of type " ++ show e-#endif  -- | Run a 'Name' through the template haskell machinery, getting a -- 'DatatypeInfo' if the 'Name' specified a datatype. The result is processed by@@ -322,11 +313,7 @@         --     port tree from the constructor         _ | familyArity info == Just (length xs) -> do           (lift $ reifyInstances x xs) >>= \case-#if MIN_VERSION_template_haskell(2,15,0)             [TySynInstD (TySynEqn _ _ r)] ->-#else-            [TySynInstD _ (TySynEqn _ r)] ->-#endif                 gatherNames (applyFamilyBindings xs info r)              [NewtypeInstD _ _ _ _ c _] -> constructorToPorts c (familyTyMap xs info)@@ -375,17 +362,9 @@     = applyContext ctx (tvName <$> holes) t   applyFamilyBindings _ _ _ = error "familyTyMap called with non family argument!" -#if MIN_VERSION_template_haskell(2,15,0)   tySynArgs (TySynEqn _ args _) = drop 1 (unapp args)-#else-  tySynArgs (TySynEqn args _) = args-#endif -#if MIN_VERSION_template_haskell(2,15,0)   tySynRHS (TySynEqn _ _ r) = r-#else-  tySynRHS (TySynEqn _ r) = r-#endif    familyBindings (FamilyI (ClosedTypeFamilyD (TypeFamilyHead _ xs _ _) _) _) = Just xs   familyBindings (FamilyI (OpenTypeFamilyD (TypeFamilyHead _ xs _ _)) _) = Just xs@@ -444,7 +423,6 @@ -- -- Fail if: -- - There are free type variables.--- - There are multiple hidden clocks handleConstraints :: Type -> ClockType -> Q (Type, ClockType) handleConstraints (ForallT [] [] x) clk = handleConstraints x clk handleConstraints (ForallT xs@(_:_) _ _) _ =@@ -470,7 +448,7 @@ clockToPorts (SingleClockResetEnable) =   return [PortProduct "" [ PortName "clk" , PortName "rst" , PortName "en" ]] clockToPorts Other =-  fail $ failMsg "TH generation for multiple hidden clocks and"+  fail $ failMsg "TH generation for"        ++ " HiddenClock/HiddenReset/HiddenEnable currently unsupported!"  -- *@@ -487,11 +465,7 @@           Just name' -> name'          -- user specified name           Nothing    -> nameBase name  -- auto-generated from Haskell name -#if MIN_VERSION_template_haskell(2,17,0)     (examineCode-#else-    (-#endif                   [|| Synthesize                      { t_name   = outName                      , t_inputs = ins@@ -502,15 +476,9 @@ -- This will return an 'TExp' of 'Nothing' if 'TopEntity' generation failed. maybeBuildTopEntity :: Maybe String -> Name -> Q (TExp (Maybe TopEntity)) maybeBuildTopEntity topName name = do-#if MIN_VERSION_template_haskell(2,17,0)   recover (examineCode [|| Nothing ||]) $ do     let expr = liftCode (getNameBinding name >>= buildTopEntity topName)     examineCode [|| Just ($$expr) ||]-#else-  recover ([|| Nothing ||]) $ do-    let expr = getNameBinding name >>= buildTopEntity topName-    [|| Just ($$expr) ||]-#endif  -- | Turn the 'Name' of a value to a @('Name', 'Type')@ getNameBinding :: Name -> Q (Name, Type)

@@ -231,9 +231,7 @@ import           GHC.Generics import qualified Language.Haskell.TH        as TH import           Language.Haskell.TH.Syntax (Lift(..))-#if MIN_VERSION_template_haskell(2,16,0) import           Language.Haskell.TH.Compat-#endif import           Data.Data  -- | TopEntity annotation@@ -271,9 +269,7 @@       , lift output       ]   lift (TestBench _) = error "Cannot lift a TestBench"-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif  -- | Give port names for arguments/results. --

@@ -21,11 +21,7 @@ #ifndef MAX_TUPLE_SIZE #ifdef LARGE_TUPLES -#if MIN_VERSION_ghc(9,0,0) import GHC.Settings.Constants (mAX_TUPLE_SIZE)-#else-import Constants (mAX_TUPLE_SIZE)-#endif #define MAX_TUPLE_SIZE (fromIntegral mAX_TUPLE_SIZE)  #else

@@ -207,9 +207,7 @@     go acc (AppT ty1 ty2)   = go (ty2:acc) ty1     go acc (SigT ty _)      = go acc ty     go acc (ParensT ty)     = go acc ty-#if MIN_VERSION_template_haskell(2,15,0)     go acc (AppKindT ty _)  = go acc ty-#endif     go acc ty               = (ty, acc)  -- | Automatically derives an 'AutoReg' instance for a product type@@ -255,11 +253,7 @@ deriveAutoRegProduct tyInfo conInfo = go (constructorName conInfo) fieldInfos  where   tyNm = datatypeName tyInfo-#if MIN_VERSION_th_abstraction(0,3,0)   tyArgs = datatypeInstTypes tyInfo-#else-  tyArgs = datatypeVars tyInfo-#endif   ty = conAppsT tyNm tyArgs    fieldInfos =@@ -423,12 +417,8 @@     (InfixT x1 _ y1 , InfixT x2 _ y2)        -> go x1 x2 ++ go y1 y2     (UInfixT x1 _ y1, UInfixT x2 _ y2)       -> go x1 x2 ++ go y1 y2     (ParensT x1     , ParensT x2)            -> go x1 x2--#if __GLASGOW_HASKELL__ >= 808     (AppKindT t1 k1     , AppKindT t2 k2)      -> go t1 t2 ++ go k1 k2     (ImplicitParamT _ x1, ImplicitParamT _ x2) -> go x1 x2-#endif-     (PromotedT _          , PromotedT _          ) -> []     (TupleT _             , TupleT _             ) -> []     (UnboxedTupleT _      , UnboxedTupleT _      ) -> []

@@ -1,8 +1,9 @@ {-| Copyright  :  (C) 2013-2016, University of Twente,                   2016-2017, Myrtle Software Ltd,-                  2021-2025, QBayLogic B.V.,+                  2021-2026, QBayLogic B.V.,                   2022,      Google Inc.+                  2023,      LumiGuide Fietsdetectie B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> -}@@ -29,15 +30,16 @@ import Data.Binary.IEEE754            (doubleToWord, floatToWord, wordToDouble,                                        wordToFloat) +import Data.Char                      (chr, ord) import Data.Complex                   (Complex) import Data.Functor.Compose           (Compose) import Data.Functor.Const             (Const) import Data.Functor.Identity          (Identity) import Data.Functor.Product           (Product) import Data.Functor.Sum               (Sum)-import Data.Char                      (chr, ord) import Data.Int import Data.Ord                       (Down)+import Data.Proxy                     (Proxy) import Data.Word import Foreign.C.Types                (CUShort) import GHC.Generics@@ -57,6 +59,7 @@ >>> :m -Prelude >>> :set -XDataKinds >>> import Clash.Prelude+>>> import Data.Proxy -}  -- | Convert data to/from a 'BitVector'. This allows functions to be defined@@ -91,7 +94,7 @@ -- places. -- -- Clash provides some generic functions on packable types in the prelude, such--- as indexing into packable stuctures (see "Clash.Class.BitPack.BitIndex") and+-- as indexing into packable structures (see "Clash.Class.BitPack.BitIndex") and -- bitwise reduction of packable data (see "Clash.Class.BitPack.BitReduction"). -- class KnownNat (BitSize a) => BitPack a where@@ -251,54 +254,144 @@  instance BitPack Int where   type BitSize Int = WORD_SIZE_IN_BITS-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith toEnum+  unpack = checkUnpackUndef fromEnum  instance BitPack Int8 where   type BitSize Int8 = 8-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packInt8#+  unpack = checkUnpackUndef unpackInt8# +packInt8# :: Int8 -> BitVector 8+packInt8# = fromIntegral+{-# OPAQUE packInt8# #-}+{-# ANN packInt8# hasBlackBox #-}++unpackInt8# :: BitVector 8 -> Int8+unpackInt8# = fromIntegral+{-# OPAQUE unpackInt8# #-}+{-# ANN unpackInt8# hasBlackBox #-}+ instance BitPack Int16 where   type BitSize Int16 = 16-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packInt16#+  unpack = checkUnpackUndef unpackInt16# +packInt16# :: Int16 -> BitVector 16+packInt16# = fromIntegral+{-# OPAQUE packInt16# #-}+{-# ANN packInt16# hasBlackBox #-}++unpackInt16# :: BitVector 16 -> Int16+unpackInt16# = fromIntegral+{-# OPAQUE unpackInt16# #-}+{-# ANN unpackInt16# hasBlackBox #-}+ instance BitPack Int32 where   type BitSize Int32 = 32-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packInt32#+  unpack = checkUnpackUndef unpackInt32# +packInt32# :: Int32 -> BitVector 32+packInt32# = fromIntegral+{-# OPAQUE packInt32# #-}+{-# ANN packInt32# hasBlackBox #-}++unpackInt32# :: BitVector 32 -> Int32+unpackInt32# = fromIntegral+{-# OPAQUE unpackInt32# #-}+{-# ANN unpackInt32# hasBlackBox #-}+ instance BitPack Int64 where   type BitSize Int64 = 64-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packInt64#+  unpack = checkUnpackUndef unpackInt64# +packInt64# :: Int64 -> BitVector 64+packInt64# = fromIntegral+{-# OPAQUE packInt64# #-}+{-# ANN packInt64# hasBlackBox #-}++unpackInt64# :: BitVector 64 -> Int64+unpackInt64# = fromIntegral+{-# OPAQUE unpackInt64# #-}+{-# ANN unpackInt64# hasBlackBox #-}+ instance BitPack Word where   type BitSize Word = WORD_SIZE_IN_BITS-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packWord#+  unpack = checkUnpackUndef unpackWord# +packWord# :: Word -> BitVector WORD_SIZE_IN_BITS+packWord# = fromIntegral+{-# OPAQUE packWord# #-}+{-# ANN packWord# hasBlackBox #-}++unpackWord# :: BitVector WORD_SIZE_IN_BITS -> Word+unpackWord# = fromIntegral+{-# OPAQUE unpackWord# #-}+{-# ANN unpackWord# hasBlackBox #-}+ instance BitPack Word8 where   type BitSize Word8 = 8-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packWord8#+  unpack = checkUnpackUndef unpackWord8# +packWord8# :: Word8 -> BitVector 8+packWord8# = fromIntegral+{-# OPAQUE packWord8# #-}+{-# ANN packWord8# hasBlackBox #-}++unpackWord8# :: BitVector 8 -> Word8+unpackWord8# = fromIntegral+{-# OPAQUE unpackWord8# #-}+{-# ANN unpackWord8# hasBlackBox #-}+ instance BitPack Word16 where   type BitSize Word16 = 16-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packWord16#+  unpack = checkUnpackUndef unpackWord16# +packWord16# :: Word16 -> BitVector 16+packWord16# = fromIntegral+{-# OPAQUE packWord16# #-}+{-# ANN packWord16# hasBlackBox #-}++unpackWord16# :: BitVector 16 -> Word16+unpackWord16# = fromIntegral+{-# OPAQUE unpackWord16# #-}+{-# ANN unpackWord16# hasBlackBox #-}+ instance BitPack Word32 where   type BitSize Word32 = 32-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packWord32#+  unpack = checkUnpackUndef unpackWord32# +packWord32# :: Word32 -> BitVector 32+packWord32# = fromIntegral+{-# OPAQUE packWord32# #-}+{-# ANN packWord32# hasBlackBox #-}++unpackWord32# :: BitVector 32 -> Word32+unpackWord32# = fromIntegral+{-# OPAQUE unpackWord32# #-}+{-# ANN unpackWord32# hasBlackBox #-}+ instance BitPack Word64 where   type BitSize Word64 = 64-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packWord64#+  unpack = checkUnpackUndef unpackWord64# +packWord64# :: Word64 -> BitVector 64+packWord64# = fromIntegral+{-# OPAQUE packWord64# #-}+{-# ANN packWord64# hasBlackBox #-}++unpackWord64# :: BitVector 64 -> Word64+unpackWord64# = fromIntegral+{-# OPAQUE unpackWord64# #-}+{-# ANN unpackWord64# hasBlackBox #-}+ instance BitPack Float where   type BitSize Float = 32   pack   = packXWith packFloat#@@ -306,14 +399,12 @@  packFloat# :: Float -> BitVector 32 packFloat# = fromIntegral . floatToWord--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE packFloat# #-}+{-# OPAQUE packFloat# #-} {-# ANN packFloat# hasBlackBox #-}  unpackFloat# :: BitVector 32 -> Float unpackFloat# (unsafeToNatural -> w) = wordToFloat (fromIntegral w)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unpackFloat# #-}+{-# OPAQUE unpackFloat# #-} {-# ANN unpackFloat# hasBlackBox #-}  instance BitPack Double where@@ -323,21 +414,29 @@  packDouble# :: Double -> BitVector 64 packDouble# = fromIntegral . doubleToWord--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE packDouble# #-}+{-# OPAQUE packDouble# #-} {-# ANN packDouble# hasBlackBox #-}  unpackDouble# :: BitVector 64 -> Double unpackDouble# (unsafeToNatural -> w) = wordToDouble (fromIntegral w)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unpackDouble# #-}+{-# OPAQUE unpackDouble# #-} {-# ANN unpackDouble# hasBlackBox #-}  instance BitPack CUShort where   type BitSize CUShort = 16-  pack   = packXWith fromIntegral-  unpack = checkUnpackUndef fromIntegral+  pack   = packXWith packCUShort#+  unpack = checkUnpackUndef unpackCUShort# +packCUShort# :: CUShort -> BitVector 16+packCUShort# = fromIntegral+{-# OPAQUE packCUShort# #-}+{-# ANN packCUShort# hasBlackBox #-}++unpackCUShort# :: BitVector 16 -> CUShort+unpackCUShort# = fromIntegral+{-# OPAQUE unpackCUShort# #-}+{-# ANN unpackCUShort# hasBlackBox #-}+ instance BitPack Half where   type BitSize Half = 16   pack (Half x) = pack x@@ -355,14 +454,12 @@  packChar# :: Char -> BitVector 21 packChar# = fromIntegral . ord--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE packChar# #-}+{-# OPAQUE packChar# #-} {-# ANN packChar# hasBlackBox #-}  unpackChar# :: BitVector 21 -> Char unpackChar# = chr . fromIntegral--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unpackChar# #-}+{-# OPAQUE unpackChar# #-} {-# ANN unpackChar# hasBlackBox #-}  -- | __NB__: The documentation only shows instances up to /3/-tuples. By@@ -481,6 +578,16 @@          ) => BitPack (Either a b)  instance BitPack a => BitPack (Maybe a)++-- | Any 'Proxy' has a bit size of 0 and hence packs to @0 :: BitVector 0@.+--+-- >>> pack (Proxy @())+-- 0+-- >>> pack (Proxy @5)+-- 0+-- >>> pack (Proxy @Bool)+-- 0+instance BitPack (Proxy a)  instance BitPack a => BitPack (Complex a) instance BitPack a => BitPack (Down a)

@@ -1,3 +1,9 @@+{- |+Copyright  :  (C) 2021-2026, QBayLogic B.V.+License    :  BSD2 (see the file LICENSE)+Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>+-}+ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralisedNewtypeDeriving #-} {-# LANGUAGE LambdaCase #-}@@ -14,6 +20,7 @@ import Clash.Sized.Index (Index) import Clash.Sized.Signed (Signed) import Clash.Sized.Unsigned (Unsigned)+import Clash.Sized.Vector as Vec (Vec, repeat, mapAccumR)  import Data.Bifunctor (bimap) import Data.Functor.Identity (Identity(..))@@ -22,11 +29,14 @@ import GHC.TypeLits (KnownNat, type (<=))  -- $setup+-- >>> :m -Prelude+-- >>> import Clash.Prelude -- >>> import Clash.Class.Counter -- >>> import Clash.Sized.BitVector (BitVector) -- >>> import Clash.Sized.Index (Index) -- >>> import Clash.Sized.Signed (Signed) -- >>> import Clash.Sized.Unsigned (Unsigned)+-- >>> import Clash.Sized.Vector (Vec(..), iterate)  -- | t'Clash.Class.Counter.Counter' is a class that composes multiple counters -- into a single one. It is similar to odometers found in olds cars,@@ -193,3 +203,26 @@     (overflowA, a1) = countPredOverflow a0  genTupleInstances maxTupleSize++rippleR :: (a -> (Bool, a)) -> Vec n a -> (Bool, Vec n a)+rippleR f = mapAccumR step True+  where+    step carry x = if carry then f x else (False, x)++-- | Counters on vectors increment from right to left.+--+-- >>> type T = Vec 2 (Index 10)+-- >>> countSucc @T (0 :> 0 :> Nil)+-- 0 :> 1 :> Nil+-- >>> countSucc @T (0 :> 1 :> Nil)+-- 0 :> 2 :> Nil+-- >>> countSucc @T (0 :> 9 :> Nil)+-- 1 :> 0 :> Nil+-- >>> iterate (SNat @5) (countSucc @T) (9 :> 8 :> Nil)+-- (9 :> 8 :> Nil) :> (9 :> 9 :> Nil) :> (0 :> 0 :> Nil) :> (0 :> 1 :> Nil) :> (0 :> 2 :> Nil) :> Nil+instance (Counter a, KnownNat n) => Counter (Vec n a) where+    countMin = Vec.repeat countMin+    countMax = Vec.repeat countMax++    countSuccOverflow = rippleR countSuccOverflow+    countPredOverflow = rippleR countPredOverflow

@@ -15,11 +15,7 @@ mkTupTy names@(length -> n) = foldl AppT (TupleT n) names  mkTup :: [Exp] -> Exp-#if MIN_VERSION_template_haskell(2,16,0) mkTup = TupE . map Just-#else-mkTup = TupE-#endif  genTupleInstances :: Int -> Q [Dec] genTupleInstances maxTupleSize = mapM genTupleInstance [3..maxTupleSize]

@@ -75,8 +75,7 @@   -> Index (Max 2 (m ^ n)) expIndex# b e@SNat =   fromInteger (toInteger b P.^ snatToInteger e)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE expIndex# #-}+{-# OPAQUE expIndex# #-} {-# ANN expIndex# hasBlackBox #-}  expSigned#@@ -86,8 +85,7 @@   -> Signed (Max 2 (m * n)) expSigned# b e@SNat =   fromInteger (toInteger b P.^ snatToInteger e)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE expSigned# #-}+{-# OPAQUE expSigned# #-} {-# ANN expSigned# hasBlackBox #-}  expUnsigned#@@ -97,6 +95,5 @@   -> Unsigned (Max 1 (m * n)) expUnsigned# b e@SNat =   fromInteger (toInteger b P.^ snatToInteger e)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE expUnsigned# #-}+{-# OPAQUE expUnsigned# #-} {-# ANN expUnsigned# hasBlackBox #-}

@@ -1,4 +1,6 @@-module Clash.Class.HasDomain+{-# OPTIONS_GHC -Wno-deprecations #-}++module Clash.Class.HasDomain {-# DEPRECATED "Experimental feature multiple hidden has been removed. This module will therefore be removed in Clash 1.12." #-}   ( WithSpecificDomain   , WithSingleDomain 

@@ -4,10 +4,9 @@ Maintainer :  Christiaan Baaij <christiaan.baaij@gmail.com> -} -{-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeFamilies #-} -module Clash.Class.HasDomain.Common+module Clash.Class.HasDomain.Common {-# DEPRECATED "Experimental feature multiple hidden has been removed. This module will therefore be removed in Clash 1.12." #-}   ( Unlines   , (:<<>>:)   , (:$$$:)

@@ -1,6 +1,6 @@ {-| Copyright  :  (C) 2019, Myrtle Software Ltd-                  2022, QBayLogic B.V.+                  2022-2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> @@ -10,15 +10,14 @@ {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE PolyKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} -{-# OPTIONS_GHC -Wno-missing-methods #-}+{-# OPTIONS_GHC -Wno-missing-methods -Wno-deprecations #-} {-# OPTIONS_HADDOCK not-home #-} -module Clash.Class.HasDomain.HasSingleDomain where+module Clash.Class.HasDomain.HasSingleDomain {-# DEPRECATED "Experimental feature multiple hidden has been removed. This module will therefore be removed in Clash 1.12." #-} where  import           Clash.Class.HasDomain.Common import           Clash.Class.HasDomain.CodeGen    (mkTryDomainTuples)

@@ -1,5 +1,6 @@ {-| Copyright  :  (C) 2019, Myrtle Software Ltd+                  2022-2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  Christiaan Baaij <christiaan.baaij@gmail.com> @@ -10,15 +11,14 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE PolyKinds #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} -{-# OPTIONS_GHC -Wno-missing-methods #-}+{-# OPTIONS_GHC -Wno-missing-methods -Wno-deprecations #-} {-# OPTIONS_HADDOCK not-home #-} -module Clash.Class.HasDomain.HasSpecificDomain where+module Clash.Class.HasDomain.HasSpecificDomain {-# DEPRECATED "Experimental feature multiple hidden has been removed. This module will therefore be removed in Clash 1.12." #-} where  import           Clash.Class.HasDomain.CodeGen  (mkHasDomainTuples) import           Clash.Class.HasDomain.Common

@@ -0,0 +1,44 @@+{- |+Copyright  :  (C) 2025     , Martijn Bastiaan+License    :  BSD2 (see the file LICENSE)+Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>++Utilities for converting between Clash number types in a non-erroring way. Its+existence is motivated by the observation that Clash users often need to convert+between different number types (e.g., @Unsigned@ to @Signed@) and that it is not+always clear how to do so properly. Two classes are exported:++* 'NumConvert': for conversions that, based on types, are guaranteed to succeed.+* 'MaybeNumConvert': for conversions that may fail for some values.++As opposed to 'Prelude.fromIntegral', all conversions are translatable to+synthesizable HDL.++== __Relation to @convertible@__+Type classes exported here are similar to the @convertible@ package in that it+aims to facilitate conversions between different types. It is different in three+ways:++ 1. It offers no partial functions+ 2. All its conversions are translatable to synthesizable HDL+ 3. It is focused on (Clash's) number types++== __Implementing 'NumConvert' for your own type__+If you want to implement 'NumConvert' and 'MaybeNumConvert' for your own type,+see 'NumConvertCanonical'.+-}+module Clash.Class.NumConvert (+  NumConvert,+  numConvert,+  MaybeNumConvert,+  maybeNumConvert,++  -- * For implementers only+  NumConvertCanonical(..),+  MaybeNumConvertCanonical(..),+  Canonical,+) where++import Clash.Class.NumConvert.Internal.MaybeNumConvert+import Clash.Class.NumConvert.Internal.NumConvert+import Clash.Class.NumConvert.Internal.Canonical

@@ -0,0 +1,48 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE TypeFamilies #-}+{-# OPTIONS_HADDOCK hide #-}++#include "MachDeps.h"++{- |+Copyright  :  (C) 2026     , Martijn Bastiaan+License    :  BSD2 (see the file LICENSE)+Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>+-}+module Clash.Class.NumConvert.Internal.Canonical where++import Clash.Sized.BitVector+import Clash.Sized.Index+import Clash.Sized.Signed+import Clash.Sized.Unsigned++import Data.Int (Int16, Int32, Int64, Int8)+import Data.Word (Word16, Word32, Word64, Word8)++-- | Type family mapping types to their canonical \"unwrapped\" Clash form.+-- This is used by 'Clash.Class.NumConvert.numConvert' and+-- 'Clash.Class.NumConvert.maybeNumConvert' to determine the intermediate type.+type family Canonical a++-- Instances for Data.Word types+type instance Canonical Word = Unsigned WORD_SIZE_IN_BITS+type instance Canonical Word64 = Unsigned 64+type instance Canonical Word32 = Unsigned 32+type instance Canonical Word16 = Unsigned 16+type instance Canonical Word8 = Unsigned 8++-- Instances for Data.Int types+type instance Canonical Int = Signed WORD_SIZE_IN_BITS+type instance Canonical Int64 = Signed 64+type instance Canonical Int32 = Signed 32+type instance Canonical Int16 = Signed 16+type instance Canonical Int8 = Signed 8++-- Bit+type instance Canonical Bit = BitVector 1++-- Clash types are already in canonical form+type instance Canonical (Unsigned n) = Unsigned n+type instance Canonical (Signed n) = Signed n+type instance Canonical (BitVector n) = BitVector n+type instance Canonical (Index n) = Index n

@@ -0,0 +1,161 @@+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -fplugin=GHC.TypeLits.Extra.Solver #-}+{-# OPTIONS_GHC -fplugin=GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin=GHC.TypeLits.Normalise #-}+{-# OPTIONS_HADDOCK hide #-}++{- |+Copyright  :  (C) 2025     , Martijn Bastiaan+                  2025-2026, QBayLogic B.V.+License    :  BSD2 (see the file LICENSE)+Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>+-}+module Clash.Class.NumConvert.Internal.MaybeNumConvert where++import Clash.Class.BitPack+import Clash.Class.NumConvert.Internal.NumConvert (NumConvertCanonical (..))+import Clash.Class.NumConvert.Internal.Canonical (Canonical)+import Clash.Class.Resize+import Clash.Promoted.Nat+import Clash.Sized.BitVector+import Clash.Sized.Index+import Clash.Sized.Signed+import Clash.Sized.Unsigned++import GHC.TypeLits (KnownNat, type (+), type (^))+import GHC.TypeLits.Extra (CLogWZ)++{- $setup+>>> import Clash.Prelude+>>> import Clash.Class.NumConvert+>>> import Data.Word+>>> import Data.Int+-}++{- | Internal class for concrete conversions that may fail. This class is used+internally by 'MaybeNumConvert' and should not be used directly. Use+'MaybeNumConvert' instead.+-}+class MaybeNumConvertCanonical a b where+  maybeNumConvertCanonical :: a -> Maybe b++{- | Conversions that may fail for some values. A successful conversion retains+the numerical value interpretation of the source type in the target type. A+failure is expressed by returning 'Nothing', never by an 'Clash.XException.XException'.++== __Laws__+A conversion is either successful or it fails gracefully. I.e., it does not+produce errors (also see "Clash.XException"). I.e.,++> x == fromMaybe x (maybeNumConvert @a @b x >>= maybeNumConvert @b @a)++for all values @x@ of type @a@. It should also preserve the numerical value+interpretation of the bits. For types that have an @Integral@ instance, this+intuition is captured by:++> toInteger x == fromMaybe (toInteger x) (toInteger <$> maybeNumConvert @a @b x)++If a conversion succeeds one way, it should also succeed the other way. I.e.,++> isJust (maybeNumConvert @a @b x) `implies` isJust (maybeNumConvert @a @b x >>= maybeNumConvert @b @a)++A conversion should succeed if and only if the value is representable in the+target type. For types that have a @Bounded@ and @Integral@ instance, this+intuition is captured by:++> isJust (maybeNumConvert @a @b x) == (i x >= i (minBound @b) && i x <= i (maxBound @b))++where @i = toInteger@.++All implementations should be total, i.e., they should not produce \"bottoms\".++Additionally, any implementation should be translatable to synthesizable HDL.+-}+type MaybeNumConvert a b =+  ( NumConvertCanonical a (Canonical a)+  , MaybeNumConvertCanonical (Canonical a) (Canonical b)+  , NumConvertCanonical (Canonical b) b+  )++{- | Convert a supplied value of type @a@ to a value of type @b@. If the value+cannot be represented in the target type, 'Nothing' is returned.++>>> maybeNumConvert (1 :: Index 8) :: Maybe (Unsigned 2)+Just 1+>>> maybeNumConvert (7 :: Index 8) :: Maybe (Unsigned 2)+Nothing++For the time being, if the input is an 'Clash.XException.XException', then+the output is too. This property might be relaxed in the future.+-}+maybeNumConvert :: forall a b. MaybeNumConvert a b => a -> Maybe b+maybeNumConvert a =+    fmap (numConvertCanonical @(Canonical b) @b)+  $ maybeNumConvertCanonical @(Canonical a) @(Canonical b)+  $ numConvertCanonical @a @(Canonical a) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Index n) (Index m) where+  maybeNumConvertCanonical !a = case natToInteger @m of+    0 -> Nothing+    _ -> maybeResize a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Index n) (Unsigned m) where+  maybeNumConvertCanonical !a = maybeResize $ bitCoerce @_ @(Unsigned (CLogWZ 2 n 0)) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Index n) (Signed m) where+  maybeNumConvertCanonical !a = maybeNumConvertCanonical $ bitCoerce @_ @(Unsigned (CLogWZ 2 n 0)) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Index n) (BitVector m) where+  maybeNumConvertCanonical !a = maybeResize $ pack a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Unsigned n) (Index m) where+  maybeNumConvertCanonical !a = case natToInteger @m of+    0 -> Nothing+    _ -> maybeResize $ bitCoerce @_ @(Index (2 ^ n)) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Unsigned n) (Unsigned m) where+  maybeNumConvertCanonical !a = maybeResize a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Unsigned n) (Signed m) where+  maybeNumConvertCanonical !a = maybeResize $ bitCoerce @(Unsigned (n + 1)) $ extend a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Unsigned n) (BitVector m) where+  maybeNumConvertCanonical !a = maybeResize $ pack a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Signed n) (Index m) where+  maybeNumConvertCanonical n = case natToInteger @m of+    0 -> Nothing+    _ | n < 0 -> Nothing+      | otherwise -> maybeResize (bitCoerce @_ @(Index (2 ^ n)) (resize n))++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Signed n) (Unsigned m) where+  maybeNumConvertCanonical n+    | n < 0 = Nothing+    | otherwise = maybeResize (bitCoerce @(Signed (n + 1)) (extend n))++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Signed n) (Signed m) where+  maybeNumConvertCanonical !a = maybeResize a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (Signed n) (BitVector m) where+  maybeNumConvertCanonical n+    | n < 0 = Nothing+    | otherwise = maybeResize (pack @(Signed (n + 1)) (extend n))++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (BitVector n) (Index m) where+  maybeNumConvertCanonical !a = case natToInteger @m of+    0 -> Nothing+    _ -> maybeResize $ unpack @(Index (2 ^ n)) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (BitVector n) (Unsigned m) where+  maybeNumConvertCanonical !a = maybeResize $ unpack @(Unsigned n) a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (BitVector n) (Signed m) where+  maybeNumConvertCanonical !a = maybeResize $ unpack @(Signed (n + 1)) $ extend a++instance (KnownNat n, KnownNat m) => MaybeNumConvertCanonical (BitVector n) (BitVector m) where+  maybeNumConvertCanonical !a = maybeResize a

@@ -0,0 +1,228 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -fplugin=GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_HADDOCK hide #-}++#include "MachDeps.h"++{- |+Copyright  :  (C) 2025     , Martijn Bastiaan+                  2025-2026, QBayLogic B.V.+License    :  BSD2 (see the file LICENSE)+Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>+-}+module Clash.Class.NumConvert.Internal.NumConvert where++import Prelude++import Clash.Class.BitPack+import Clash.Class.NumConvert.Internal.Canonical+import Clash.Class.Resize+import Clash.Sized.BitVector+import Clash.Sized.Index+import Clash.Sized.Signed+import Clash.Sized.Unsigned++import GHC.TypeLits (KnownNat, type (+), type (<=), type (^))+import GHC.TypeLits.Extra (CLogWZ)++import Data.Int (Int16, Int32, Int64, Int8)+import Data.Word (Word16, Word32, Word64, Word8)++{- $setup+>>> import Clash.Prelude+>>> import Clash.Class.NumConvert+>>> import Data.Word+>>> import Data.Int+-}++{- | Internal class for concrete conversions. This class is used internally by+'NumConvert' and should not be used directly. Use 'NumConvert' instead.++If you want to provide an instance for your own type, please only make an+instance for a direct mapping from and to Clash types and tell the instance+what Clash type it corresponds to. For example, implementing 'Int16' looks like:++> instance NumConvertCanonical Int16 (Signed 16) where+>   numConvertCanonical = bitCoerce+>+> instance NumConvertCanonical (Signed 16) Int16 where+>   numConvertCanonical = bitCoerce+>+> type instance Canonical Int16 = Signed 16++By doing this, your type will be convertable from and to any other type. For+example:++>>> numConvert (10 :: Int16) :: Int32+10+>>> numConvert (15 :: Signed 8) :: Int16+15+-}+class NumConvertCanonical a b where+  numConvertCanonical :: a -> b++{- | Conversions that are, based on their types, guaranteed to succeed. A+successful conversion retains the numerical value interpretation of the source+type in the target type and does not produce errors.++== __Laws__+A conversion is successful if a round trip conversion is lossless. I.e.,++> Just x == maybeNumConvert (numConvert @a @b x)++for all values @x@ of type @a@. It should also preserve the numerical value+interpretation of the bits. For types that have an @Integral@ instance, this+intuition is captured by:++> toInteger x == toInteger (numConvert @a @b x)++Instances should make sure their constraints are as \"tight\" as possible. I.e.,+if an instance's constraints cannot be satisfied, then for the same types+'Clash.Class.NumConvert.maybeNumConvert' should return 'Nothing' for one or more+values in the domain of the source type @a@:++> L.any isNothing (L.map (maybeNumConvert @a @b) [minBound ..])++All implementations should be total, i.e., they should not produce \"bottoms\".++Additionally, any implementation should be translatable to synthesizable HDL.+-}+type NumConvert a b =+  ( NumConvertCanonical a (Canonical a)+  , NumConvertCanonical (Canonical a) (Canonical b)+  , NumConvertCanonical (Canonical b) b+  )++{- | Convert a supplied value of type @a@ to a value of type @b@. The conversion+is guaranteed to succeed.++>>> numConvert (3 :: Index 8) :: Unsigned 8+3++The following will fail with a type error, as we cannot prove that all values+of @Index 8@ can be represented by an @Unsigned 2@:++>>> numConvert (3 :: Index 8) :: Unsigned 2+...++For the time being, if the input is an 'Clash.XException.XException', then+the output is too. This property might be relaxed in the future.+-}+numConvert :: forall a b. NumConvert a b => a -> b+numConvert =+    numConvertCanonical @(Canonical b) @b+  . numConvertCanonical @(Canonical a) @(Canonical b)+  . numConvertCanonical @a @(Canonical a)++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (Index n) (Index m) where+  numConvertCanonical = resize++instance (KnownNat n, KnownNat m, n <= 2 ^ m) => NumConvertCanonical (Index n) (Unsigned m) where+  numConvertCanonical !a = resize $ bitCoerce a++{- | Note: Conversion from @Index 1@ to @Signed 0@ is lossless, but not within the+constraints of the instance.+-}+instance (KnownNat n, KnownNat m, CLogWZ 2 n 0 + 1 <= m) => NumConvertCanonical (Index n) (Signed m) where+  numConvertCanonical !a = numConvertCanonical $ bitCoerce @_ @(Unsigned (CLogWZ 2 n 0)) a++instance (KnownNat n, KnownNat m, n <= 2 ^ m) => NumConvertCanonical (Index n) (BitVector m) where+  numConvertCanonical !a = resize $ pack a++instance (KnownNat n, KnownNat m, 2 ^ n <= m) => NumConvertCanonical (Unsigned n) (Index m) where+  numConvertCanonical !a = bitCoerce $ resize a++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (Unsigned n) (Unsigned m) where+  numConvertCanonical = resize++{- | Note: Conversion from @Unsigned 0@ to @Signed 0@ is lossless, but not within the+constraints of the instance.+-}+instance (KnownNat n, KnownNat m, n + 1 <= m) => NumConvertCanonical (Unsigned n) (Signed m) where+  numConvertCanonical !a = bitCoerce $ resize a++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (Unsigned n) (BitVector m) where+  numConvertCanonical !a = resize $ pack a++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (Signed n) (Signed m) where+  numConvertCanonical !a = resize a++instance (KnownNat n, KnownNat m, 2 ^ n <= m) => NumConvertCanonical (BitVector n) (Index m) where+  numConvertCanonical = unpack . resize++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (BitVector n) (Unsigned m) where+  numConvertCanonical = unpack . resize++{- | Note: Conversion from @BitVector 0@ to @Signed 0@ is lossless, but not within the+constraints of the instance.+-}+instance (KnownNat n, KnownNat m, n + 1 <= m) => NumConvertCanonical (BitVector n) (Signed m) where+  numConvertCanonical = unpack . resize++instance (KnownNat n, KnownNat m, n <= m) => NumConvertCanonical (BitVector n) (BitVector m) where+  numConvertCanonical = resize++-- Concrete bidirectional instances for Word types+instance NumConvertCanonical Word (Unsigned WORD_SIZE_IN_BITS) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Unsigned WORD_SIZE_IN_BITS) Word where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Word64 (Unsigned 64) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Unsigned 64) Word64 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Word32 (Unsigned 32) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Unsigned 32) Word32 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Word16 (Unsigned 16) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Unsigned 16) Word16 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Word8 (Unsigned 8) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Unsigned 8) Word8 where+  numConvertCanonical = bitCoerce++-- Concrete bidirectional instances for Int types+instance NumConvertCanonical Int (Signed WORD_SIZE_IN_BITS) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Signed WORD_SIZE_IN_BITS) Int where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Int64 (Signed 64) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Signed 64) Int64 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Int32 (Signed 32) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Signed 32) Int32 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Int16 (Signed 16) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Signed 16) Int16 where+  numConvertCanonical = bitCoerce++instance NumConvertCanonical Int8 (Signed 8) where+  numConvertCanonical = bitCoerce+instance NumConvertCanonical (Signed 8) Int8 where+  numConvertCanonical = bitCoerce++-- Concrete bidirectional instances for Bit+instance NumConvertCanonical Bit (BitVector 1) where+  numConvertCanonical = pack+instance NumConvertCanonical (BitVector 1) Bit where+  numConvertCanonical = unpack

@@ -6,7 +6,8 @@ Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> -} -{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE MonoLocalBinds #-}  {-# LANGUAGE Safe #-} @@ -20,6 +21,8 @@  , checkedResize  , checkedFromIntegral  , checkedTruncateB+ , maybeResize+ , maybeTruncateB  ) where  import Data.Kind (Type)@@ -27,8 +30,11 @@ import GHC.Stack (HasCallStack) import GHC.TypeLits (Nat, KnownNat, type (+)) +import Clash.Magic (clashSimulation) import Clash.Sized.Internal (formatRange) +import GHC.TypeLits (OrderingI(EQI, GTI), cmpNat)+ -- | Coerce a value to be represented by a different number of bits class Resize (f :: Nat -> Type) where   -- | A sign-preserving resize operation@@ -54,20 +60,21 @@   truncateB :: KnownNat a => f (a + b) -> f a  -- | Helper function of 'checkedFromIntegral', 'checkedResize' and 'checkedTruncateB'-checkIntegral ::+checkIntegralSimOnly ::   forall a b.   HasCallStack =>   (Integral a, Integral b, Bounded b) =>   Proxy b ->-  a -> ()-checkIntegral Proxy v =-  if toInteger v > toInteger (maxBound @b)-  || toInteger v < toInteger (minBound @b) then+  a -> a+checkIntegralSimOnly Proxy v =+  if clashSimulation+  && (toInteger v > toInteger (maxBound @b)+  || toInteger v < toInteger (minBound @b)) then     error $ "Given integral " <> show (toInteger v) <> " is out of bounds for" <>             " target type. Bounds of target type are: " <>             formatRange (toInteger (minBound @b)) (toInteger (maxBound @b)) <> "."   else-    ()+    v  -- | Like 'fromIntegral', but errors if /a/ is out of bounds for /b/. Useful when -- you "know" /a/ can't be out of bounds, but would like to have your assumptions@@ -83,8 +90,7 @@   HasCallStack =>   (Integral a, Integral b, Bounded b) =>   a -> b-checkedFromIntegral v =-  checkIntegral (Proxy @b) v `seq` fromIntegral v+checkedFromIntegral v = fromIntegral (checkIntegralSimOnly (Proxy @b) v)  -- | Like 'resize', but errors if /f a/ is out of bounds for /f b/. Useful when -- you "know" /f a/ can't be out of bounds, but would like to have your@@ -99,8 +105,7 @@   , KnownNat a, Integral (f a)   , KnownNat b, Integral (f b), Bounded (f b) ) =>   f a -> f b-checkedResize v =-  checkIntegral (Proxy @(f b)) v `seq` resize v+checkedResize v = resize (checkIntegralSimOnly (Proxy @(f b)) v)  -- | Like 'truncateB', but errors if /f (a + b)/ is out of bounds for /f a/. Useful -- when you "know" /f (a + b)/ can't be out of bounds, but would like to have your@@ -115,5 +120,32 @@   , KnownNat b, Integral (f (a + b))   , KnownNat a, Integral (f a), Bounded (f a) ) =>   f (a + b) -> f a-checkedTruncateB v =-  checkIntegral (Proxy @(f a)) v `seq` truncateB v+checkedTruncateB v = truncateB (checkIntegralSimOnly (Proxy @(f a)) v)++-- | Like 'resize', but returns 'Nothing' if the argument is out of bounds for+-- the result type.+maybeResize ::+  forall a b f.+  ( Resize f+  , KnownNat a, Integral (f a)+  , KnownNat b, Integral (f b), Bounded (f b) ) =>+  f a -> Maybe (f b)+maybeResize v =+  case Proxy @a `cmpNat` Proxy @b of+    GTI | v > resize (maxBound @(f b)) -> Nothing+    GTI | v < resize (minBound @(f b)) -> Nothing+    EQI -> Just v+    _ -> Just (resize v)++-- | Like 'truncateB', but returns 'Nothing' if the argument is out of bounds for+-- the result type.+maybeTruncateB ::+  forall a b f.+  ( Resize f+  , KnownNat b, Integral (f (a + b))+  , KnownNat a, Integral (f a), Bounded (f a) ) =>+  f (a + b) -> Maybe (f a)+maybeTruncateB v+  | v > resize (maxBound @(f a)) = Nothing+  | v < resize (minBound @(f a)) = Nothing+  | otherwise = Just (truncateB v)

@@ -53,7 +53,7 @@          clocks (Clock _ Nothing) $(varP rst) = $funcImpl         clocks _ _ = error "clocks: dynamic clocks unsupported"-        {-# CLASH_OPAQUE clocks #-}+        {-# OPAQUE clocks #-}     |]  where   clkTyVar m = varT $ mkName $ "c" <> show m

@@ -2,7 +2,7 @@ Copyright  :  (C) 2013-2016, University of Twente,                   2016-2017, Myrtle Software Ltd,                   2017     , Google Inc.,-                  2021-2023, QBayLogic B.V.,+                  2021-2026, QBayLogic B.V.,                   2022     , Google Inc.,                   2024     , Alex Mason, License    :  BSD2 (see the file LICENSE)@@ -406,6 +406,8 @@ -- as to why we need this. {-# OPTIONS_GHC -fno-cpr-anal #-} +{-# OPTIONS_GHC -fconstraint-solver-iterations=12 #-}+ module Clash.Explicit.BlockRam   ( -- * Block RAM synchronized to an arbitrary clock     blockRam@@ -429,6 +431,7 @@  import Clash.HaskellPrelude +import Control.DeepSeq (NFData) import Control.Exception (catch, throw) import Control.Monad (forM_) import Control.Monad.ST (ST, runST)@@ -441,17 +444,17 @@ import GHC.Arr (STArray, unsafeReadSTArray, unsafeWriteSTArray) import GHC.Generics (Generic) import GHC.Stack (HasCallStack, withFrozenCallStack)-import GHC.TypeLits (KnownNat, type (^), type (<=))+import GHC.TypeLits (KnownNat, type (^)) import Unsafe.Coerce (unsafeCoerce)  import Clash.Annotations.Primitive   (Primitive(InlineYamlPrimitive), HDL(..), hasBlackBox) import Clash.Class.AutoReg (AutoReg(autoReg))-import Clash.Class.BitPack (bitToBool, msb)+import Clash.Class.BitPack (BitPack, bitToBool, msb) import Clash.Class.Num (SaturationMode(SatBound), satSucc) import Clash.Explicit.BlockRam.Model (TdpbramModelConfig(..), tdpbramModel) import Clash.Explicit.Signal (KnownDomain, Enable, register, fromEnable, andEnable)-import Clash.Promoted.Nat (SNat(..))+import Clash.Promoted.Nat (SNat(..), UNat(..), toUNat) import Clash.Signal.Bundle (unbundle) import Clash.Signal.Internal   (Clock(..), Reset, Signal (..), invertReset, (.&&.), mux)@@ -460,7 +463,7 @@ import Clash.Sized.Unsigned (Unsigned) import Clash.Sized.Vector (Vec, replicate, iterateI) import Clash.XException- (maybeIsX, NFDataX(deepErrorX), defaultSeqX, fromJustX, undefined,+ (ShowX, maybeIsX, NFDataX(deepErrorX), defaultSeqX, fromJustX, undefined,  XException (..), seqX, errorX) import Clash.XException.MaybeX (MaybeX(..), andX) @@ -854,9 +857,9 @@   (blockRam clk en cnt rd wrM) {-# INLINE blockRamPow2 #-} -data ResetStrategy (r :: Bool) where-  ClearOnReset :: ResetStrategy 'True-  NoClearOnReset :: ResetStrategy 'False+data ResetStrategy (r :: Bool) a where+  ClearOnReset :: a -> ResetStrategy 'True a+  NoClearOnReset :: ResetStrategy 'False a  -- | A version of 'blockRam' that has no default values set. May be cleared to -- an arbitrary state using a reset function.@@ -867,7 +870,7 @@      , NFDataX a      , Enum addr      , NFDataX addr-     , 1 <= n )+     )   => Clock dom   -- ^ 'Clock' to synchronize to   -> Reset dom@@ -875,25 +878,31 @@   -- for the BRAM to be reset to its initial state.   -> Enable dom   -- ^ 'Enable' line-  -> ResetStrategy r+  -> ResetStrategy r (Index n -> a)   -- ^ Whether to clear BRAM on asserted reset ('ClearOnReset') or   -- not ('NoClearOnReset'). The reset needs to be asserted for at least /n/   -- cycles to clear the BRAM.   -> SNat n   -- ^ Number of elements in BRAM-  -> (Index n -> a)-  -- ^ If applicable (see 'ResetStrategy' argument), reset BRAM using this function   -> Signal dom addr   -- ^ Read address @r@   -> Signal dom (Maybe (addr, a))   -- ^ (write address @w@, value to write)   -> Signal dom a   -- ^ Value of the BRAM at address @r@ from the previous clock cycle-blockRamU clk rst0 en rstStrategy n@SNat initF rd0 mw0 =-  case rstStrategy of-    ClearOnReset ->+blockRamU clk rst0 en rstStrategy n@SNat rd0 mw0 = case toUNat n of+  UZero -> case rstStrategy of+    ClearOnReset f -> pure $ f undefined+    NoClearOnReset -> pure undefined+  USucc _ -> case rstStrategy of+    ClearOnReset initF ->       -- Use reset infrastructure       blockRamU# clk en n rd1 we1 wa1 w1+      where+        rd1 = mux rstBool 0 (fromEnum <$> rd0)+        we1 = mux rstBool (pure True) we0+        wa1 = mux rstBool (fromInteger . toInteger <$> waCounter) (fromEnum <$> wa0)+        w1  = mux rstBool (initF <$> waCounter) w0     NoClearOnReset ->       -- Ignore reset infrastructure, pass values unchanged       blockRamU# clk en n@@ -912,11 +921,6 @@   w0  = snd . fromJustX <$> mw0   we0 = isJust <$> mw0 -  rd1 = mux rstBool 0 (fromEnum <$> rd0)-  we1 = mux rstBool (pure True) we0-  wa1 = mux rstBool (fromInteger . toInteger <$> waCounter) (fromEnum <$> wa0)-  w1  = mux rstBool (initF <$> waCounter) w0- -- | blockRAMU primitive blockRamU#   :: forall n dom a@@ -947,8 +951,7 @@     (CV.map       (\i -> deepErrorX $ "Initial value at index " <> show i <> " undefined.")       (iterateI @n succ (0 :: Int)))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE blockRamU# #-}+{-# OPAQUE blockRamU# #-} {-# ANN blockRamU# hasBlackBox #-}  -- | A version of 'blockRam' that is initialized with the same value on all@@ -960,7 +963,7 @@      , NFDataX a      , Enum addr      , NFDataX addr-     , 1 <= n )+     )   => Clock dom   -- ^ 'Clock' to synchronize to   -> Reset dom@@ -968,7 +971,7 @@   -- for the BRAM to be reset to its initial state.   -> Enable dom   -- ^ 'Enable' line-  -> ResetStrategy r+  -> ResetStrategy r ()   -- ^ Whether to clear BRAM on asserted reset ('ClearOnReset') or   -- not ('NoClearOnReset'). The reset needs to be asserted for at least /n/   -- cycles to clear the BRAM.@@ -982,9 +985,10 @@   -- ^ (write address @w@, value to write)   -> Signal dom a   -- ^ Value of the BRAM at address @r@ from the previous clock cycle-blockRam1 clk rst0 en rstStrategy n@SNat a rd0 mw0 =-  case rstStrategy of-    ClearOnReset ->+blockRam1 clk rst0 en rstStrategy n@SNat a rd0 mw0 = case toUNat n of+  UZero -> pure a+  USucc _ -> case rstStrategy of+    ClearOnReset () ->       -- Use reset infrastructure       blockRam1# clk en n a rd1 we1 wa1 w1     NoClearOnReset ->@@ -1037,8 +1041,7 @@ blockRam1# clk en n a =   -- TODO: Generalize to single BRAM primitive taking an initialization function   blockRam# clk en (replicate n a)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE blockRam1# #-}+{-# OPAQUE blockRam1# #-} {-# ANN blockRam1# hasBlackBox #-}  -- | blockRAM primitive@@ -1135,8 +1138,7 @@   {-# INLINE safeUpdate #-} blockRam# _ _ _ = error "blockRam#: dynamic clocks not supported" {-# ANN blockRam# hasBlackBox #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE blockRam# #-}+{-# OPAQUE blockRam# #-}  -- | Create a read-after-write block RAM from a read-before-write one readNew@@ -1170,7 +1172,7 @@   -- ^ Write data to address   | RamNoOp   -- ^ No operation-  deriving (Generic, NFDataX, Show)+  deriving (Eq, Generic, NFData, NFDataX, Show, ShowX, BitPack)  instance (AutoReg a, KnownNat n) => AutoReg (RamOp n a) where   autoReg clk rst en initVal input =@@ -1278,11 +1280,9 @@ -- into its own module / architecture. trueDualPortBlockRamWrapper clkA enA weA addrA datA clkB enB weB addrB datB =   trueDualPortBlockRam# clkA enA weA addrA datA clkB enB weB addrB datB--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE trueDualPortBlockRamWrapper #-}+{-# OPAQUE trueDualPortBlockRamWrapper #-} --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE trueDualPortBlockRam# #-}+{-# OPAQUE trueDualPortBlockRam# #-} {-# ANN trueDualPortBlockRam# hasBlackBox #-} {-# ANN trueDualPortBlockRam# (   let

@@ -233,8 +233,7 @@        in forM_ [0..(szI-1)] (\j -> unsafeWriteSTArray s j d)   {-# INLINE safeUpdate #-} {-# ANN blockRamBlob# hasBlackBox #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE blockRamBlob# #-}+{-# OPAQUE blockRamBlob# #-}  {- | Create a 'MemBlob' binding from a list of values 

@@ -423,8 +423,7 @@   parseBV' = fmap fst . listToMaybe . readInt 2 (`elem` "01") digitToInt blockRamFile# _ _ _ _ = error "blockRamFile#: dynamic clocks not supported" --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE blockRamFile# #-}+{-# OPAQUE blockRamFile# #-} {-# ANN blockRamFile# hasBlackBox #-}  -- | __NB__: Not synthesizable@@ -435,5 +434,4 @@                   Just i  -> fromInteger i                   Nothing -> error ("Failed to parse: " ++ s)     parseBV' = fmap fst . listToMaybe . readInt 2 (`elem` "01") digitToInt--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE initMem #-}+{-# OPAQUE initMem #-}

@@ -14,9 +14,6 @@  module Clash.Explicit.BlockRam.Model where -#if !MIN_VERSION_base(4,18,0)-import Control.Applicative (liftA2)-#endif import Control.Exception (throw) import Data.Sequence (Seq) import GHC.Stack (HasCallStack)

@@ -21,21 +21,28 @@  {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE QuasiQuotes #-}+{-# LANGUAGE TemplateHaskellQuotes #-} {-# LANGUAGE TypeFamilies #-}  module Clash.Explicit.DDR   ( ddrIn   , ddrOut+  , ddrForwardClock     -- * Internal   , ddrIn#   , ddrOut#+  , ddrForwardClock#   ) where +import Data.List.Infinite (Infinite(..), (...))+import Data.String.Interpolate (__i) import GHC.Stack (HasCallStack, withFrozenCallStack)+import Unsafe.Coerce (unsafeCoerce) -import Clash.Annotations.Primitive    (hasBlackBox)-import Clash.Explicit.Prelude+import Clash.Annotations.Primitive (hasBlackBox, Primitive(..), HDL(..))+import Clash.Explicit.Prelude hiding ((:<)) import Clash.Signal.Internal  {- $setup@@ -43,9 +50,9 @@ >>> import Clash.Explicit.Prelude >>> import Clash.Explicit.DDR >>> :{-type Fast = ("Fast" :: Domain)-instance KnownDomain "Fast" where-  type KnownConf "Fast" = 'DomainConfiguration "Fast" 5000 'Rising 'Asynchronous 'Defined 'ActiveHigh+type DDR = "DDR" :: Domain+instance KnownDomain "DDR" where+  type KnownConf "DDR" = 'DomainConfiguration "DDR" 5000 'Rising 'Asynchronous 'Defined 'ActiveHigh   knownDomain = SDomainConfiguration SSymbol SNat SRising SAsynchronous SDefined SActiveHigh :} @@ -69,21 +76,23 @@ -- in on the rising clock edge. For a domain with the falling edge as the active -- edge, this is the other way around, but @o0@ still comes before @o1@ in time. ----- >>> sampleN 5 $ ddrIn systemClockGen systemResetGen enableGen (-1,-2,-3) (fromList [0..10] :: Signal Fast Int)+-- >>> sampleN 5 $ ddrIn @Int @System @DDR clockGen resetGen enableGen (-1,-2,-3) (fromList [0..10]) -- [(-1,-2),(-1,-2),(-3,2),(3,4),(5,6)] ddrIn-  :: ( HasCallStack-     , NFDataX a-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity) )-  => Clock slow-  -> Reset slow-  -> Enable slow+  :: forall a dom domDDR+   . HasCallStack+  => NFDataX a+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => Clock dom+  -> Reset dom+  -> Enable dom   -> (a, a, a)   -- ^ Reset values-  -> Signal fast a+  -> Signal domDDR a   -- ^ DDR input signal-  -> Signal slow (a, a)+  -> Signal dom (a, a)   -- ^ Normal speed output pair @(o0, o1)@ ddrIn clk rst en (i0,i1,i2) =   withFrozenCallStack $ ddrIn# clk rst en i0 i1 i2@@ -92,21 +101,22 @@ -- For details about all the seq's en seqX's -- see the [Note: register strictness annotations] in Clash.Signal.Internal ddrIn#-  :: forall a slow fast fPeriod polarity edge reset init-   . ( HasCallStack-     , NFDataX a-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity) )-  => Clock slow-  -> Reset slow-  -> Enable slow+  :: forall a dom domDDR+   . HasCallStack+  => NFDataX a+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => Clock dom+  -> Reset dom+  -> Enable dom   -> a   -> a   -> a-  -> Signal fast a-  -> Signal slow (a,a)+  -> Signal domDDR a+  -> Signal dom (a,a) ddrIn# (Clock _ Nothing) (unsafeToActiveHigh -> hRst) (fromEnable -> ena) i0 i1 i2 =-  case resetKind @fast of+  case resetKind @domDDR of     SAsynchronous ->       goAsync         ( deepErrorX "ddrIn: initial value 0 undefined"@@ -124,10 +134,10 @@   where     goSync       :: (a, a, a)-      -> Signal slow Bool-      -> Signal slow Bool-      -> Signal fast a-      -> Signal slow (a,a)+      -> Signal dom Bool+      -> Signal dom Bool+      -> Signal domDDR a+      -> Signal dom (a,a)     goSync (o0,o1,o2) rt@(~(r :- rs)) ~(e :- es) as@(~(x0 :- x1 :- xs)) =       let (o0',o1',o2') = if r then (i0,i1,i2) else (o2,x0,x1)       in o0 `seqX` o1 `seqX` (o0,o1)@@ -136,10 +146,10 @@      goAsync       :: (a, a, a)-      -> Signal slow Bool-      -> Signal slow Bool-      -> Signal fast a-      -> Signal slow (a, a)+      -> Signal dom Bool+      -> Signal dom Bool+      -> Signal domDDR a+      -> Signal dom (a, a)     goAsync (o0,o1,o2) ~(r :- rs) ~(e :- es) as@(~(x0 :- x1 :- xs)) =       let (o0',o1',o2',o3',o4') = if r then (i0,i1,i0,i1,i2) else (o0,o1,o2,x0,x1)       in o0' `seqX` o1' `seqX` (o0',o1')@@ -148,8 +158,7 @@  ddrIn# _ _ _ _ _ _ =   error "ddrIn#: dynamic clocks not supported"--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE ddrIn# #-}+{-# OPAQUE ddrIn# #-} {-# ANN ddrIn# hasBlackBox #-}  -- | DDR output primitive@@ -170,38 +179,42 @@ -- active edge, this is the other way around, but @i0@ still comes before @i1@ -- in time. ----- >>> sampleN 7 (ddrOut systemClockGen systemResetGen enableGen (-1) (fromList [(0,1),(2,3),(4,5)]) :: Signal Fast Int)+-- >>> sampleN 7 (ddrOut @Int @System @DDR clockGen resetGen enableGen (-1) (fromList [(0,1),(2,3),(4,5)])) -- [-1,-1,-1,2,3,4,5] ddrOut-  :: ( HasCallStack-     , NFDataX a-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity) )-  => Clock slow-  -> Reset slow-  -> Enable slow+  :: forall a dom domDDR+   . HasCallStack+  => NFDataX a+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => Clock dom+  -> Reset dom+  -> Enable dom   -> a   -- ^ Reset value-  -> Signal slow (a, a)+  -> Signal dom (a, a)   -- ^ Normal speed input pair @(i0, i1)@-  -> Signal fast a+  -> Signal domDDR a   -- ^ DDR output signal ddrOut clk rst en i0 =   uncurry (withFrozenCallStack $ ddrOut# clk rst en i0) . unbundle   ddrOut#-  :: ( HasCallStack-     , NFDataX a-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity) )-  => Clock slow-  -> Reset slow-  -> Enable slow+  :: forall a dom domDDR+   . HasCallStack+  => NFDataX a+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => Clock dom+  -> Reset dom+  -> Enable dom   -> a-  -> Signal slow a-  -> Signal slow a-  -> Signal fast a+  -> Signal dom a+  -> Signal dom a+  -> Signal domDDR a ddrOut# clk rst en i0 xs ys =     -- We only observe one reset value, because when the mux switches on the     -- next clock level, the second register will already be outputting its@@ -213,6 +226,117 @@     xs' = register# clk rst en (errorX "ddrOut: unreachable error") i0 xs     ys' = register# clk rst en (deepErrorX "ddrOut: initial value undefined") i0 ys     zipSig (a :- as) (b :- bs) = a :- b :- zipSig as bs--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE ddrOut# #-}+{-# OPAQUE ddrOut# #-} {-# ANN ddrOut# hasBlackBox #-}++-- | Use a DDR output primitive to forward a clock to an output pin+--+-- This function allows outputting a clock signal on a DDR-capable output pin.+-- As with the DDR output primitive itself, the created clock cannot be used+-- internally in the design.+--+-- The @ddrOut@ primitive passed in will always have its enable asserted. If the+-- @Enable@ input of @ddrForwardClock@ is deasserted, the data inputs of the+-- @ddrOut@ primitive will switch to achieve the desired output signal. This is+-- because the behavior of the enable input of the DDR primitive differs between+-- vendor-specific primitives.+--+-- The @Reset@ input of this function is passed on to the @ddrOut@ primitive and+-- not otherwise used by @ddrForwardClock@.+--+-- With the @phase@ argument, the phase relation between input and output clock+-- can be defined. With the argument @Nothing@, the clocks are in phase: the+-- active edge of the output clock is on the active edge of the input clock,+-- even if the domains differ on what the active edge is.+--+-- With the @idle@ argument, the output level when the @Enable@ input is+-- deasserted can be defined. With @Nothing@, it will be 0 for a clock with the+-- rising edge as the active edge, and 1 for a clock with the falling edge as+-- the active edge.+--+-- __NB__: The deassertion of the @Enable@ input or the assertion of the @Reset@+-- input is not faithfully simulated in Haskell simulation: Haskell simulation+-- of a Clash design has clocks that always run. The generated HDL will actually+-- output an idle state when @Enable@ is deasserted (and the reset depends on+-- the @ddrOut@ primitive used).+ddrForwardClock+  :: forall domDDR domOut domIn+   . KnownDomain domOut+  => DomainPeriod domIn ~ DomainPeriod domOut+  => DomainPeriod domIn ~ (2 * DomainPeriod domDDR)+  => Clock domIn+  -> Reset domIn+  -> Enable domIn+  -> Maybe Bit+  -- ^ @idle@: Output value when @Enable@ is deasserted+  -> Maybe Bit+  -- ^ @phase@: Value to output at active edge of incoming clock+  -> (Clock domIn -> Reset domIn -> Enable domIn -> Signal domIn (Bit, Bit)+      -> Signal domDDR Bit)+  -- ^ @ddrOut@ primitive to use+  -> Clock domOut+ddrForwardClock clk rst en idle phase oddr =+  ddrForwardClock# clk $ oddr clk rst enableGen ins+ where+  ins =+    mux+      (fromEnable en)+      (pure (activeLevel, complement activeLevel))+      (pure (idleLevel, idleLevel))+  activeLevel =+    case phase of+      Nothing ->+        case activeEdge @domOut of+          SRising -> 1+          SFalling -> 0+      Just x -> x+  idleLevel =+    case idle of+      Nothing ->+        case activeEdge @domOut of+          SRising -> 0+          SFalling -> 1+      Just x -> x++ddrForwardClock#+  :: KnownDomain domOut+  => DomainPeriod domIn ~ DomainPeriod domOut+  => DomainPeriod domIn ~ (2 * DomainPeriod domDDR)+  => Clock domIn+  -> Signal domDDR Bit+  -> Clock domOut+ddrForwardClock# (Clock SSymbol periods) ddrSignal =+  Clock (ddrSignal `seq` SSymbol) (unsafeCoerce periods)+{-# OPAQUE ddrForwardClock# #-}+{-# ANN ddrForwardClock# (+  let+    bbName = show 'ddrForwardClock#+    _knownDomOut+      :< _domInOutPeriod+      :< _domDDRPeriod+      :< _clkIn+      :< ddrSignal+      :< _ = ((0 :: Int)...)+  in InlineYamlPrimitive [VHDL] [__i|+    BlackBox:+      name: #{bbName}+      kind: Expression+      template: ~TYPMO'(~ARG[#{ddrSignal}])+      workInfo: Never+    |]) #-}+{-# ANN ddrForwardClock# (+  let+    bbName = show 'ddrForwardClock#+    _knownDomOut+      :< _domInOutPeriod+      :< _domDDRPeriod+      :< _clkIn+      :< ddrSignal+      :< _ = ((0 :: Int)...)+  in InlineYamlPrimitive [Verilog, SystemVerilog] [__i|+    BlackBox:+      name: #{bbName}+      kind: Expression+      template: ~ARG[#{ddrSignal}]+      workInfo: Never+    |]) #-}

@@ -2,7 +2,7 @@ Copyright  :  (C) 2013-2016, University of Twente,                   2017     , Google Inc.                   2019     , Myrtle Software Ltd,-                  2021-2023, QBayLogic B.V.,+                  2021-2025, QBayLogic B.V.,                   2022     , Myrtle.ai, License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>@@ -125,6 +125,11 @@     -- ** Template Haskell   , Lift (..)     -- ** Type classes+    -- *** Number conversion+  , NumConvert+  , numConvert+  , MaybeNumConvert+  , maybeNumConvert     -- *** Clash   , module Clash.Class.AutoReg   , module Clash.Class.BitPack@@ -134,7 +139,7 @@     -- *** Other   , module Control.Applicative   , module Data.Bits-  , module Data.Default.Class+  , module Data.Default     -- ** Exceptions   , module Clash.XException     -- ** Named types@@ -149,11 +154,9 @@  import Control.Applicative import Data.Bits-import Data.Default.Class+import Data.Default import GHC.TypeLits-#if MIN_VERSION_base(4,18,0)   hiding (SNat, SSymbol, fromSNat)-#endif import GHC.TypeLits.Extra import Language.Haskell.TH.Syntax  (Lift(..)) import Clash.HaskellPrelude@@ -163,6 +166,7 @@ import Clash.Class.BitPack import Clash.Class.Exp import Clash.Class.Num+import Clash.Class.NumConvert import Clash.Class.Resize import Clash.Magic import Clash.NamedTypes

@@ -117,9 +117,7 @@ import Data.Bits import GHC.Generics (Generic, Generic1) import GHC.TypeLits-#if MIN_VERSION_base(4,18,0)   hiding (SNat, SSymbol, fromSNat)-#endif import GHC.TypeLits.Extra import Clash.HaskellPrelude import qualified Prelude

@@ -212,6 +212,5 @@                            " not in range [0.." ++ show szI ++ ")"))         in d <$ s     {-# INLINE safeUpdate #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE asyncRam# #-}+{-# OPAQUE asyncRam# #-} {-# ANN asyncRam# hasBlackBox #-}

@@ -140,6 +140,5 @@         (deepErrorX ("rom: address " ++ show i ++                      " not in range [0.." ++ show szI ++ ")"))   {-# INLINE safeAt #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE rom# #-}+{-# OPAQUE rom# #-} {-# ANN rom# hasBlackBox #-}

@@ -150,6 +150,5 @@         (deepErrorX ("romBlob: address " ++ show i ++                      " not in range [0.." ++ show szI ++ ")"))   {-# INLINE safeAt #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE romBlob# #-}+{-# OPAQUE romBlob# #-} {-# ANN romBlob# hasBlackBox #-}

@@ -222,6 +222,5 @@       deepErrorX ("romFile: address " ++ show i ++                   " not in range [0.." ++ show szI ++ ")")   {-# INLINE safeAt #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE romFile# #-}+{-# OPAQUE romFile# #-} {-# ANN romFile# hasBlackBox #-}

@@ -3,7 +3,7 @@                   2016-2019, Myrtle Software,                   2017-2022, Google Inc.                   2020     , Ben Gamari,-                  2021-2023, QBayLogic B.V.+                  2021-2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> @@ -173,12 +173,23 @@   , DomainInitBehavior   , DomainResetPolarity     -- *** Convenience types #conveniencetypes#-    -- **** Simplifying     -- $conveniencetypes    , HasSynchronousReset   , HasAsynchronousReset   , HasDefinedInitialValues+  -- **** Time representations+  , Seconds+  , Milliseconds+  , Microseconds+  , Nanoseconds+  , Picoseconds+  -- **** Time conversions+  , DomainToHz+  , HzToPeriod+  , PeriodToHz+  , PeriodToCycles+  , ClockDivider     -- ** Default domains   , System   , XilinxSystem@@ -226,7 +237,9 @@   , register   , regMaybe   , regEn+  , regEnN   , mux+  , apEn     -- * Simulation and testbench functions   , clockGen   , resetGen@@ -265,9 +278,9 @@   , testFor     -- * Type classes     -- ** 'Eq'-like-  , (.==.), (./=.)+  , (.==.), (.==), (==.), (./=.), (./=), (/=.)     -- ** 'Ord'-like-  , (.<.), (.<=.), (.>=.), (.>.)+  , (.<.), (.<), (<.), (.<=.), (.<=), (<=.), (.>=.), (.>=), (>=.), (.>.), (.>), (>.)     -- * Bisignal functions   , veryUnsafeToBiSignalIn   , readFromBiSignal@@ -289,7 +302,8 @@ import           GHC.TypeLits                   (type (<=))  import           Clash.Annotations.Primitive    (hasBlackBox)-import           Clash.Promoted.Nat             (SNat(..), snatToNum)+import           Clash.Promoted.Nat+  (SNat(..), SNatLE(..), compareSNat, leToPlus, snatToNum) import           Clash.Signal.Bundle   (Bundle (..), EmptyTuple(..), TaggedEmptyTuple(..), vecBundle#) import           Clash.Signal.BiSignal@@ -346,6 +360,8 @@  {- $conveniencetypes +==== Simplifying+ If you want to write part of your Clash design as domain-polymorphic functions, it can be practical to define a design-wide constraint synonym that captures the characteristics of the clock domains of the design. Such a constraint synonym@@ -503,8 +519,7 @@       ClockA  -> go ticks as       ClockB  -> a :- go ticks ass       ClockAB -> go (ClockB:ClockA:ticks) ass--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeSynchronizer #-}+{-# OPAQUE unsafeSynchronizer #-} {-# ANN unsafeSynchronizer hasBlackBox #-}  -- | Same as 'unsafeSynchronizer', but with manually supplied clock periods.@@ -554,8 +569,7 @@       ClockA  -> go ticks as       ClockB  -> a :- go ticks ass       ClockAB -> go (ClockB:ClockA:ticks) ass--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE veryUnsafeSynchronizer #-}+{-# OPAQUE veryUnsafeSynchronizer #-} {-# ANN veryUnsafeSynchronizer hasBlackBox #-}  -- * Basic circuit functions@@ -746,6 +760,31 @@   register# clk rst (andEnable gen en) initial initial i {-# INLINE regEn #-} +-- | A chain of 'regEn's.+regEnN ::+  forall dom a n.+  (KnownDomain dom, NFDataX a) =>+  -- | Clock+  Clock dom ->+  -- | Reset, 'regEnN' outputs the reset value when the reset value is active+  Reset dom ->+  -- | Global enable+  Enable dom ->+  -- | The number of stored elements+  SNat n ->+  -- | Initial content of all elements in the chain.+  a ->+  -- | The "push next input" indicator+  Signal dom Bool ->+  Signal dom a ->+  Signal dom a+regEnN clk rst gen n@SNat initial en = case compareSNat n (SNat @0) of+  SNatLE -> id+  SNatGT -> leToPlus @1 @n+          $ Clash.Sized.Vector.last+          . Clash.Sized.Vector.generate n (regEn clk rst gen initial en)+{-# INLINE regEnN #-}+ -- * Simulation functions  -- | Same as 'simulate', but with the reset line asserted for /n/ cycles. Similar@@ -779,8 +818,7 @@   clk = clockGen   en  = enableGen   out = simulate (f clk rst en) inp--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE simulateWithReset #-}+{-# OPAQUE simulateWithReset #-}  -- | Same as 'simulateWithReset', but only sample the first /Int/ output values. simulateWithResetN@@ -886,8 +924,7 @@ sampleWithReset nReset f0 =   let f1 = f0 clockGen (resetGenN @dom nReset) enableGen in   drop (snatToNum nReset) (sample f1)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sampleWithReset #-}+{-# OPAQUE sampleWithReset #-}  -- | Get a fine list of /m/ samples from a 'Signal', while asserting the reset line -- for /n/ clock cycles. 'sampleWithReset' does not return the first /n/ cycles,

@@ -233,7 +233,7 @@ data DelayedFold (dom :: Domain) (n :: Nat) (delay :: Nat) (a :: Type) (f :: TyFun Nat Type) :: Type type instance Apply (DelayedFold dom n delay a) k = DSignal dom (n + (delay*k)) a --- | Tree fold over a 'Vec' of 'DSignal's with a combinatorial function,+-- | Tree fold over a 'Vec' of 'DSignal's with a combinational function, -- and delaying @delay@ cycles after each application. -- Values at times 0..(delay*k)-1 are set to a default. --

@@ -45,14 +45,9 @@ where  import Control.Monad (when)-#if __GLASGOW_HASKELL__ < 900-import Data.Coerce-#endif import Data.IORef import GHC.TypeLits-#if MIN_VERSION_base(4,18,0)   hiding (SNat)-#endif import Prelude hiding (getChar, putChar, getLine) import qualified System.IO as IO import System.IO.Unsafe@@ -68,11 +63,7 @@ -- itself is unlikely to be synthesisable to a digital circuit. -- -- See 'mealyIO' as to its use.-#if __GLASGOW_HASKELL__ >= 900 data SimIO a = SimIO {unSimIO :: !(IO a)}-#else-newtype SimIO a = SimIO {unSimIO :: IO a}-#endif {-# ANN unSimIO hasBlackBox #-}  instance Functor SimIO where@@ -80,8 +71,7 @@  fmapSimIO# :: (a -> b) -> SimIO a -> SimIO b fmapSimIO# f (SimIO m) = SimIO (fmap f m)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE fmapSimIO# #-}+{-# OPAQUE fmapSimIO# #-} {-# ANN fmapSimIO# hasBlackBox #-}  instance Applicative SimIO where@@ -90,30 +80,20 @@  pureSimIO# :: a -> SimIO a pureSimIO# a = SimIO (pure a)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE pureSimIO# #-}+{-# OPAQUE pureSimIO# #-} {-# ANN pureSimIO# hasBlackBox #-}  apSimIO# :: SimIO (a -> b) -> SimIO a -> SimIO b apSimIO# (SimIO f) (SimIO m) = SimIO (f <*> m)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE apSimIO# #-}+{-# OPAQUE apSimIO# #-} {-# ANN apSimIO# hasBlackBox #-}  instance Monad SimIO where-#if !MIN_VERSION_base(4,16,0)-  return = pureSimIO#-#endif   (>>=)  = bindSimIO#  bindSimIO# :: SimIO a -> (a -> SimIO b) -> SimIO b-#if __GLASGOW_HASKELL__ >= 900 bindSimIO# (SimIO m) k = SimIO (m >>= (\x -> x `seqX` unSimIO (k x)))-#else-bindSimIO# (SimIO m) k = SimIO (m >>= (\x -> x `seqX` coerce k x))-#endif--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE bindSimIO# #-}+{-# OPAQUE bindSimIO# #-} {-# ANN bindSimIO# hasBlackBox #-}  -- | Display a string on /stdout/@@ -122,8 +102,7 @@   -- ^ String you want to display   -> SimIO () display s = SimIO (putStrLn s)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE display #-}+{-# OPAQUE display #-} {-# ANN display hasBlackBox #-}  -- | Finish the simulation with an exit code@@ -132,16 +111,11 @@   -- ^ The exit code you want to return at the end of the simulation   -> SimIO a finish i = return (error (show i))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE finish #-}+{-# OPAQUE finish #-} {-# ANN finish hasBlackBox #-}  -- | Mutable reference-#if __GLASGOW_HASKELL__ >= 900 data Reg a = Reg !(IORef a)-#else-newtype Reg a = Reg (IORef a)-#endif  -- | Create a new mutable reference with the given starting value reg@@ -149,15 +123,13 @@   -- ^ The starting value   -> SimIO (Reg a) reg a = SimIO (Reg <$> newIORef a)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE reg #-}+{-# OPAQUE reg #-} {-# ANN reg hasBlackBox #-}  -- | Read value from a mutable reference readReg :: Reg a -> SimIO a readReg (Reg a) = SimIO (readIORef a)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE readReg #-}+{-# OPAQUE readReg #-} {-# ANN readReg hasBlackBox #-}  -- | Write new value to the mutable reference@@ -168,16 +140,11 @@   -- ^ The new value   -> SimIO () writeReg (Reg r) a = SimIO (writeIORef r a)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE writeReg #-}+{-# OPAQUE writeReg #-} {-# ANN writeReg hasBlackBox #-}  -- | File handle-#if __GLASGOW_HASKELL__ >= 900 data File = File !IO.Handle-#else-newtype File = File IO.Handle-#endif  -- | Open a file openFile@@ -193,7 +160,6 @@   -- * "w+": Create for update   -- * "a+": Append, open or create for update at end-of-file   -> SimIO File-#if __GLASGOW_HASKELL__ >= 900 openFile fp "r"   = SimIO $ fmap File (IO.openFile fp IO.ReadMode) openFile fp "w"   = SimIO $ fmap File (IO.openFile fp IO.WriteMode) openFile fp "a"   = SimIO $ fmap File (IO.openFile fp IO.AppendMode)@@ -209,26 +175,8 @@ openFile fp "rb+" = SimIO $ fmap File (IO.openBinaryFile fp IO.ReadWriteMode) openFile fp "wb+" = SimIO $ fmap File (IO.openBinaryFile fp IO.WriteMode) openFile fp "ab+" = SimIO $ fmap File (IO.openBinaryFile fp IO.AppendMode)-#else-openFile fp "r"   = coerce (IO.openFile fp IO.ReadMode)-openFile fp "w"   = coerce (IO.openFile fp IO.WriteMode)-openFile fp "a"   = coerce (IO.openFile fp IO.AppendMode)-openFile fp "rb"  = coerce (IO.openBinaryFile fp IO.ReadMode)-openFile fp "wb"  = coerce (IO.openBinaryFile fp IO.WriteMode)-openFile fp "ab"  = coerce (IO.openBinaryFile fp IO.AppendMode)-openFile fp "r+"  = coerce (IO.openFile fp IO.ReadWriteMode)-openFile fp "w+"  = coerce (IO.openFile fp IO.WriteMode)-openFile fp "a+"  = coerce (IO.openFile fp IO.AppendMode)-openFile fp "r+b" = coerce (IO.openBinaryFile fp IO.ReadWriteMode)-openFile fp "w+b" = coerce (IO.openBinaryFile fp IO.WriteMode)-openFile fp "a+b" = coerce (IO.openBinaryFile fp IO.AppendMode)-openFile fp "rb+" = coerce (IO.openBinaryFile fp IO.ReadWriteMode)-openFile fp "wb+" = coerce (IO.openBinaryFile fp IO.WriteMode)-openFile fp "ab+" = coerce (IO.openBinaryFile fp IO.AppendMode)-#endif openFile _  m     = error ("openFile unknown mode: " ++ show m)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE openFile #-}+{-# OPAQUE openFile #-} {-# ANN openFile hasBlackBox #-}  -- | Close a file@@ -236,8 +184,7 @@   :: File   -> SimIO () closeFile (File fp) = SimIO (IO.hClose fp)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE closeFile #-}+{-# OPAQUE closeFile #-} {-# ANN closeFile hasBlackBox #-}  -- | Read one character from a file@@ -246,8 +193,7 @@   -- ^ File to read from   -> SimIO Char getChar (File fp) = SimIO (IO.hGetChar fp)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE getChar #-}+{-# OPAQUE getChar #-} {-# ANN getChar hasBlackBox #-}  -- | Insert a character into a buffer specified by the file@@ -258,8 +204,7 @@   -- ^ Buffer to insert to   -> SimIO () putChar c (File fp) = SimIO (IO.hPutChar fp c)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE putChar #-}+{-# OPAQUE putChar #-} {-# ANN putChar hasBlackBox #-}  -- | Read one line from a file@@ -282,8 +227,7 @@    rep []     vs          = vs    rep (x:xs) (Cons _ vs) = Cons (toEnum (fromEnum x)) (rep xs vs)    rep _      Nil         = Nil--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE getLine #-}+{-# OPAQUE getLine #-} {-# ANN getLine hasBlackBox #-}  -- | Determine whether we've reached the end of the file@@ -292,8 +236,7 @@   -- ^ File we want to inspect   -> SimIO Bool isEOF (File fp) = SimIO (IO.hIsEOF fp)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE isEOF #-}+{-# OPAQUE isEOF #-} {-# ANN isEOF hasBlackBox #-}  -- | Set the position of the next operation on the file@@ -310,8 +253,7 @@   -- * 2: From the end of the file   -> SimIO Int seek (File fp) pos mode = SimIO (IO.hSeek fp (toEnum mode) pos >> return 0)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE seek #-}+{-# OPAQUE seek #-} {-# ANN seek hasBlackBox #-}  -- | Set the position of the next operation to the beginning of the file@@ -319,8 +261,7 @@   :: File   -> SimIO Int rewind (File fp) = SimIO (IO.hSeek fp IO.AbsoluteSeek 0 >> return 0)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE rewind #-}+{-# OPAQUE rewind #-} {-# ANN rewind hasBlackBox #-}  -- | Returns the offset from the beginning of the file (in bytes).@@ -329,8 +270,7 @@   -- ^ File we want to inspect   -> SimIO Integer tell (File fp) = SimIO (IO.hTell fp)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE tell #-}+{-# OPAQUE tell #-} {-# ANN tell hasBlackBox #-}  -- | Write any buffered output to file@@ -338,8 +278,7 @@   :: File   -> SimIO () flush (File fp) = SimIO (IO.hFlush fp)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE flush #-}+{-# OPAQUE flush #-} {-# ANN flush hasBlackBox #-}  -- | Simulation-level I/O environment that can be synthesized to HDL-level I\/O.@@ -397,5 +336,4 @@  where   go q@(~(k :- ks)) s =     (:-) <$> unSimIO (f s k) <*> unsafeInterleaveIO ((q `seq` go ks s))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE mealyIO #-}+{-# OPAQUE mealyIO #-}

@@ -193,7 +193,6 @@       in  ptr == (complement (slice addrSize a1 s_ptr) ++# slice a2 d0 s_ptr)  -- | Synchronizer implemented as a FIFO around a synchronous RAM. Based on the--- design described in "Clash.Tutorial#multiclock", which is itself based on the -- design described in <http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf>. -- However, this FIFO uses a synchronous dual-ported RAM which, unlike those -- designs using RAM with an asynchronous read port, is nearly guaranteed to

@@ -115,8 +115,7 @@   where     eqX a b = unsafeDupablePerformIO (catch (evaluate (a == b))                                             (\(_ :: XException) -> return False))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE assert #-}+{-# OPAQUE assert #-} {-# ANN assert hasBlackBox #-}  -- | The same as 'assert', but can handle don't care bits in its expected value.@@ -150,8 +149,7 @@   where     eqX a b = unsafeDupablePerformIO (catch (evaluate (a `isLike#` b))                                             (\(_ :: XException) -> return False))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE assertBitVector #-}+{-# OPAQUE assertBitVector #-} {-# ANN assertBitVector hasBlackBox #-}  @@ -430,8 +428,7 @@ -- be optimized away. tbEnableGen :: Enable tag tbEnableGen = toEnable (pure True)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE tbEnableGen #-}+{-# OPAQUE tbEnableGen #-} {-# ANN tbEnableGen hasBlackBox #-}  -- | Clock generator for the 'System' clock domain.@@ -479,8 +476,7 @@   -- | Differential output   DiffClock dom clockToDiffClock clk = DiffClock clk (ClockN SSymbol)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE clockToDiffClock #-}+{-# OPAQUE clockToDiffClock #-} {-# ANN clockToDiffClock hasBlackBox #-}  -- | Cross clock domains in a way that is unsuitable for hardware but good@@ -501,6 +497,5 @@   -> Signal dom1 a   -> Signal dom2 a unsafeSimSynchronizer = unsafeSynchronizer--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeSimSynchronizer #-}+{-# OPAQUE unsafeSimSynchronizer #-} {-# ANN unsafeSimSynchronizer hasBlackBox #-}

@@ -248,8 +248,7 @@   pure (errorX (concat [       "Simulation for Clash.Verification not yet implemented. If you need this,"     , " create an issue at https://github.com/clash-compiler/clash-lang/issues." ]))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE check #-}+{-# OPAQUE check #-} {-# ANN check (InlineYamlPrimitive [Verilog, SystemVerilog, VHDL] [__i|   BlackBoxHaskell:     name: Clash.Explicit.Verification.check

@@ -1,7 +1,7 @@ {-| Copyright  :  (C) 2017-2018, Google Inc                   2019     , Myrtle Software-                  2022-2023, QBayLogic B.V.+                  2022-2026, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> @@ -55,9 +55,6 @@     -- $unsafe_example   , unsafeAltpll   , unsafeAlteraPll-    -- * Deprecated-  , altpll-  , alteraPll   ) where  import GHC.TypeLits (type (<=))@@ -65,10 +62,8 @@ import Clash.Annotations.Primitive (hasBlackBox) import Clash.Clocks   (Clocks(..), ClocksSync(..), ClocksSyncCxt, NumOutClocksSync)-import Clash.Magic (setName)-import Clash.Promoted.Symbol (SSymbol) import Clash.Signal.Internal-  (Signal, Clock, Reset, KnownDomain, HasAsynchronousReset)+  (Clock, Reset, KnownDomain, HasAsynchronousReset)  {- $domains Synthesis domains are denoted by the type-parameter@@ -323,36 +318,6 @@ -- | Instantiate an Intel clock generator corresponding to the Intel/Quartus -- \"ALTPLL\" IP core (Arria GX, Arria II, Stratix IV, Stratix III, Stratix II, -- Stratix, Cyclone 10 LP, Cyclone IV, Cyclone III, Cyclone II, Cyclone) with 1--- reference clock input and a reset input and 1 output clock and a @locked@--- output.------ This function is deprecated because the @locked@ output is an asynchronous--- signal. This means the user is required to add a synchronizer and as such--- this function is unsafe. The common use case is now covered by 'altpllSync'--- and 'unsafeAltpll' offers the functionality of this deprecated function for--- advanced use cases.-altpll ::-  forall domOut domIn name .-  ( HasAsynchronousReset domIn-  , KnownDomain domOut-  ) =>-  -- | Name of the component instance-  ---  -- Instantiate as follows: @(SSymbol \@\"altpll50\")@-  SSymbol name ->-  -- | Free running clock (e.g. a clock pin connected to a crystal oscillator)-  Clock domIn ->-  -- | Reset for the clock generator-  Reset domIn ->-  -- | (Output clock, Clock generator locked)-  (Clock domOut, Signal domOut Bool)-altpll _ = setName @name unsafeAltpll-{-# INLINE altpll #-}-{-# DEPRECATED altpll "This function is unsafe. Please see documentation of the function for alternatives." #-}---- | Instantiate an Intel clock generator corresponding to the Intel/Quartus--- \"ALTPLL\" IP core (Arria GX, Arria II, Stratix IV, Stratix III, Stratix II,--- Stratix, Cyclone 10 LP, Cyclone IV, Cyclone III, Cyclone II, Cyclone) with 1 -- reference clock input and a reset input and 1 to 5 output clocks and a -- @locked@ output. --@@ -373,8 +338,7 @@   Reset domIn ->   t unsafeAltpll = clocks--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeAltpll #-}+{-# OPAQUE unsafeAltpll #-} {-# ANN unsafeAltpll hasBlackBox #-}  -- | Instantiate an Intel clock generator corresponding to the Intel/Quartus@@ -404,35 +368,6 @@ -- \"Altera PLL\" IP core (Arria V, Stratix V, Cyclone V) with 1 reference clock -- input and a reset input and 1 to 18 output clocks and a @locked@ output. ----- This function is deprecated because the @locked@ output is an asynchronous--- signal. This means the user is required to add a synchronizer and as such--- this function is unsafe. The common use case is now covered by--- 'alteraPllSync' and 'unsafeAlteraPll' offers the functionality of this--- deprecated function for advanced use cases.-alteraPll ::-  forall t domIn name .-  ( HasAsynchronousReset domIn-  , Clocks t-  , ClocksCxt t-  , NumOutClocks t <= 18-  ) =>-  -- | Name of the component instance-  ---  -- Instantiate as follows: @(SSymbol \@\"alterapll50\")@-  SSymbol name ->-  -- | Free running clock (e.g. a clock pin connected to a crystal oscillator)-  Clock domIn ->-  -- | Reset for the clock generator-  Reset domIn ->-  t-alteraPll _ = setName @name unsafeAlteraPll-{-# INLINE alteraPll #-}-{-# DEPRECATED alteraPll "This function is unsafe. Please see documentation of the function for alternatives." #-}---- | Instantiate an Intel clock generator corresponding to the Intel/Quartus--- \"Altera PLL\" IP core (Arria V, Stratix V, Cyclone V) with 1 reference clock--- input and a reset input and 1 to 18 output clocks and a @locked@ output.--- -- __NB__: Because the clock generator reacts asynchronously to the incoming -- reset input, the signal __must__ be glitch-free. --@@ -450,6 +385,5 @@   Reset domIn ->   t unsafeAlteraPll = clocks--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeAlteraPll #-}+{-# OPAQUE unsafeAlteraPll #-} {-# ANN unsafeAlteraPll hasBlackBox #-}

@@ -1,9 +1,8 @@ {-| Copyright  :  (C) 2017, Google Inc                   2019, Myrtle Software Ltd-                  2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE)-Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>+Maintainer :  Christiaan Baaij <christiaan.baaij@gmail.com>  DDR primitives for Intel FPGAs using ALTDDIO primitives. @@ -21,9 +20,13 @@ module Clash.Intel.DDR   ( altddioIn   , altddioOut+    -- * Internal+  , altddioIn#+  , altddioOut#   ) where +import Data.Bifunctor import GHC.Stack (HasCallStack, withFrozenCallStack)  import Clash.Annotations.Primitive (hasBlackBox)@@ -38,50 +41,48 @@ -- edge and @o1@ is the data clocked in on the /rising/ edge, and @o0@ comes -- before @o1@ in time. ----- __NB__: This primitive only supports rising edges as the active edge. Trying--- to instantiate this function in a domain where falling edges are the active--- edge will lead to a HDL generation or Haskell simulation error.+-- __NB__: This primitive only supports rising edges as the active edge. altddioIn-  :: forall fast fPeriod edge reset init polarity slow m deviceFamily-   . ( HasCallStack-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity)-     , KnownNat m )+  :: forall deviceFamily a dom domDDR+   . HasCallStack+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => DomainActiveEdge dom ~ 'Rising+  => BitPack a   => SSymbol deviceFamily   -- ^ The FPGA family   --   -- For example this can be instantiated as follows:   --   -- > SSymbol @"Cyclone IV GX"-  -> Clock slow-  -> Reset slow-  -> Enable slow-  -> Signal fast (BitVector m)+  -> Clock dom+  -> Reset dom+  -> Enable dom+  -> Signal domDDR a   -- ^ DDR input signal-  -> Signal slow (BitVector m,BitVector m)+  -> Signal dom (a, a)   -- ^ Normal speed output pair @(o0, o1)@-altddioIn =-  case activeEdge @slow of-    SRising ->-      withFrozenCallStack altddioIn#-    SFalling ->-      clashCompileError-        "altddioIn: Primitive only supports rising active edge"+altddioIn devFam clk rst en =+  fmap (bimap unpack unpack) .+    withFrozenCallStack (altddioIn# devFam clk rst en) . fmap pack  altddioIn#-  :: ( HasCallStack-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod 'Rising reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) 'Rising reset init polarity)-     , KnownNat m )+  :: forall deviceFamily n dom domDDR+   . HasCallStack+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => DomainActiveEdge dom ~ 'Rising+  => KnownNat n   => SSymbol deviceFamily-  -> Clock slow-  -> Reset slow-  -> Enable slow-  -> Signal fast (BitVector m)-  -> Signal slow (BitVector m,BitVector m)+  -> Clock dom+  -> Reset dom+  -> Enable dom+  -> Signal domDDR (BitVector n)+  -> Signal dom (BitVector n, BitVector n) altddioIn# SSymbol clk rst en = withFrozenCallStack ddrIn# clk rst en 0 0 0--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE altddioIn# #-}+{-# OPAQUE altddioIn# #-} {-# ANN altddioIn# hasBlackBox #-}  -- | Intel specific variant of 'ddrOut' implemented using the ALTDDIO_OUT IP core.@@ -92,49 +93,47 @@ -- edge and @i1@ is the data clocked out on the /falling/ edge, and @i0@ comes -- before @i1@ in time. ----- __NB__: This primitive only supports rising edges as the active edge. Trying--- to instantiate this function in a domain where falling edges are the active--- edge will lead to a HDL generation or Haskell simulation error.+-- __NB__: This primitive only supports rising edges as the active edge. altddioOut-  :: forall fast fPeriod edge reset init polarity slow m deviceFamily-   . ( HasCallStack-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod edge reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) edge reset init polarity)-     , KnownNat m )+  :: forall deviceFamily a dom domDDR+   . HasCallStack+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => DomainActiveEdge dom ~ 'Rising+  => BitPack a   => SSymbol deviceFamily   -- ^ The FPGA family   --   -- For example this can be instantiated as follows:   --   -- > SSymbol @"Cyclone IV E"-  -> Clock slow-  -> Reset slow-  -> Enable slow-  -> Signal slow (BitVector m,BitVector m)+  -> Clock dom+  -> Reset dom+  -> Enable dom+  -> Signal dom (a, a)   -- ^ Normal speed input pair @(i0, i1)@-  -> Signal fast (BitVector m)+  -> Signal domDDR a   -- ^ DDR output signal altddioOut devFam clk rst en =-  case activeEdge @slow of-    SRising ->-      uncurry (withFrozenCallStack altddioOut# devFam clk rst en) . unbundle-    SFalling ->-      clashCompileError-        "altddioOut: Primitive only supports rising active edge"+  fmap unpack . uncurry (withFrozenCallStack altddioOut# devFam clk rst en) .+    unbundle . fmap (bimap pack pack)  altddioOut#-  :: ( HasCallStack-     , KnownConfiguration fast ('DomainConfiguration fast fPeriod 'Rising reset init polarity)-     , KnownConfiguration slow ('DomainConfiguration slow (2*fPeriod) 'Rising reset init polarity)-     , KnownNat m )+  :: forall deviceFamily n dom domDDR+   . HasCallStack+  => KnownDomain dom+  => KnownDomain domDDR+  => DomainPeriod dom ~ (2 * DomainPeriod domDDR)+  => DomainActiveEdge dom ~ 'Rising+  => KnownNat n   => SSymbol deviceFamily-  -> Clock slow-  -> Reset slow-  -> Enable slow-  -> Signal slow (BitVector m)-  -> Signal slow (BitVector m)-  -> Signal fast (BitVector m)+  -> Clock dom+  -> Reset dom+  -> Enable dom+  -> Signal dom (BitVector n)+  -> Signal dom (BitVector n)+  -> Signal domDDR (BitVector n) altddioOut# SSymbol clk rst en = ddrOut# clk rst en 0--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE altddioOut# #-}+{-# OPAQUE altddioOut# #-} {-# ANN altddioOut# hasBlackBox #-}

@@ -20,6 +20,7 @@ {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskellQuotes #-}+{-# LANGUAGE Trustworthy #-}  module Clash.Magic   (@@ -58,22 +59,19 @@ prefixName   :: forall (name :: Symbol) a . a -> name ::: a prefixName = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE prefixName #-}+{-# OPAQUE prefixName #-}  -- | Suffix instance and register names with the given 'Symbol' suffixName   :: forall (name :: Symbol) a . a -> name ::: a suffixName = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE suffixName #-}+{-# OPAQUE suffixName #-}  -- | Suffix instance and register names with the given 'Nat' suffixNameFromNat   :: forall (name :: Nat) a . a -> name ::: a suffixNameFromNat = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE suffixNameFromNat #-}+{-# OPAQUE suffixNameFromNat #-}  -- | Suffix instance and register names with the given 'Symbol', but add it -- in front of other suffixes.@@ -96,8 +94,7 @@ suffixNameP   :: forall (name :: Symbol) a . a -> name ::: a suffixNameP = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE suffixNameP #-}+{-# OPAQUE suffixNameP #-}  -- | Suffix instance and register names with the given 'Nat', but add it in -- front of other suffixes.@@ -120,8 +117,7 @@ suffixNameFromNatP   :: forall (name :: Nat) a . a -> name ::: a suffixNameFromNatP = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE suffixNameFromNatP #-}+{-# OPAQUE suffixNameFromNatP #-}  -- | Name the instance or register with the given 'Symbol', instead of using -- an auto-generated name. Pre- and suffixes annotated with 'prefixName' and@@ -130,8 +126,7 @@ setName   :: forall (name :: Symbol) a . a -> name ::: a setName = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE setName #-}+{-# OPAQUE setName #-}  -- | Name a given term, such as one of type 'Clash.Signal.Signal', using the -- given 'SSymbol'. Results in a declaration with the name used as the@@ -150,8 +145,7 @@   -- ^ A hint for a name   -> a -> a nameHint = seq--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE nameHint #-}+{-# OPAQUE nameHint #-} {-# ANN nameHint hasBlackBox #-}  -- | Force deduplication, i.e. share a function or operator between multiple@@ -198,8 +192,7 @@ deDup   :: forall a . a -> a deDup = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE deDup #-}+{-# OPAQUE deDup #-}  -- | Do not deduplicate, i.e. /keep/, an applied function inside a -- case-alternative; do not try to share the function between multiple@@ -258,15 +251,13 @@ noDeDup   :: forall a . a -> a noDeDup = id--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE noDeDup #-}+{-# OPAQUE noDeDup #-}  -- | 'True' in Haskell/Clash simulation. Replaced by 'False' when generating HDL. clashSimulation :: Bool clashSimulation = noinline True -- The 'noinline' is here to prevent SpecConstr from poking through the OPAQUE, see #2736--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE clashSimulation #-}+{-# OPAQUE clashSimulation #-}  -- | A container for data you only want to have around during simulation and -- is ignored during synthesis. Useful for carrying around things such as:@@ -304,8 +295,7 @@ -- descriptive. clashCompileError :: forall a . HasCallStack => String -> a clashCompileError msg = withFrozenCallStack $ error msg--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE clashCompileError #-}+{-# OPAQUE clashCompileError #-} {-# ANN clashCompileError (   let primName = 'clashCompileError   in InlineYamlPrimitive [minBound..] [__i|

@@ -34,7 +34,6 @@ -}  {-# LANGUAGE NoGeneralizedNewtypeDeriving #-}-{-# LANGUAGE PolyKinds #-}  {-# LANGUAGE Safe #-} 

@@ -2,7 +2,7 @@   Copyright   :  (C) 2013-2016, University of Twente,                      2017-2019, Myrtle Software Ltd                      2017     , Google Inc.,-                     2021-2023, QBayLogic B.V.+                     2021-2025, QBayLogic B.V.   License     :  BSD2 (see the file LICENSE)   Maintainer  :  QBayLogic B.V. <devops@qbaylogic.com> @@ -29,8 +29,9 @@     have overlapping definitions.    For now, "Clash.Prelude" is also the best starting point for exploring the-  library. A preliminary version of a tutorial can be found in "Clash.Tutorial".-  Some circuit examples can be found in "Clash.Examples".+  library. A preliminary version of a tutorial can be found at+  https://docs.clash-lang.org/tutorial. Some circuit examples can be found in+  "Clash.Examples". -}  {-# LANGUAGE CPP #-}@@ -52,11 +53,6 @@   , moore   , mooreB   , registerB-#ifdef CLASH_MULTIPLE_HIDDEN-    -- * Synchronizer circuits for safe clock domain crossings-  , dualFlipFlopSynchronizer-  , asyncFIFOSynchronizer-#endif     -- * ROMs   , asyncRom   , asyncRomPow2@@ -146,6 +142,11 @@     -- ** Template Haskell   , Lift (..)     -- ** Type classes+    -- *** Number conversion+  , NumConvert+  , numConvert+  , MaybeNumConvert+  , maybeNumConvert     -- *** Clash   , AutoReg, autoReg, deriveAutoReg   , module Clash.Class.BitPack@@ -156,7 +157,7 @@     -- *** Other   , module Control.Applicative   , module Data.Bits-  , module Data.Default.Class+  , module Data.Default   , module Data.Kind     -- ** Exceptions   , module Clash.XException@@ -174,13 +175,11 @@  import           Control.Applicative import           Data.Bits-import           Data.Default.Class+import           Data.Default import           Data.Kind (Type, Constraint) import           GHC.Stack                   (HasCallStack) import           GHC.TypeLits-#if MIN_VERSION_base(4,18,0)   hiding (SNat, SSymbol, fromSNat)-#endif import           GHC.TypeLits.Extra import           Language.Haskell.TH.Syntax  (Lift(..)) import           Clash.HaskellPrelude@@ -190,6 +189,7 @@ import           Clash.Class.BitPack import           Clash.Class.Exp import           Clash.Class.Num+import           Clash.Class.NumConvert import           Clash.Class.Parity import           Clash.Class.Resize import qualified Clash.Explicit.Prelude      as E@@ -202,9 +202,6 @@ import           Clash.Prelude.ROM.Blob import           Clash.Prelude.ROM.File import           Clash.Prelude.Safe-#ifdef CLASH_MULTIPLE_HIDDEN-import           Clash.Prelude.Synchronizer-#endif import           Clash.Promoted.Nat import           Clash.Promoted.Nat.TH import           Clash.Promoted.Nat.Literals

@@ -2,7 +2,7 @@ Copyright  :  (C) 2013-2016, University of Twente,                   2016-2019, Myrtle Software Ltd,                   2017     , Google Inc.,-                  2021-2022, QBayLogic B.V.+                  2021-2026, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> @@ -404,7 +404,7 @@  import           Prelude                 (Enum, Maybe, Eq) -import           GHC.TypeLits            (KnownNat, type (^), type (<=))+import           GHC.TypeLits            (KnownNat, type (^)) import           GHC.Stack               (HasCallStack, withFrozenCallStack)  import qualified Clash.Explicit.BlockRam as E@@ -740,15 +740,13 @@      , NFDataX a      , Enum addr      , NFDataX addr-     , 1 <= n )-  => E.ResetStrategy r+     )+  => E.ResetStrategy r (Index n -> a)   -- ^ Whether to clear BRAM on asserted reset ('Clash.Explicit.BlockRam.ClearOnReset')   -- or not ('Clash.Explicit.BlockRam.NoClearOnReset'). The reset needs to be   -- asserted for at least /n/ cycles to clear the BRAM.   -> SNat n   -- ^ Number of elements in BRAM-  -> (Index n -> a)-  -- ^ If applicable (see first argument), reset BRAM using this function   -> Signal dom addr   -- ^ Read address @r@   -> Signal dom (Maybe (addr, a))@@ -756,8 +754,8 @@   -> Signal dom a   -- ^ Value of the BRAM at address @r@ from the previous clock cycle blockRamU =-  \rstStrategy cnt initF rd wrM -> withFrozenCallStack-    (hideClockResetEnable E.blockRamU) rstStrategy cnt initF rd wrM+  \rstStrategy cnt rd wrM -> withFrozenCallStack+    (hideClockResetEnable E.blockRamU) rstStrategy cnt rd wrM {-# INLINE blockRamU #-}  -- | A version of 'blockRam' that is initialized with the same value on all@@ -769,8 +767,8 @@      , NFDataX a      , Enum addr      , NFDataX addr-     , 1 <= n )-  => E.ResetStrategy r+     )+  => E.ResetStrategy r ()   -- ^ Whether to clear BRAM on asserted reset ('Clash.Explicit.BlockRam.ClearOnReset')   -- or not ('Clash.Explicit.BlockRam.NoClearOnReset'). The reset needs to be   -- asserted for at least /n/ cycles to clear the BRAM.@@ -838,7 +836,7 @@  {- | Create a read-after-write block RAM from a read-before-write one -#if __GLASGOW_HASKELL__ >= 908 && !defined(CLASH_MULTIPLE_HIDDEN)+#if __GLASGOW_HASKELL__ >= 908 >>> :t readNew (blockRam (0 :> 1 :> Nil)) readNew (blockRam (0 :> 1 :> Nil))   :: ...@@ -846,20 +844,10 @@      ... =>      Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a -#elif __GLASGOW_HASKELL__ >= 902 && !defined(CLASH_MULTIPLE_HIDDEN)->>> :t readNew (blockRam (0 :> 1 :> Nil))-readNew (blockRam (0 :> 1 :> Nil))-  :: ...-     ... =>-     Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a- #else >>> :t readNew (blockRam (0 :> 1 :> Nil)) readNew (blockRam (0 :> 1 :> Nil))   :: ...-     ...-     ...-     ...      ... =>      Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a @@ -888,24 +876,6 @@ -- is: WriteFirst. For mixed-port read/write, when port A writes to the address -- port B reads from, the output of port B is undefined, and vice versa. trueDualPortBlockRam ::-#ifdef CLASH_MULTIPLE_HIDDEN-  forall nAddrs dom1 dom2 a .-  ( HasCallStack-  , KnownNat nAddrs-  , HiddenClock dom1-  , HiddenClock dom2-  , NFDataX a-  )-  => Signal dom1 (E.RamOp nAddrs a)-  -- ^ RAM operation for port A-  -> Signal dom2 (E.RamOp nAddrs a)-  -- ^ RAM operation for port B-  -> (Signal dom1 a, Signal dom2 a)-  -- ^ Outputs data on /next/ cycle. When writing, the data written-  -- will be echoed. When reading, the read data is returned.-trueDualPortBlockRam inA inB =-  E.trueDualPortBlockRam (hasClock @dom1) (hasClock @dom2) inA inB-#else   forall nAddrs dom a .   ( HasCallStack   , KnownNat nAddrs@@ -920,4 +890,3 @@   -- ^ Outputs data on /next/ cycle. When writing, the data written   -- will be echoed. When reading, the read data is returned. trueDualPortBlockRam inA inB = E.trueDualPortBlockRam hasClock hasClock inA inB-#endif

@@ -1,574 +0,0 @@-{-|-Copyright  :  (C) 2013-2016, University of Twente,-                  2017     , Google Inc.-                  2019     , Myrtle Software Ltd,-                  2021     , QBayLogic B.V.-License    :  BSD2 (see the file LICENSE)-Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>--Self-synchronizing circuits based on data-flow principles.--}--{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}-{-# LANGUAGE TypeFamilies #-}--{-# LANGUAGE Safe #-}--{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}-{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise       #-}-{-# OPTIONS_HADDOCK show-extensions #-}--module Clash.Prelude.DataFlow {-# DEPRECATED "Module will be removed in Clash 1.10 in favor of clash-protocols. See: https://github.com/clash-lang/clash-protocols/." #-}-  ( -- * Data types-    DataFlow (..)-    -- * Creating DataFlow circuits-  , liftDF-  , pureDF-  , mealyDF-  , mooreDF-  , fifoDF-    -- * Composition combinators-  , idDF-  , seqDF-  , firstDF-  , swapDF-  , secondDF-  , parDF-  , parNDF-  , loopDF-  , loopDF_nobuf-    -- * Lock-Step operation-  , LockStep (..)-  )-where--import GHC.TypeLits           (KnownNat, type (+), type (^))-import Prelude-  hiding ((++), (!!), length, map, repeat, tail, unzip3, zip3, zipWith)--import Clash.Class.BitPack    (boolToBV)-import Clash.Class.Resize     (truncateB)-import Clash.Class.BitPack.BitIndex (msb)-import Clash.Explicit.Mealy   (mealyB)-import Clash.Promoted.Nat     (SNat)-import Clash.Signal           (KnownDomain, (.&&.))-import Clash.Signal.Bundle    (Bundle (..))-import Clash.Explicit.Signal  (Clock, Reset, Signal, Enable, andEnable, register)-import Clash.Sized.BitVector  (BitVector)-import Clash.Sized.Vector-import Clash.XException       (errorX, NFDataX)--{- | Dataflow circuit with bidirectional synchronization channels.--In the /forward/ direction we assert /validity/ of the data. In the /backward/-direction we assert that the circuit is /ready/ to receive new data. A circuit-adhering to the 'DataFlow' type should:-- * Not consume data when validity is deasserted.- * Only update its output when readiness is asserted.--The 'DataFlow' type is defined as:--@-newtype DataFlow' dom iEn oEn i o-  = DF-  { df :: 'Signal' dom i     -- Incoming data-       -> 'Signal' dom iEn   -- Flagged with \/valid\/ bits \@iEn\@.-       -> 'Signal' dom oEn   -- Incoming back-pressure, \/ready\/ edge.-       -> ( 'Signal' dom o   -- Outgoing data.-          , 'Signal' dom oEn -- Flagged with \/valid\/ bits \@oEn\@.-          , 'Signal' dom iEn -- Outgoing back-pressure, \/ready\/ edge.-          )-  }-@--where:-- * @dom@ is the domain to which the circuit is synchronized.- * @iEn@ is the type of the bidirectional incoming synchronization channel.- * @oEn@ is the type of the bidirectional outgoing synchronization channel.- * @i@ is the incoming data type.- * @o@ is the outgoing data type.--We define several composition operators for our 'DataFlow' circuits:-- * 'seqDF' sequential composition.- * 'parDF' parallel composition.- * 'loopDF' add a feedback arc.- * 'lockStep' proceed in lock-step.--When you look at the types of the above operators it becomes clear why we-parametrize in the types of the synchronization channels.--}-newtype DataFlow dom iEn oEn i o-  = DF-  { -- | Create an ordinary circuit from a 'DataFlow' circuit-    df :: Signal dom i     -- Incoming data-       -> Signal dom iEn   -- Flagged with /valid/ bits @iEn@.-       -> Signal dom oEn   -- Incoming back-pressure, /ready/ edge.-       -> ( Signal dom o   -- Outgoing data.-          , Signal dom oEn -- Flagged with /valid/ bits @oEn@.-          , Signal dom iEn -- Outgoing back-pressure, /ready/ edge.-          )-  }---- | Dataflow circuit synchronized to the 'Clash.Signal.systemClockGen'.--- type DataFlow iEn oEn i o = DataFlow' systemClockGen iEn oEn i o---- | Create a 'DataFlow' circuit from a circuit description with the appropriate--- type:------ @--- 'Signal' dom i        -- Incoming data.--- -> 'Signal' dom Bool  -- Flagged with a single \/valid\/ bit.--- -> 'Signal' dom Bool  -- Incoming back-pressure, \/ready\/ bit.--- -> ( 'Signal' dom o   -- Outgoing data.---    , 'Signal' dom oEn -- Flagged with a single \/valid\/ bit.---    , 'Signal' dom iEn -- Outgoing back-pressure, \/ready\/ bit.---    )--- @------ A circuit adhering to the 'DataFlow' type should:------  * Not consume data when validity is deasserted.---  * Only update its output when readiness is asserted.-liftDF-  :: ( Signal dom i-    -> Signal dom Bool-    -> Signal dom Bool-    -> (Signal dom o, Signal dom Bool, Signal dom Bool))-  -> DataFlow dom Bool Bool i o-liftDF = DF---- | Create a 'DataFlow' circuit where the given function @f@ operates on the--- data, and the synchronization channels are passed unaltered.-pureDF-  :: (i -> o)-  -> DataFlow dom Bool Bool i o-pureDF f = DF (\i iV oR -> (fmap f i,iV,oR))---- | Create a 'DataFlow' circuit from a Mealy machine description as those of--- "Clash.Prelude.Mealy"-mealyDF-  :: ( KnownDomain dom-     , NFDataX s )-  => Clock dom-  -> Reset dom-  -> Enable dom-  -> (s -> i -> (s,o))-  -> s-  -> DataFlow dom Bool Bool i o-mealyDF clk rst gen f iS =-  DF (\i iV oR -> let en     = iV .&&. oR-                      (s',o) = unbundle (f <$> s <*> i)-                      s      = register clk rst (andEnable gen en) iS s'-                  in  (o,iV,oR))---- | Create a 'DataFlow' circuit from a Moore machine description as those of--- "Clash.Prelude.Moore"-mooreDF-  :: ( KnownDomain dom-     , NFDataX s )-  => Clock dom-  -> Reset dom-  -> Enable dom-  -> (s -> i -> s)-  -> (s -> o)-  -> s-  -> DataFlow dom Bool Bool i o-mooreDF clk rst gen ft fo iS =-  DF (\i iV oR -> let en  = iV .&&. oR-                      s'  = ft <$> s <*> i-                      s   = register clk rst (andEnable gen en) iS s'-                      o   = fo <$> s-                  in  (o,iV,oR))--fifoDF_mealy-  :: forall addrSize a-   . KnownNat addrSize-  => (Vec (2^addrSize) a, BitVector (addrSize + 1), BitVector (addrSize + 1))-  -> (a, Bool, Bool)-  -> ((Vec (2^addrSize) a, BitVector (addrSize + 1), BitVector (addrSize + 1))-     ,(a, Bool, Bool))-fifoDF_mealy (mem,rptr,wptr) (wdata,winc,rinc) =-  let raddr = truncateB rptr :: BitVector addrSize-      waddr = truncateB wptr :: BitVector addrSize--      mem' | winc && not full = replace waddr wdata mem-           | otherwise        = mem--      rdata = mem !! raddr--      rptr' = rptr + boolToBV (rinc && not empty)-      wptr' = wptr + boolToBV (winc && not full)-      empty = rptr == wptr-      full  = msb rptr /= msb wptr && raddr == waddr-  in  ((mem',rptr',wptr'), (rdata,empty,full))---- | Create a FIFO buffer adhering to the 'DataFlow' protocol. Can be filled--- with initial content.------ To create a FIFO of size 4, with two initial values 2 and 3 you would write:------ @--- fifo4 = 'fifoDF' d4 (2 :> 3 :> Nil)--- @-fifoDF-  :: forall addrSize m n a dom-   . ( KnownDomain dom-     , NFDataX a-     , KnownNat addrSize-     , KnownNat n-     , KnownNat m-     , (m + n) ~ (2 ^ addrSize) )-  => Clock dom-  -> Reset dom-  -> Enable dom-  -> SNat (m + n) -- ^ Depth of the FIFO buffer. Must be a power of two.-  -> Vec m a      -- ^ Initial content. Can be smaller than the size of the-                  -- FIFO. Empty spaces are initialized with 'undefined'.-  -> DataFlow dom Bool Bool a a-fifoDF clk rst en _ iS = DF $ \i iV oR ->-  let initRdPtr      = 0-      initWrPtr      = fromIntegral (length iS)-      initMem        = iS ++ repeat  (errorX "fifoDF: undefined") :: Vec (m + n) a-      initS          = (initMem,initRdPtr,initWrPtr)-      (o,empty,full) = mealyB clk rst en fifoDF_mealy initS (i,iV,oR)-  in  (o,not <$> empty, not <$> full)---- | Identity circuit------ <<doc/idDF.svg>>-idDF :: DataFlow dom en en a a-idDF = DF (\a val rdy -> (a,val,rdy))---- | Sequential composition of two 'DataFlow' circuits.------ <<doc/seqDF.svg>>-seqDF-  :: DataFlow dom aEn bEn a b-  -> DataFlow dom bEn cEn b c-  -> DataFlow dom aEn cEn a c-(DF f) `seqDF` (DF g) = DF (\a aVal cRdy -> let (b,bVal,aRdy) = f a aVal bRdy-                                                (c,cVal,bRdy) = g b bVal cRdy-                                            in  (c,cVal,aRdy))---- | Apply the circuit to the first halve of the communication channels, leave--- the second halve unchanged.------ <<doc/firstDF.svg>>-firstDF-  :: DataFlow dom aEn bEn a b-  -> DataFlow dom (aEn, cEn) (bEn, cEn) (a, c) (b, c)-firstDF (DF f) = DF (\ac acV bcR -> let (a,c)     = unbundle ac-                                        (aV,cV)   = unbundle acV-                                        (bR,cR)   = unbundle bcR-                                        (b,bV,aR) = f a aV bR-                                        bc        = bundle (b,c)-                                        bcV       = bundle (bV,cV)-                                        acR       = bundle (aR,cR)-                                    in  (bc,bcV,acR)-                    )---- | Swap the two communication channels.------ <<doc/swapDF.svg>>-swapDF :: DataFlow dom (aEn, bEn) (bEn, aEn) (a, b) (b, a)-swapDF = DF (\ab abV baR -> (swap <$> ab, swap <$> abV, swap <$> baR))-  where-    swap ~(a,b) = (b,a)---- | Apply the circuit to the second halve of the communication channels, leave--- the first halve unchanged.------ <<doc/secondDF.svg>>-secondDF-  :: DataFlow dom aEn bEn a b-  -> DataFlow dom (cEn, aEn) (cEn, bEn) (c, a) (c, b)-secondDF f = swapDF `seqDF` firstDF f `seqDF` swapDF---- | Compose two 'DataFlow' circuits in parallel.------ <<doc/parDF.svg>>-parDF-  :: DataFlow dom aEn bEn a b-  -> DataFlow dom cEn dEn c d-  -> DataFlow dom (aEn, cEn) (bEn, dEn) (a, c) (b, d)-f `parDF` g = firstDF f `seqDF` secondDF g---- | Compose /n/ 'DataFlow' circuits in parallel.-parNDF-  :: KnownNat n-  => Vec n (DataFlow dom aEn bEn a b)-  -> DataFlow dom (Vec n aEn) (Vec n bEn) (Vec n a) (Vec n b)-parNDF fs =-  DF (\as aVs bRs ->-        let as'  = unbundle as-            aVs' = unbundle aVs-            bRs' = unbundle bRs-            (bs,bVs,aRs) = unzip3 (zipWith (\k (a,b,r) -> df k a b r) fs-                                  (zip3 (lazyV as') (lazyV aVs') bRs'))-        in  (bundle bs,bundle bVs, bundle aRs)-     )---- | Feed back the second halve of the communication channel. The feedback loop--- is buffered by a 'fifoDF' circuit.------ So given a circuit /h/ with two synchronization channels:------ @--- __h__ :: 'DataFlow' (Bool,Bool) (Bool,Bool) (a,d) (b,d)--- @------ Feeding back the /d/ part (including its synchronization channels) results--- in:------ @--- 'loopDF' d4 Nil h--- @------ <<doc/loopDF.svg>>------ When you have a circuit @h'@, with only a single synchronization channel:------ @--- __h'__ :: 'DataFlow' Bool Bool (a,d) (b,d)--- @------ and you want to compose /h'/ in a feedback loop, the following will not work:------ @--- f \`@'seqDF'@\` ('loopDF' d4 Nil h') \`@'seqDF'@\` g--- @------ The circuits @f@, @h@, and @g@, must operate in /lock-step/ because the /h'/--- circuit only has a single synchronization channel. Consequently, there--- should only be progress when all three circuits are producing /valid/ data--- and all three circuits are /ready/ to receive new data. We need to compose--- /h'/ with the 'lockStep' and 'stepLock' functions to achieve the /lock-step/--- operation.------ @--- f \`@'seqDF'@\` ('lockStep' \`@'seqDF'@\` 'loopDF' d4 Nil h' \`@'seqDF'@\` 'stepLock') \`@'seqDF'@\` g--- @------ <<doc/loopDF_sync.svg>>-loopDF-  :: ( KnownDomain dom-     , NFDataX d-     , KnownNat m-     , KnownNat n-     , KnownNat addrSize-     , (m+n) ~ (2^addrSize) )-  => Clock dom-  -> Reset dom-  -> Enable dom-  -> SNat (m + n)-  -- ^ Depth of the FIFO buffer. Must be a power of two-  -> Vec m d-  -- ^ Initial content of the FIFO buffer. Can be smaller than the size of the-  -- FIFO. Empty spaces are initialized with 'undefined'.-  -> DataFlow dom (Bool,Bool) (Bool,Bool) (a,d) (b,d)-  -> DataFlow dom Bool Bool   a           b-loopDF clk rst en sz is (DF f) =-  DF (\a aV bR -> let (bd,bdV,adR) = f ad adV bdR-                      (b,d)        = unbundle bd-                      (bV,dV)      = unbundle bdV-                      (aR,dR)      = unbundle adR-                      (d_buf,dV_buf,dR_buf) = df (fifoDF clk rst en sz is) d dV dR--                      ad  = bundle (a,d_buf)-                      adV = bundle (aV,dV_buf)-                      bdR = bundle (bR,dR_buf)-                  in  (b,bV,aR)-     )---- | Feed back the second halve of the communication channel. Unlike 'loopDF',--- the feedback loop is /not/ buffered.-loopDF_nobuf :: DataFlow dom (Bool,Bool) (Bool,Bool) (a,d) (b,d)-             -> DataFlow dom Bool Bool   a           b-loopDF_nobuf (DF f) = DF (\a aV bR -> let (bd,bdV,adR) = f ad adV bdR-                                          (b,d)        = unbundle bd-                                          (bV,dV)      = unbundle bdV-                                          (aR,dR)      = unbundle adR-                                          ad           = bundle (a,d)-                                          adV          = bundle (aV,dV)-                                          bdR          = bundle (bR,dR)-                                      in  (b,bV,aR)-                         )---- | Reduce or extend the synchronization granularity of parallel compositions.-class LockStep a b where-  -- | Reduce the synchronization granularity to a single 'Bool'ean value.-  ---  -- Given:-  ---  -- @-  -- __f__ :: 'DataFlow' Bool Bool a b-  -- __g__ :: 'DataFlow' Bool Bool c d-  -- __h__ :: 'DataFlow' Bool Bool (b,d) (p,q)-  -- @-  ---  -- We /cannot/ simply write:-  ---  -- @-  -- (f \`@'parDF'@\` g) \`@'seqDF'@\` h-  -- @-  ---  -- because, @f \`parDF\` g@, has type, @'DataFlow' (Bool,Bool) (Bool,Bool) (a,c) (b,d)@,-  -- which does not match the expected synchronization granularity of @h@. We-  -- need a circuit in between that has the type:-  ---  -- @-  -- 'DataFlow' (Bool,Bool) Bool (b,d) (b,d)-  -- @-  ---  -- Simply '&&'-ing the /valid/ signals in the forward direction, and-  -- duplicating the /ready/ signal in the backward direction is however not-  -- enough. We also need to make sure that @f@ does not update its output when-  -- @g@'s output is invalid and visa versa, as @h@ can only consume its input-  -- when both @f@ and @g@ are producing valid data. @g@'s /ready/ port is hence-  -- only asserted when @h@ is ready and @f@ is producing /valid/ data. And @f@'s-  -- ready port is only asserted when @h@ is ready and @g@ is producing valid-  -- data. @f@ and @g@ will hence be proceeding in /lock-step/.-  ---  -- The 'lockStep' function ensures that all synchronization signals are-  -- properly connected:-  ---  -- @-  -- (f \`@'parDF'@\` g) \`@'seqDF'@\` 'lockStep' \`@'seqDF'@\` h-  -- @-  ---  -- <<doc/lockStep.svg>>-  ---  -- __Note 1__: ensure that the components that you are synchronizing have-  -- buffered/delayed @ready@ and @valid@ signals, or 'lockStep' has the-  -- potential to introduce combinational loops. You can do this by placing-  -- 'fifoDF's on the parallel channels. Extending the above example, you would-  -- write:-  ---  -- @-  -- ((f \`@'seqDF'@\` 'fifoDF' d4 Nil) \`@'parDF'@\` (g \`@'seqDF'@\` 'fifoDF' d4 Nil)) \`@'seqDF'@\` 'lockStep' \`@'seqDF'@\` h-  -- @-  ---  -- __Note 2__: 'lockStep' works for arbitrarily nested tuples. That is:-  ---  -- @-  -- p :: 'DataFlow' Bool Bool ((b,d),d) z-  ---  -- q :: 'DataFlow' ((Bool,Bool),Bool) ((Bool,Bool),Bool) ((a,c),c) ((b,d),d)-  -- q = f \`@'parDF'@\` g \`@'parDF'@\` g-  ---  -- r = q \`@'seqDF'@\` 'lockStep' \`@'seqDF'@\` p-  -- @-  ---  -- Does the right thing.-  lockStep :: DataFlow dom a Bool b b--  -- | Extend the synchronization granularity from a single 'Bool'ean value.-  ---  -- Given:-  ---  -- @-  -- __f__ :: 'DataFlow' Bool Bool a b-  -- __g__ :: 'DataFlow' Bool Bool c d-  -- __h__ :: 'DataFlow' Bool Bool (p,q) (a,c)-  -- @-  ---  -- We /cannot/ simply write:-  ---  -- @-  -- h \`@'seqDF'@\` (f \`@'parDF'@\` g)-  -- @-  ---  -- because, @f \`parDF\` g@, has type, @'DataFlow' (Bool,Bool) (Bool,Bool) (a,c) (b,d)@,-  -- which does not match the expected synchronization granularity of @h@. We-  -- need a circuit in between that has the type:-  ---  -- @-  -- 'DataFlow' Bool (Bool,Bool) (a,c) (a,c)-  -- @-  ---  -- Simply '&&'-ing the /ready/ signals in the backward direction, and-  -- duplicating the /valid/ signal in the forward direction is however not-  -- enough. We need to make sure that @f@ does not consume values when @g@ is-  -- not /ready/ and visa versa, because @h@ cannot update the values of its-  -- output tuple independently. @f@'s /valid/ port is hence only asserted when-  -- @h@ is valid and @g@ is ready to receive new values. @g@'s /valid/ port is-  -- only asserted when @h@ is valid and @f@ is ready to receive new values.-  -- @f@ and @g@ will hence be proceeding in /lock-step/.-  ---  -- The 'stepLock' function ensures that all synchronization signals are-  -- properly connected:-  ---  -- @-  -- h \`@'seqDF'@\` 'stepLock' \`@'seqDF'@\` (f \`@'parDF'@\` g)-  -- @-  ---  -- <<doc/stepLock.svg>>-  ---  -- __Note 1__: ensure that the components that you are synchronizing have-  -- buffered/delayed @ready@ and @valid@ signals, or 'stepLock' has the-  -- potential to introduce combinational loops. You can do this by placing-  -- 'fifoDF's on the parallel channels. Extending the above example, you would-  -- write:-  ---  -- @-  -- h \`@'seqDF'@\` 'stepLock' \`@'seqDF'@\` ((`fifoDF` d4 Nil \`@'seqDF'@\` f) \`@'parDF'@\` (`fifoDF` d4 Nil \`@'seqDF'@\` g))-  -- @-  ---  -- __Note 2__: 'stepLock' works for arbitrarily nested tuples. That is:-  ---  -- @-  -- p :: 'DataFlow' Bool Bool z ((a,c),c)-  ---  -- q :: 'DataFlow' ((Bool,Bool),Bool) ((Bool,Bool),Bool) ((a,c),c) ((b,d),d)-  -- q = f \`@'parDF'@\` g \`@'parDF'@\` g-  ---  -- r = p \`@'seqDF'@\` 'stepLock' \`@'seqDF'@\` q-  -- @-  ---  -- Does the right thing.-  stepLock :: DataFlow dom Bool a b b--instance LockStep Bool c where-  lockStep = idDF-  stepLock = idDF--instance (LockStep a x, LockStep b y) => LockStep (a,b) (x,y) where-  lockStep = (lockStep `parDF` lockStep) `seqDF`-                (DF (\xy xyV rdy -> let (xV,yV)   = unbundle xyV-                                        val       = xV .&&. yV-                                        xR        = yV .&&. rdy-                                        yR        = xV .&&. rdy-                                        xyR       = bundle (xR,yR)-                                    in  (xy,val,xyR)))--  stepLock = (DF (\xy val xyR -> let (xR,yR) = unbundle xyR-                                     rdy     = xR  .&&. yR-                                     xV      = val .&&. yR-                                     yV      = val .&&. xR-                                     xyV     = bundle (xV,yV)-                                 in  (xy,xyV,rdy))) `seqDF` (stepLock `parDF` stepLock)--instance (LockStep en a, KnownNat n) => LockStep (Vec n en) (Vec n a) where-  lockStep = parNDF (repeat lockStep) `seqDF`-    DF (\xs vals rdy ->-          let val  = (and . (True :>)) <$> vals-              rdys = allReady <$> rdy <*> (repeat . (:< True) <$> vals)-          in  (xs,val,rdys)-       )-  stepLock =-    DF (\xs val rdys ->-          let rdy  = (and . (True :>)) <$> rdys-              vals = allReady <$> val <*> (repeat . (:< True) <$> rdys)-          in  (xs,vals,rdy)-       ) `seqDF` parNDF (repeat stepLock)--allReady :: KnownNat n-         => Bool-         -> Vec n (Vec (n+1) Bool)-         -> Vec n Bool-allReady b vs = map (and . (b :>) . tail) (smap (flip rotateLeftS) vs)

@@ -122,8 +122,7 @@         withFrozenCallStack           (deepErrorX ("asyncRom: address " ++ show i ++                        " not in range [0.." ++ show szI ++ ")"))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE asyncRom# #-}+{-# OPAQUE asyncRom# #-} {-# ANN asyncRom# hasBlackBox #-}  -- | A ROM with a synchronous read port, with space for @n@ elements

@@ -119,8 +119,7 @@           (deepErrorX ("asyncRom: address " ++ show i ++                        " not in range [0.." ++ show szI ++ ")")) {-# ANN asyncRomBlob# hasBlackBox #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE asyncRomBlob# #-}+{-# OPAQUE asyncRomBlob# #-}  -- | A ROM with a synchronous read port, with space for @n@ elements --

@@ -252,8 +252,7 @@     mem     = unsafePerformIO (initMem file)     content = listArray (0,szI-1) mem     szI     = snatToNum sz--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE asyncRomFile# #-}+{-# OPAQUE asyncRomFile# #-} {-# ANN asyncRomFile# hasBlackBox #-}  -- | A ROM with a synchronous read port, with space for @n@ elements

@@ -26,8 +26,9 @@     explicitly clocked circuits in a multi-clock setting    For now, "Clash.Prelude" is also the best starting point for exploring the-  library. A preliminary version of a tutorial can be found in "Clash.Tutorial".-  Some circuit examples can be found in "Clash.Examples".+  library. A preliminary version of a tutorial can be found at+  https://docs.clash-lang.org/tutorial. Some circuit examples can be found in+  "Clash.Examples". -}  {-# LANGUAGE CPP #-}@@ -138,9 +139,7 @@ import           GHC.Generics (Generic, Generic1)  import           GHC.TypeLits-#if MIN_VERSION_base(4,18,0)   hiding (SNat, SSymbol, fromSNat)-#endif import           GHC.TypeLits.Extra import           Clash.HaskellPrelude 

@@ -1,88 +0,0 @@-{-|-Copyright   :  (C) 2019, Myrtle Software Ltd,-License     :  BSD2 (see the file LICENSE)-Maintainer  :  Christiaan Baaij <christiaan.baaij@gmail.com>--Synchronizer circuits for safe clock domain crossings--}--{-# LANGUAGE TypeFamilies #-}--module Clash.Prelude.Synchronizer-  ( -- * Bit-synchronizers-    dualFlipFlopSynchronizer-    -- * Word-synchronizers-  , asyncFIFOSynchronizer-  ) where--import qualified Clash.Explicit.Synchronizer as E-import           Clash.Promoted.Nat          (SNat)-import           Clash.Signal-  (HiddenClockResetEnable, HiddenClock, Signal, hasClock, hasReset, hasEnable)-import           Clash.XException            (NFDataX)-import           GHC.TypeLits                (type (<=))---- | Synchronizer based on two sequentially connected flip-flops.------  * __NB__: This synchronizer can be used for __bit__-synchronization.------  * __NB__: Although this synchronizer does reduce metastability, it does---  not guarantee the proper synchronization of a whole __word__. For---  example, given that the output is sampled twice as fast as the input is---  running, and we have two samples in the input stream that look like:------      @[0111,1000]@------      But the circuit driving the input stream has a longer propagation delay---      on __msb__ compared to the __lsb__s. What can happen is an output stream---      that looks like this:------      @[0111,0111,0000,1000]@------      Where the level-change of the __msb__ was not captured, but the level---      change of the __lsb__s were.------      If you want to have /safe/ __word__-synchronization use---      'asyncFIFOSynchronizer'.-dualFlipFlopSynchronizer-  :: ( NFDataX a-     , HiddenClock dom1-     , HiddenClockResetEnable dom2-     )-  => a-  -- ^ Initial value of the two synchronization registers-  -> Signal dom1 a-  -- ^ Incoming data-  -> Signal dom2 a-  -- ^ Outgoing, synchronized, data-dualFlipFlopSynchronizer =-  E.dualFlipFlopSynchronizer hasClock hasClock hasReset hasEnable---- | Synchronizer implemented as a FIFO around an asynchronous RAM. Based on the--- design described in "Clash.Tutorial#multiclock", which is itself based on the--- design described in <http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf>.------ __NB__: This synchronizer can be used for __word__-synchronization.-asyncFIFOSynchronizer-  :: ( HiddenClockResetEnable rdom-     , HiddenClockResetEnable wdom-     , 2 <= addrSize-     , NFDataX a )-  => SNat addrSize-  -- ^ Size of the internally used addresses, the  FIFO contains @2^addrSize@-  -- elements.-  -> Signal rdom Bool-  -- ^ Read request-  -> Signal wdom (Maybe a)-  -- ^ Element to insert-  -> (Signal rdom a, Signal rdom Bool, Signal wdom Bool)-  -- ^ (Oldest element in the FIFO, @empty@ flag, @full@ flag)-asyncFIFOSynchronizer addrSize =-  E.asyncFIFOSynchronizer-    addrSize-    hasClock  -- wdom-    hasClock  -- rdom-    hasReset  -- wdom-    hasReset  -- rdom-    hasEnable  -- wdom-    hasEnable  -- rdom

@@ -1,7 +1,7 @@ {-| Copyright  :  (C) 2013-2016, University of Twente,                   2016     , Myrtle Software Ltd-                  2022     , QBayLogic B.V.+                  2022-2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> -}@@ -70,19 +70,22 @@   ) where +import Data.Constraint    (Dict(..), (:-)(Sub))+import Data.Constraint.Nat (euclideanNat) import Data.Kind          (Type)+import Data.Type.Equality ((:~:)(..))+import Data.Type.Ord      (OrderingI(..)) import GHC.Show           (appPrec) import GHC.TypeLits       (KnownNat, Nat, type (+), type (-), type (*),-                           type (^), type (<=), natVal)+                           type (^), type (<=),+                           cmpNat, sameNat,+                           natVal) import GHC.TypeLits.Extra (CLog, FLog, Div, Log, Mod, Min, Max) import GHC.Natural        (naturalFromInteger) import Language.Haskell.TH (appT, conT, litT, numTyLit, sigE) import Language.Haskell.TH.Syntax (Lift (..))-#if MIN_VERSION_template_haskell(2,16,0) import Language.Haskell.TH.Compat-#endif import Numeric.Natural    (Natural)-import Unsafe.Coerce      (unsafeCoerce)  import Clash.Annotations.Primitive (hasBlackBox) import Clash.XException   (ShowX (..), showsPrecXWith)@@ -103,9 +106,7 @@ instance Lift (SNat n) where   lift s = sigE [| SNat |]                 (appT (conT ''SNat) (litT $ numTyLit (snatToInteger s)))-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif  -- | Create an @`SNat` n@ from a proxy for /n/ snatProxy :: KnownNat n => proxy n -> SNat n@@ -184,11 +185,12 @@ -- -- __NB__: Not synthesizable toUNat :: forall n . SNat n -> UNat n-toUNat p@SNat = fromI @n (snatToInteger p)-  where-    fromI :: forall m . Integer -> UNat m-    fromI 0 = unsafeCoerce @(UNat 0) @(UNat m) UZero-    fromI n = unsafeCoerce @(UNat ((m-1)+1)) @(UNat m) (USucc (fromI @(m-1) (n - 1)))+toUNat p@SNat = case cmpNat (SNat @1) p of+  LTI -> USucc (toUNat @(n - 1) (predSNat p))+  EQI -> USucc UZero+  GTI -> case sameNat p (SNat @0) of+    Just Refl -> UZero+    _ -> error "toUNat: impossible: 1 > n and n /= 0 for (n :: Nat)"  -- | Convert a unary-encoded natural number to its singleton representation --@@ -225,7 +227,7 @@ -- __NB__: Not synthesizable predUNat :: UNat (n+1) -> UNat n predUNat (USucc x) = x-#if __GLASGOW_HASKELL__ != 902+#if __GLASGOW_HASKELL__ < 912 predUNat UZero     =   error "predUNat: impossible: 0 minus 1, -1 is not a natural number" #endif@@ -236,7 +238,9 @@ subUNat :: UNat (m+n) -> UNat n -> UNat m subUNat x         UZero     = x subUNat (USucc x) (USucc y) = subUNat x y+#if __GLASGOW_HASKELL__ < 912 subUNat UZero     _         = error "subUNat: impossible: 0 + (n + 1) ~ 0"+#endif  -- | Predecessor of a singleton natural number predSNat :: SNat (a+1) -> SNat (a)@@ -269,8 +273,7 @@ -- | Power of two singleton natural numbers powSNat :: SNat a -> SNat b -> SNat (a^b) powSNat SNat SNat = SNat--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE powSNat #-}+{-# OPAQUE powSNat #-} {-# ANN powSNat hasBlackBox #-} infixr 8 `powSNat` @@ -298,8 +301,7 @@              -> SNat x              -> SNat (FLog base x) flogBaseSNat SNat SNat = SNat--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE flogBaseSNat #-}+{-# OPAQUE flogBaseSNat #-} {-# ANN flogBaseSNat hasBlackBox #-}  -- | Ceiling of the logarithm of a natural number@@ -308,8 +310,7 @@              -> SNat x              -> SNat (CLog base x) clogBaseSNat SNat SNat = SNat--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE clogBaseSNat #-}+{-# OPAQUE clogBaseSNat #-} {-# ANN clogBaseSNat hasBlackBox #-}  -- | Exact integer logarithm of a natural number@@ -320,8 +321,7 @@             -> SNat x             -> SNat (Log base x) logBaseSNat SNat SNat = SNat--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE logBaseSNat #-}+{-# OPAQUE logBaseSNat #-} {-# ANN logBaseSNat hasBlackBox #-}  -- | Power of two of a singleton natural number@@ -338,10 +338,13 @@  -- | Get an ordering relation between two SNats compareSNat :: forall a b . SNat a -> SNat b -> SNatLE a b-compareSNat a b =-  if snatToInteger a <= snatToInteger b-     then unsafeCoerce (SNatLE @0 @0)-     else unsafeCoerce (SNatGT @1 @0)+compareSNat a@SNat b@SNat = case cmpNat a b of+  LTI -> SNatLE+  EQI -> SNatLE+  GTI -> case cmpNat (succSNat b) a of+    LTI -> SNatGT+    EQI -> SNatGT+    GTI -> error "compareSNat: impossible: a > b and b + 1 > a"  -- | Base-2 encoded natural number --@@ -404,14 +407,18 @@ -- | Convert a singleton natural number to its base-2 representation -- -- __NB__: Not synthesizable-toBNat :: SNat n -> BNat n-toBNat s@SNat = toBNat' (snatToInteger s)-  where-    toBNat' :: forall m . Integer -> BNat m-    toBNat' 0 = unsafeCoerce BT-    toBNat' n = case n `divMod` 2 of-      (n',1) -> unsafeCoerce (B1 (toBNat' @(Div (m-1) 2) n'))-      (n',_) -> unsafeCoerce (B0 (toBNat' @(Div m 2) n'))+toBNat :: forall n. SNat n -> BNat n+toBNat s@SNat = case cmpNat (SNat @1) s of+  LTI -> case euclideanNat @2 @n of+    Sub Dict -> case sameNat (SNat @(n `Mod` 2)) (SNat @0) of+      Just Refl -> B0 (toBNat (SNat @(n `Div` 2)))+      Nothing -> case sameNat (SNat @(n `Mod` 2)) (SNat @1) of+        Just Refl -> B1 (toBNat (SNat @(n `Div` 2)))+        Nothing -> error "toBNat: impossible: n mod 2 is either 0 or 1"+  EQI -> B1 BT+  GTI -> case sameNat s (SNat @0) of+    Just Refl -> BT+    _ -> error "toBNat: impossible: 1 > n and n /= 0 for (n :: Nat)"  -- | Convert a base-2 encoded natural number to its singleton representation --@@ -488,7 +495,7 @@ -- -- __NB__: Not synthesizable log2BNat :: BNat (2^n) -> BNat n-#if __GLASGOW_HASKELL__ != 902+#if __GLASGOW_HASKELL__ < 912 log2BNat BT = error "log2BNat: log2(0) not defined" #endif log2BNat (B1 x) = case stripZeros x of

@@ -21,6 +21,5 @@ -- | I hope you know what you're doing unsafeSNat :: Integer -> SNat k unsafeSNat i = reifyNat i $ (\p -> unsafeCoerce (snatProxy p))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeSNat #-}+{-# OPAQUE unsafeSNat #-} {-# ANN unsafeSNat hasBlackBox #-}

@@ -36,11 +36,7 @@     where       tt = LitT (StrTyLit (ssymbolToString t)) -#if MIN_VERSION_template_haskell(2,17,0)   liftTyped = unsafeCodeCoerce . lift-#elif MIN_VERSION_template_haskell(2,16,0)-  liftTyped = unsafeTExpCoerce . lift-#endif  instance Show (SSymbol s) where   showsPrec d s@SSymbol = showParen (d > appPrec) $

@@ -107,12 +107,23 @@   , DomainInitBehavior   , DomainResetPolarity     -- *** Convenience types-    -- **** Simplifying     -- $conveniencetypes    , HasSynchronousReset   , HasAsynchronousReset   , HasDefinedInitialValues+  -- **** Time representations+  , Seconds+  , Milliseconds+  , Microseconds+  , Nanoseconds+  , Picoseconds+  -- **** Time conversions+  , DomainToHz+  , HzToPeriod+  , PeriodToHz+  , PeriodToCycles+  , ClockDivider     -- ** Default domains   , System   , XilinxSystem@@ -135,10 +146,6 @@   , DiffClock   , periodToHz   , hzToPeriod-#ifdef CLASH_MULTIPLE_HIDDEN-    -- ** Synchronization primitive-  , unsafeSynchronizer-#endif     -- * Reset   , Reset   , unsafeToReset@@ -147,9 +154,6 @@   , unsafeToActiveLow   , unsafeFromActiveHigh   , unsafeFromActiveLow-#ifdef CLASH_MULTIPLE_HIDDEN-  , convertReset-#endif   , resetSynchronizer   , resetGlitchFilter   , registerSyncReset@@ -170,46 +174,27 @@   , hideClock   , exposeClock   , withClock-#ifdef CLASH_MULTIPLE_HIDDEN-  , exposeSpecificClock-  , withSpecificClock-#endif   , hasClock     -- ** Hidden reset   , HiddenReset   , hideReset   , exposeReset   , withReset-#ifdef CLASH_MULTIPLE_HIDDEN-  , exposeSpecificReset-  , withSpecificReset-#endif   , hasReset     -- ** Hidden enable   , HiddenEnable   , hideEnable   , exposeEnable   , withEnable-#ifdef CLASH_MULTIPLE_HIDDEN-  , exposeSpecificEnable-  , withSpecificEnable-#endif   , hasEnable     -- ** Hidden clock, reset, and enable   , HiddenClockResetEnable   , hideClockResetEnable   , exposeClockResetEnable   , withClockResetEnable-#ifdef CLASH_MULTIPLE_HIDDEN-  , exposeSpecificClockResetEnable-  , withSpecificClockResetEnable-#endif   , SystemClockResetEnable     -- * Basic circuit functions   , andEnable-#ifdef CLASH_MULTIPLE_HIDDEN-  , andSpecificEnable-#endif   , dflipflop   , delay   , delayMaybe@@ -217,7 +202,9 @@   , register   , regMaybe   , regEn+  , regEnN   , mux+  , apEn     -- * Simulation and testbench functions   , clockGen   , resetGen@@ -225,7 +212,7 @@   , systemClockGen   , systemResetGen     -- * Boolean connectives-  , (.&&.), (.||.)+  ,(.&&.), (&&.), (.&&), (.||.), (||.), (.||)     -- * Product/Signal isomorphism   , Bundle(..)   , EmptyTuple(..)@@ -257,9 +244,9 @@   , testFor     -- * Type classes     -- ** 'Eq'-like-  , (.==.), (./=.)+  , (.==.), (.==), (==.), (./=.), (./=), (/=.)     -- ** 'Ord'-like-  , (.<.), (.<=.), (.>=.), (.>.)+  , (.<.), (.<), (<.), (.<=.), (.<=), (<=.), (.>=.), (.>=), (>=.), (.>.), (.>), (>.)     -- * Bisignal functions   , veryUnsafeToBiSignalIn   , readFromBiSignal@@ -286,13 +273,6 @@ import           Prelude import           Test.QuickCheck       (Property, property) --#ifdef CLASH_MULTIPLE_HIDDEN-import           GHC.TypeLits          (AppendSymbol)-import           Clash.Class.HasDomain (WithSingleDomain)-#endif--import           Clash.Class.HasDomain (WithSpecificDomain) import qualified Clash.Explicit.Signal as E import qualified Clash.Explicit.Reset  as E import           Clash.Explicit.Reset  (resetSynchronizer, resetGlitchFilter)@@ -335,6 +315,8 @@  {- $conveniencetypes +==== Simplifying+ If you want to write part of your Clash design as domain-polymorphic functions, it can be practical to define a design-wide constraint synonym that captures the characteristics of the clock domains of the design. Such a constraint synonym@@ -587,15 +569,9 @@ to 'andEnable' as an argument would have avoided this hard to debug problem. -} -#ifdef CLASH_MULTIPLE_HIDDEN-type HiddenClockName dom = AppendSymbol dom "_clk"-type HiddenResetName dom = AppendSymbol dom "_rst"-type HiddenEnableName dom = AppendSymbol dom "_en"-#else type HiddenClockName (dom :: Domain) = "clock" type HiddenResetName (dom :: Domain) = "reset" type HiddenEnableName (dom :: Domain) = "enable"-#endif  -- | A /constraint/ that indicates the component has a hidden 'Clock' --@@ -642,24 +618,6 @@ {- | Expose a hidden 'Clock' argument of a component, so it can be applied explicitly. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single-domain. For example, this function will refuse when:--@-r ~ HiddenClock dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenClock dom => Signal dom a -> Signal dom a-@--If you want to expose a clock of a component working on multiple domains-(such as the first example), use 'exposeSpecificClock'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -680,100 +638,13 @@ -} exposeClock   :: forall dom  r-   .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif-     (HiddenClock dom => r)+   . (HiddenClock dom => r)   -- ^ The component with a hidden clock   -> (KnownDomain dom => Clock dom -> r)   -- ^ The component with its clock argument exposed-exposeClock = \f clk -> exposeSpecificClock (const f) clk (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]+exposeClock = \f clk -> expose @(HiddenClockName dom) f clk {-# INLINE exposeClock #-} --- Note [Going from WithSingleDomain to WithSpecificDomain]------ Functions like 'exposeSpecificClock' have a 'WithSpecificDomain dom r'--- constraint on the component with type 'r' that's passed to them. This--- requires 'dom' to be present in 'r' at the time the function is used,--- otherwise it will not type-check.------ Functions like 'exposeClock' have a 'WithSingleDomain dom r' constraint, so--- it is known that the domain 'dom' is indeed in 'r'. So we can safely--- introduce 'dom' into the type passed to 'exposeSpecificClock'. By introducing--- 'dom' into the type, the type checker can find the 'dom' when it type-checks--- that the use of 'exposeSpecificClock' in 'exposeClock' satisies the--- 'WithSpecificDomain dom r' constraint.------ So given:------     exposeClock---       :: forall dom r---        . WithSingleDomain dom r---       => (HiddenClock dom => r)---       -> (KnownDomain dom => Clock dom -> r)---     exposeClock = \f clk -> exposeSpecificClock (const f) clk (Proxy @dom)------ The type of 'exposeSpecificClock' as called from 'exposeClock' could be--- written something like:------     exposeSpecificClock---       :: ( WithSpecificDomain dom s---          , s ~ (Proxy dom -> r)---          )---       => (HiddenClock dom => Proxy dom -> r)---       -> (KnownDomain dom => Clock dom -> Proxy dom -> r)------ The type-checker can now find 'dom' in the 'Proxy', so it type-checks.------ The argument------     (HiddenClock dom => Proxy dom -> r)------ is filled in as 'const f', consuming the 'Proxy' before passing on to 'f'.------ In the resulting------     (KnownDomain dom => Clock dom -> Proxy dom -> r)------ the filled in values are 'clk' and 'Proxy @dom', leaving 'r'.--{- | Expose a hidden 'Clock' argument of a component, so it can be applied-explicitly. This function can be used on components with multiple domains.-As opposed to 'exposeClock', callers should explicitly state what the clock-domain is. See the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'exposeSpecificClock' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = exposeSpecificClock @System reg clockGen->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'exposeSpecificClock' @@dom reg 'clockGen'-@-#endif--}-exposeSpecificClock-   :: forall dom  r-   . WithSpecificDomain dom r-  => (HiddenClock dom => r)-  -- ^ The component with a hidden clock-  -> (KnownDomain dom => Clock dom -> r)-  -- ^ The component with its clock argument exposed-exposeSpecificClock = \f clk -> expose @(HiddenClockName dom) f clk-{-# INLINE exposeSpecificClock #-}- -- | Hide the 'Clock' argument of a component, so it can be routed implicitly. -- -- <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>@@ -788,24 +659,6 @@  {- | Connect an explicit 'Clock' to a function with a hidden 'Clock'. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenClock dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenClock dom => Signal dom a -> Signal dom a-@--If you want to connect a clock to a component working on multiple domains-(such as the first example), use 'withSpecificClock'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -826,56 +679,15 @@ -} withClock   :: forall dom r-   .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif-     KnownDomain dom+   . KnownDomain dom   => Clock dom   -- ^ The 'Clock' we want to connect   -> (HiddenClock dom => r)   -- ^ The function with a hidden 'Clock' argument   -> r-withClock clk f = withSpecificClock clk (const f) (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]+withClock = \clk f -> expose @(HiddenClockName dom) f clk {-# INLINE withClock #-} -{- | Connect an explicit 'Clock' to a function with a hidden 'Clock'. This-function can be used on components with multiple domains. As opposed to-'withClock', callers should explicitly state what the clock domain is. See-the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'withSpecificClock' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = withSpecificClock @System clockGen reg->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'withSpecificClock' @@dom 'clockGen' reg-@-#endif--}-withSpecificClock-  :: forall dom r-   . (KnownDomain dom, WithSpecificDomain dom r)-  => Clock dom-  -- ^ The 'Clock' we want to connect-  -> (HiddenClock dom => r)-  -- ^ The function with a hidden 'Clock' argument-  -> r-withSpecificClock = \clk f -> expose @(HiddenClockName dom) f clk-{-# INLINE withSpecificClock #-}- -- | Connect a hidden 'Clock' to an argument where a normal 'Clock' argument -- was expected. --@@ -890,26 +702,6 @@ {- | Expose a hidden 'Reset' argument of a component, so it can be applied explicitly. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenReset dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenReset dom => Signal dom a -> Signal dom a-@--If you want to expose a reset of a component working on multiple domains-(such as the first example), use 'exposeSpecificReset'.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#endif === __Example__ Usage with a /polymorphic/ domain: @@ -928,53 +720,13 @@ -} exposeReset   :: forall dom r-   .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif-     (HiddenReset dom => r)+   . (HiddenReset dom => r)   -- ^ The component with a hidden reset   -> (KnownDomain dom => Reset dom -> r)   -- ^ The component with its reset argument exposed-exposeReset = \f rst -> exposeSpecificReset (const f) rst (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]+exposeReset = \f rst -> expose @(HiddenResetName dom) f rst {-# INLINE exposeReset #-} -{- | Expose a hidden 'Reset' argument of a component, so it can be applied-explicitly. This function can be used on components with multiple domains.-As opposed to 'exposeReset', callers should explicitly state what the reset-domain is. See the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'exposeSpecificReset' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = exposeSpecificReset @System reg resetGen->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'exposeSpecificReset' @@dom reg 'resetGen'-@-#endif--}-exposeSpecificReset-  :: forall dom r-   . WithSpecificDomain dom r-  => (HiddenReset dom => r)-  -- ^ The component with a hidden reset-  -> (KnownDomain dom => Reset dom -> r)-  -- ^ The component with its reset argument exposed-exposeSpecificReset = \f rst -> expose @(HiddenResetName dom) f rst-{-# INLINE exposeSpecificReset #-}- -- | Hide the 'Reset' argument of a component, so it can be routed implicitly. -- -- <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>@@ -989,26 +741,7 @@  {- | Connect an explicit 'Reset' to a function with a hidden 'Reset'. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when: -@-r ~ HiddenReset dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenReset dom => Signal dom a -> Signal dom a-@--If you want to connect a reset to a component working on multiple domains-(such as the first example), use 'withSpecificReset'.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#endif === __Example__ Usage with a /polymorphic/ domain: @@ -1027,11 +760,7 @@ -} withReset   :: forall dom r-   .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif-     KnownDomain dom+   . KnownDomain dom   => Reset dom   -- ^ The 'Reset' we want to connect   -> (HiddenReset dom => r)@@ -1040,42 +769,6 @@ withReset = \rst f -> expose @(HiddenResetName dom) f rst {-# INLINE withReset #-} -{- | Connect an explicit 'Reset' to a function with a hidden 'Reset'. This-function can be used on components with multiple domains. As opposed to-'withReset', callers should explicitly state what the reset domain is. See-the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'withSpecificReset' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = withSpecificReset @System resetGen reg->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'withSpecificReset' @@dom 'resetGen' reg-@-#endif--}-withSpecificReset-  :: forall dom r-   . (KnownDomain dom, WithSpecificDomain dom r)-  => Reset dom-  -- ^ The 'Reset' we want to connect-  -> (HiddenReset dom => r)-  -- ^ The function with a hidden 'Reset' argument-  -> r-withSpecificReset = \rst f -> expose @(HiddenResetName dom) f rst-{-# INLINE withSpecificReset #-}- -- | Connect a hidden 'Reset' to an argument where a normal 'Reset' argument -- was expected. --@@ -1090,24 +783,6 @@ {- | Expose a hidden 'Enable' argument of a component, so it can be applied explicitly. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenEnable dom => Signal dom a -> Signal dom a-@--If you want to expose a enable of a component working on multiple domains-(such as the first example), use 'exposeSpecificEnable'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -1127,53 +802,14 @@ [5,5,6,7,8,9,10,11,12,13] -} exposeEnable-  :: forall dom  r .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif-     (HiddenEnable dom => r)+  :: forall dom  r+  .  (HiddenEnable dom => r)   -- ^ The component with a hidden enable   -> (KnownDomain dom => Enable dom -> r)   -- ^ The component with its enable argument exposed-exposeEnable = \f gen -> exposeSpecificEnable (const f) gen (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]+exposeEnable = \f gen -> expose @(HiddenEnableName dom) f gen {-# INLINE exposeEnable #-} -{- | Expose a hidden 'Enable' argument of a component, so it can be applied-explicitly. This function can be used on components with multiple domains.-As opposed to 'exposeEnable', callers should explicitly state what the enable-domain is. See the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'exposeSpecificEnable' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = exposeSpecificEnable @System reg enableGen->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'exposeSpecificEnable' @@dom reg 'enableGen'-@-#endif--}-exposeSpecificEnable-  :: forall dom r-   . WithSpecificDomain dom r-  => (HiddenEnable dom => r)-  -- ^ The component with a hidden enable-  -> (KnownDomain dom => Enable dom -> r)-  -- ^ The component with its enable argument exposed-exposeSpecificEnable = \f gen -> expose @(HiddenEnableName dom) f gen-{-# INLINE exposeSpecificEnable #-}- -- | Hide the 'Enable' argument of a component, so it can be routed implicitly. -- -- <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>@@ -1188,24 +824,6 @@  {- | Connect an explicit 'Enable' to a function with a hidden 'Enable'. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenEnable dom => Signal dom a -> Signal dom a-@--If you want to connect a enable to a component working on multiple domains-(such as the first example), use 'withSpecificEnable'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -1227,9 +845,6 @@ withEnable   :: forall dom r    . KnownDomain dom-#ifdef CLASH_MULTIPLE_HIDDEN-  => WithSingleDomain dom r-#endif   => Enable dom   -- ^ The 'Enable' we want to connect   -> (HiddenEnable dom => r)@@ -1238,42 +853,6 @@ withEnable = \gen f -> expose @(HiddenEnableName dom) f gen {-# INLINE withEnable #-} -{- | Connect an explicit 'Enable' to a function with a hidden 'Enable'. This-function can be used on components with multiple domains. As opposed to-'withEnable', callers should explicitly state what the enable domain is. See-the examples for more information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'withSpecificEnable' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = withSpecificEnable @System enableGen reg->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'withSpecificEnable' @@dom 'enableGen' reg-@-#endif--}-withSpecificEnable-  :: forall dom r-   . (KnownDomain dom, WithSpecificDomain dom r)-  => Enable dom-  -- ^ The 'Enable' we want to connect-  -> (HiddenEnable dom => r)-  -- ^ The function with a hidden 'Enable' argument-  -> r-withSpecificEnable = \gen f -> expose @(HiddenEnableName dom) f gen-{-# INLINE withSpecificEnable #-}- -- | Connect a hidden 'Enable' to an argument where a normal 'Enable' argument -- was expected. --@@ -1295,24 +874,6 @@ The component whose enable is modified will only be enabled when both the encompassing 'HiddenEnable' and the 'Signal' @dom@ 'Bool' are asserted. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single-domain. For example, this function will refuse when:--@-r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenEnable dom => Signal dom a -> Signal dom a-@--If you want to merge an enable of a component working on multiple domains-(such as the first example), use 'andSpecificEnable'.-#endif- <#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -1334,94 +895,26 @@ andEnable   :: forall dom r    . HiddenEnable dom-#ifdef CLASH_MULTIPLE_HIDDEN-  => WithSingleDomain dom r-#endif   => Signal dom Bool   -- ^ The signal to AND with   -> (HiddenEnable dom => r)   -- ^ The component whose enable is modified   -> r-andEnable = \en f -> andSpecificEnable en (const f) (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]-{-# INLINE andEnable #-}--#ifdef CLASH_MULTIPLE_HIDDEN-{- | Merge enable signal with signal of bools by applying the boolean AND-operation.--__NB: The component given to 'andSpecificEnable' as an argument needs an explicit type signature.__-Please read [Monomorphism restriction leads to-surprising behavior](#monomorphism).--The component whose enable is modified will only be enabled when both the-encompassing 'HiddenEnable' and the 'Signal' @dom@ 'Bool' are asserted.--This function can be used on components with multiple domains. As opposed to-'andEnable', callers should explicitly state what the enable domain is. See the-examples for more information.--<#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--=== __Example__-'andSpecificEnable' can only be used when it can find the specified domain-in /r/:-->>> reg = register @System 5 (reg + 1)->>> f en = andSpecificEnable @System en reg->>> sampleN 10 (f (riseEvery d2))-[5,5,5,6,6,7,7,8,8,9]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-f en = 'andSpecificEnable' @@dom en reg-@--}-#endif-andSpecificEnable-  :: forall dom r-   . ( HiddenEnable dom-     , WithSpecificDomain dom r)-  => Signal dom Bool-  -- ^ The signal to AND with-  -> (HiddenEnable dom => r)-  -- ^ The component whose enable is modified-  -> r-andSpecificEnable = \en f -> andSpecificEnable0 hasEnable en f+andEnable = \en f -> andEnable0 hasEnable en f  where-  andSpecificEnable0+  andEnable0     :: Enable dom     -> Signal dom Bool     -> (HiddenEnable dom => r)     -> r-  andSpecificEnable0 gen en f =+  andEnable0 gen en f =     let en0 = E.andEnable gen en-    in withSpecificEnable @dom en0 f-{-# INLINE andSpecificEnable #-}+    in withEnable @dom en0 f+{-# INLINE andEnable #-}  {- | Expose hidden 'Clock', 'Reset', and 'Enable' arguments of a component, so they can be applied explicitly. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenClockResetEnable dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenClockResetEnable dom => Signal dom a -> Signal dom a-@--If you want to expose a clock, reset, and enable of a component working on-multiple domains (such as the first example), use 'exposeSpecificClockResetEnable'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -1459,55 +952,15 @@ -} exposeClockResetEnable   :: forall dom r .-#ifdef CLASH_MULTIPLE_HIDDEN-     WithSingleDomain dom r =>-#endif      (HiddenClockResetEnable dom => r)   -- ^ The component with hidden clock, reset, and enable arguments   -> (KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r)   -- ^ The component with its clock, reset, and enable arguments exposed exposeClockResetEnable =   \f clk rst en ->-    exposeSpecificClock (exposeSpecificReset (exposeEnable f)) clk rst en+    exposeClock (exposeReset (exposeEnable f)) clk rst en {-# INLINE exposeClockResetEnable #-} -#ifdef CLASH_MULTIPLE_HIDDEN--- | Expose hidden 'Clock', 'Reset', and 'Enable' arguments of a component, so--- they can be applied explicitly. This function can be used on components with--- multiple domains. As opposed to 'exposeClockResetEnable', callers should--- explicitly state what the domain is. See the examples for more information.------ <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>------ === __Example__--- 'exposeSpecificClockResetEnable' can only be used when it can find the--- specified domain in /r/:------ >>> reg = register @System 5 (reg + 1)--- >>> sig = exposeSpecificClockResetEnable @System reg clockGen resetGen enableGen--- >>> sampleN 10 sig--- [5,5,6,7,8,9,10,11,12,13]------ Type variables work too, if they are in scope. For example:------ @--- reg = 'register' @@dom 5 (reg + 1)--- sig = exposeSpecificClockResetEnable @@dom reg 'clockGen' 'resetGen' 'enableGen'--- @----exposeSpecificClockResetEnable-  :: forall dom r-   . WithSpecificDomain dom r-  => (HiddenClockResetEnable dom => r)-  -- ^ The function with hidden 'Clock', 'Reset', and 'Enable' arguments-  -> (KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r)-  -- ^ The component with its 'Clock', 'Reset', and 'Enable' arguments exposed-exposeSpecificClockResetEnable =-  \f clk rst en ->-    exposeSpecificClock (exposeSpecificReset (exposeSpecificEnable f)) clk rst en-{-# INLINE exposeSpecificClockResetEnable #-}-#endif- -- | Hide the 'Clock', 'Reset', and 'Enable' arguments of a component, so they -- can be routed implicitly. --@@ -1529,25 +982,6 @@ {- | Connect an explicit 'Clock', 'Reset', and 'Enable' to a function with a hidden 'Clock', 'Reset', and 'Enable'. -#ifdef CLASH_MULTIPLE_HIDDEN-This function can only be used on components with a single domain. For-example, this function will refuse when:--@-r ~ HiddenClockResetEnable dom1 => Signal dom1 a -> Signal dom2 a-@--But will work when:--@-r ~ HiddenClockResetEnable dom => Signal dom a -> Signal dom a-@--If you want to connect a clock, reset, and enable to a component working on-multiple domains (such as the first example), use-'withSpecificClockResetEnable'.--#endif <Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>  === __Example__@@ -1569,9 +1003,6 @@ withClockResetEnable   :: forall dom r    . KnownDomain dom-#ifdef CLASH_MULTIPLE_HIDDEN-  => WithSingleDomain dom r-#endif   => Clock dom   -- ^ The 'Clock' we want to connect   -> Reset dom@@ -1583,52 +1014,9 @@   -- 'Enable' argument   -> r withClockResetEnable =-  \clk rst en f -> withSpecificClockResetEnable clk rst en (const f) (Proxy @dom)--- See Note [Going from WithSingleDomain to WithSpecificDomain]+  \clk rst en f -> withClock clk (withReset rst (withEnable en f)) {-# INLINE withClockResetEnable #-} -{- | Connect an explicit 'Clock', 'Reset', and 'Enable' to a function with-hidden 'Clock', 'Reset', and 'Enable' arguments. This function can be used on-components with multiple domains. As opposed to 'withClockResetEnable',-callers should explicitly state what the domain is. See the examples for more-information.--<Clash-Signal.html#hiddenclockandreset Click here to read more about hidden clocks, resets, and enables>--#ifdef CLASH_MULTIPLE_HIDDEN-=== __Example__-'withSpecificClockResetEnable' can only be used when it can find the-specified domain in /r/:-->>> reg = register @System 5 (reg + 1)->>> sig = withSpecificClockResetEnable @System clockGen resetGen enableGen reg->>> sampleN 10 sig-[5,5,6,7,8,9,10,11,12,13]--Type variables work too, if they are in scope. For example:--@-reg = 'register' @@dom 5 (reg + 1)-sig = 'withSpecificClockResetEnable' @@dom 'clockGen' 'resetGen' 'enableGen' reg-@-#endif--}-withSpecificClockResetEnable-  :: forall dom r-   . (KnownDomain dom, WithSpecificDomain dom r)-  => Clock dom-  -- ^ The 'Clock' we want to connect-  -> Reset dom-  -- ^ The 'Reset' we want to connect-  -> Enable dom-  -- ^ The 'Enable' we want to connect-  -> (HiddenClockResetEnable dom => r)-  -- ^ The function with hidden 'Clock', 'Reset', and 'Enable' arguments-  -> r-withSpecificClockResetEnable =-  \clk rst en f -> withSpecificClock clk (withSpecificReset rst (withSpecificEnable en f))-{-# INLINE withSpecificClockResetEnable #-}- -- * Basic circuit functions  -- | Special version of 'delay' that doesn't take enable signals of any kind.@@ -1816,6 +1204,29 @@     i {-# INLINE regEn #-} +-- | A chain of 'regEn's.+regEnN ::+  forall dom a n.+  (HiddenClockResetEnable dom, NFDataX a) =>+  -- | The number of stored elements+  SNat n ->+  -- | Initial content of all elements in the chain.+  a ->+  -- | The "push next input" indicator+  Signal dom Bool ->+  Signal dom a ->+  Signal dom a+regEnN = \sn initial en i ->+  E.regEnN+    (fromLabel @(HiddenClockName dom))+    (fromLabel @(HiddenResetName dom))+    (fromLabel @(HiddenEnableName dom))+    sn+    initial+    en+    i+{-# INLINE regEnN #-}+ -- * Signal -> List conversion  -- | Get an infinite list of samples from a 'Signal'@@ -1842,8 +1253,7 @@   -> [a] sample s =   E.sample (exposeClockResetEnable @dom s clockGen resetGen enableGen)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sample #-}+{-# OPAQUE sample #-}  -- | Get a list of /n/ samples from a 'Signal' --@@ -1872,8 +1282,7 @@ sampleN n s0 =   let s1 = exposeClockResetEnable @dom s0 clockGen resetGen enableGen in   E.sampleN n s1--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sampleN #-}+{-# OPAQUE sampleN #-}  -- | Get an infinite list of samples from a 'Signal', while asserting the reset -- line for /m/ clock cycles. 'sampleWithReset' does not return the first /m/@@ -1894,8 +1303,7 @@ sampleWithReset nReset f0 =   let f1 = exposeClockResetEnable f0 clockGen (resetGenN @dom nReset) enableGen in   drop (snatToNum nReset) (E.sample f1)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sampleWithReset #-}+{-# OPAQUE sampleWithReset #-}  -- | Get a list of /n/ samples from a 'Signal', while asserting the reset line -- for /m/ clock cycles. 'sampleWithReset' does not return the first /m/ cycles,@@ -1940,8 +1348,7 @@   -> [a] sample_lazy s =   E.sample_lazy (exposeClockResetEnable @dom s clockGen resetGen enableGen)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sample_lazy #-}+{-# OPAQUE sample_lazy #-}  -- | Lazily get a list of /n/ samples from a 'Signal' --@@ -1966,8 +1373,7 @@   -> [a] sampleN_lazy n s =   E.sampleN_lazy n (exposeClockResetEnable @dom s clockGen resetGen enableGen)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE sampleN_lazy #-}+{-# OPAQUE sampleN_lazy #-}  -- * Simulation functions @@ -2089,8 +1495,7 @@ simulate_lazy f0 =   let f1 = exposeClockResetEnable @dom f0 clockGen resetGen enableGen in   drop 1 . E.simulate_lazy f1 . dup1--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE simulate_lazy #-}+{-# OPAQUE simulate_lazy #-}  -- | Simulate a (@'Unbundled' a -> 'Unbundled' b@) function given a list of -- samples of type @a@@@ -2118,15 +1523,13 @@   drop 1 . E.simulateB f1 . dup1  where   f1 =-    withSpecificClockResetEnable-      @dom+    withClockResetEnable       clockGen       resetGen       enableGen       (const f0)       (Proxy @dom)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE simulateB #-}+{-# OPAQUE simulateB #-}  -- | /Lazily/ simulate a (@'Unbundled' a -> 'Unbundled' b@) function given a -- list of samples of type @a@@@ -2151,15 +1554,13 @@   drop 1 . E.simulateB_lazy f1 . dup1  where   f1 =-    withSpecificClockResetEnable-      @dom+    withClockResetEnable       clockGen       resetGen       enableGen       (const f0)       (Proxy @dom)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE simulateB_lazy #-}+{-# OPAQUE simulateB_lazy #-}  dup1 :: [a] -> [a] dup1 (x:xs) = x:x:xs@@ -2260,18 +1661,6 @@   -> Property testFor n s = property (and (Clash.Signal.sampleN n s)) -#ifdef CLASH_MULTIPLE_HIDDEN--- ** Synchronization primitive--- | Implicit version of 'Clash.Explicit.Signal.unsafeSynchronizer'.-unsafeSynchronizer-  :: forall dom1 dom2 a-   . ( HiddenClock dom1-     , HiddenClock dom2 )-  => Signal dom1 a-  -> Signal dom2 a-unsafeSynchronizer =-  hideClock (hideClock E.unsafeSynchronizer)-#endif  -- | Register a synchronous reset signal. --@@ -2348,20 +1737,6 @@ fromListWithReset = hideReset E.fromListWithReset {-# INLINE fromListWithReset #-} -#ifdef CLASH_MULTIPLE_HIDDEN--- | Convert between different types of reset, adding a synchronizer in case--- it needs to convert from an asynchronous to a synchronous reset.-convertReset-  :: forall domA domB-   . ( HiddenClock domA-     , HiddenClock domB-     )-  => Reset domA-  -> Reset domB-convertReset =-  E.convertReset hasClock hasClock-#endif- -- | Build an 'Automaton' from a function over 'Signal's. -- -- __NB__: Consumption of continuation of the 'Automaton' must be affine; that@@ -2375,5 +1750,4 @@ signalAutomaton f0 =   let f1 = exposeClockResetEnable @dom f0 clockGen resetGen enableGen in   E.signalAutomaton f1--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE signalAutomaton #-}+{-# OPAQUE signalAutomaton #-}

@@ -104,6 +104,9 @@ {-# OPTIONS_GHC -fplugin=GHC.TypeLits.Normalise #-} {-# OPTIONS_GHC -fplugin=GHC.TypeLits.KnownNat.Solver #-} +-- TryDomain / HasDomain instances+{-# OPTIONS_GHC -Wno-deprecations #-}+ module Clash.Signal.BiSignal (     BiSignalIn()   , BiSignalOut()@@ -240,8 +243,7 @@     SFloating -> fromMaybe (errorX " undefined value on BiSignalIn") <$> s     SPullDown  -> fromMaybe minBound <$> s     SPullUp    -> fromMaybe maxBound <$> s--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE readFromBiSignal# #-}+{-# OPAQUE readFromBiSignal# #-} {-# ANN readFromBiSignal# hasBlackBox #-}  -- | Read the value from an __inout__ port@@ -261,8 +263,7 @@   => Vec n (BiSignalOut defaultState dom m)   -> BiSignalOut defaultState dom m mergeBiSignalOuts = mconcat . V.toList--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE mergeBiSignalOuts #-}+{-# OPAQUE mergeBiSignalOuts #-} {-# ANN mergeBiSignalOuts hasBlackBox #-}  writeToBiSignal#@@ -273,8 +274,7 @@   -> Signal d (BitVector n)   -> BiSignalOut ds d n writeToBiSignal# bIn maybeSignal wEn val = BiSignalOut [bIn `seq` wEn `seq` val `seq` maybeSignal]--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE writeToBiSignal# #-}+{-# OPAQUE writeToBiSignal# #-} {-# ANN writeToBiSignal# hasBlackBox #-}  -- | Write to an __inout__ port@@ -321,6 +321,5 @@      -- Recursive step     biSignalOut' = veryUnsafeToBiSignalIn $ BiSignalOut $ map tail# signals--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE veryUnsafeToBiSignalIn #-}+{-# OPAQUE veryUnsafeToBiSignalIn #-} {-# ANN veryUnsafeToBiSignalIn hasBlackBox #-}

@@ -155,8 +155,7 @@   bundle   = vecBundle#   unbundle = sequenceA . fmap lazyV --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE vecBundle# #-}+{-# OPAQUE vecBundle# #-} {-# ANN vecBundle# hasBlackBox #-} vecBundle# :: Vec n (Signal t a) -> Signal t (Vec n a) vecBundle# = traverse# id

@@ -73,20 +73,12 @@         instTy = AppT bundleTy $ mkTupleT vars          -- Associated type Unbundled-#if MIN_VERSION_template_haskell(2,15,0)         unbundledTypeEq =           TySynEqn Nothing             ((ConT unbundledTyName `AppT`                 VarT tNm ) `AppT` mkTupleT vars )             $ mkTupleT $ map (AppT (signal `AppT` VarT tNm)) vars         unbundledType = TySynInstD unbundledTypeEq-#else-        unbundledTypeEq =-          TySynEqn-            [ VarT tNm, mkTupleT vars ]-            $ mkTupleT $ map (AppT (signal `AppT` VarT tNm)) vars-        unbundledType = TySynInstD unbundledTyName unbundledTypeEq-#endif          mkFunD nm alias = FunD nm [Clause [] (NormalB (VarE alias)) []]         bundleD = mkFunD bundleName bundlePrimName

@@ -105,22 +105,11 @@  Or @d@ can be specified using type application: -#if __GLASGOW_HASKELL__ >= 902 >>> :t delayedI @3 delayedI @3   :: ... =>      a -> DSignal dom n a -> DSignal dom (n + 3) a -#else->>> :t delayedI @3-delayedI @3-  :: (...-      ...-      ...-      ...) =>-     a -> DSignal dom n a -> DSignal dom (n + 3) a--#endif -} delayedI   :: ( KnownNat d@@ -190,7 +179,7 @@   -> DSignal dom (n+d) a delayI dflt = hideClock (hideEnable (E.delayI dflt)) --- | Tree fold over a 'Vec' of 'DSignal's with a combinatorial function,+-- | Tree fold over a 'Vec' of 'DSignal's with a combinational function, -- and delaying @delay@ cycles after each application. -- Values at times 0..(delay*k)-1 are set to a default. --

@@ -8,7 +8,6 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE NoImplicitPrelude #-}-{-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeFamilyDependencies #-}  module Clash.Signal.Delayed.Bundle (@@ -18,9 +17,6 @@   , TaggedEmptyTuple(..)   ) where -#if !MIN_VERSION_base(4,18,0)-import           Control.Applicative           (liftA2)-#endif import           GHC.TypeLits                  (KnownNat) import           Prelude                       hiding (head, map, tail) 

@@ -1,10 +1,10 @@ {-|   Copyright   :  (C) 2019     , Myrtle Software Ltd.                      2018     , @blaxill-                     2018-2019, QBayLogic B.V.+                     2018-2025, QBayLogic B.V.                      2021     , LUMI GUIDE FIETSDETECTIE B.V.   License     :  BSD2 (see the file LICENSE)-  Maintainer  :  Christiaan Baaij <christiaan.baaij@gmail.com>+  Maintainer  :  QBayLogic B.V. <devops@qbaylogic.com> -} {-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-}@@ -35,7 +35,7 @@ where  import Data.Coerce                (coerce)-import Data.Default.Class         (Default(..))+import Data.Default               (Default(..)) import GHC.TypeLits               (Nat, type (+)) import Language.Haskell.TH.Syntax (Lift) import Test.QuickCheck            (Arbitrary, CoArbitrary)

@@ -1,8 +1,9 @@ {-| Copyright  :  (C) 2013-2016, University of Twente,-                  2017-2019, Myrtle Software Ltd+                  2017-2019, Myrtle Software Ltd,                   2017-2022, Google Inc.,-                  2021-2023, QBayLogic B.V.+                  2020     , Gergő Érdi,+                  2021-2025, QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> -}@@ -20,6 +21,7 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}  {-# LANGUAGE Unsafe #-} @@ -67,12 +69,22 @@   , DomainConfigurationInitBehavior   , DomainConfigurationResetPolarity -    -- *** Convenience types-+  -- *** Convenience types   , HasSynchronousReset   , HasAsynchronousReset   , HasDefinedInitialValues-+  -- **** Time representations+  , Seconds+  , Milliseconds+  , Microseconds+  , Nanoseconds+  , Picoseconds+  -- **** Time conversions+  , DomainToHz+  , HzToPeriod+  , PeriodToHz+  , PeriodToCycles+  , ClockDivider     -- ** Default domains   , System   , XilinxSystem@@ -114,6 +126,7 @@   , syncRegister#   , registerPowerup#   , mux+  , apEn     -- * Simulation and testbench functions   , clockGen   , tbClockGen@@ -127,7 +140,7 @@   , resetGen   , resetGenN     -- * Boolean connectives-  , (.&&.), (.||.)+  , (.&&.), (&&.), (.&&), (.||.), (||.), (.||)     -- * Simulation functions (not synthesizable)   , simulate     -- ** lazy version@@ -146,9 +159,9 @@   , testFor     -- * Type classes     -- ** 'Eq'-like-  , (.==.), (./=.)+  , (.==.), (.==), (==.), (./=.), (./=), (/=.)     -- ** 'Ord'-like-  , (.<.), (.<=.), (.>=.), (.>.)+  , (.<.), (.<), (<.), (.<=.), (.<=), (<=.), (.>=.), (.>=), (>=.), (.>.), (.>), (>.)     -- ** 'Functor'   , mapSignal#     -- ** 'Applicative'@@ -170,11 +183,10 @@ where  import Data.IORef                 (IORef, atomicModifyIORef, newIORef, readIORef)+#if __GLASGOW_HASKELL__ < 912 import Type.Reflection            (Typeable)-import Control.Arrow.Transformer.Automaton-#if !MIN_VERSION_base(4,18,0)-import Control.Applicative        (liftA2) #endif+import Control.Arrow.Transformer.Automaton import Control.Applicative        (liftA3) import Control.DeepSeq            (NFData) import Clash.Annotations.Primitive (hasBlackBox, dontTranslate)@@ -182,7 +194,7 @@ import Data.Char                  (isAsciiUpper, isAlphaNum, isAscii) import Data.Coerce                (coerce) import Data.Data                  (Data)-import Data.Default.Class         (Default (..))+import Data.Default               (Default (..)) import Data.Hashable              (Hashable) import Data.Int                   (Int64) import Data.Maybe                 (isJust)@@ -191,7 +203,10 @@ import Data.Type.Equality         ((:~:)) import GHC.Generics               (Generic) import GHC.Stack                  (HasCallStack, withFrozenCallStack)-import GHC.TypeLits               (KnownSymbol, KnownNat, Nat, Symbol, type (<=), sameSymbol)+import GHC.TypeLits+  (Div, KnownSymbol, KnownNat, Nat, Symbol, type (<=), type (*), sameSymbol)+import GHC.TypeLits.Extra         (DivRU)+import GHC.Records                (HasField(getField)) import Language.Haskell.TH.Syntax -- (Lift (..), Q, Dec) import Language.Haskell.TH.Compat import Numeric.Natural            (Natural)@@ -199,6 +214,7 @@ import Test.QuickCheck            (Arbitrary (..), CoArbitrary(..), Property,                                    property) +import Clash.Class.Num            (SaturatingNum(..)) import Clash.CPP                  (fStrictMapSignal) import Clash.NamedTypes import Clash.Promoted.Nat         (SNat (..), snatToNum, snatToNatural)@@ -331,7 +347,9 @@   , _resetPolarity :: ResetPolarity   -- ^ Whether resets are active high or active low   }+#if __GLASGOW_HASKELL__ < 912   deriving (Typeable)+#endif  -- | Helper type family for 'DomainPeriod' type family DomainConfigurationPeriod (config :: DomainConfiguration) :: Nat where@@ -439,9 +457,43 @@ type DomainResetPolarity (dom :: Domain) =   DomainConfigurationResetPolarity (KnownConf dom) +-- * Time representation++-- | Gets time in 'Picoseconds' from time in 'Seconds'+type Seconds      (s  :: Nat) = Milliseconds (1000 * s)+-- | Gets time in 'Picoseconds' from time in 'Milliseconds'+type Milliseconds (ms :: Nat) = Microseconds (1000 * ms)+-- | Gets time in 'Picoseconds' from time in 'Microseconds'+type Microseconds (us :: Nat) = Nanoseconds  (1000 * us)+-- | Gets time in 'Picoseconds' from time in 'Nanoseconds'+type Nanoseconds  (ns :: Nat) = Picoseconds  (1000 * ns)+-- | Gets time in 'Picoseconds' from time in picoseconds, essentially 'id'+type Picoseconds  (ps :: Nat) = ps++-- | Converts a frequency in hertz to a period in picoseconds. This might lead to rounding+-- errors.+type HzToPeriod (hz :: Nat) = Seconds 1 `Div` hz++-- | The domain's clock frequency in hertz, calculated based on the period stored in+-- picoseconds. This might lead to rounding errors.+type DomainToHz (dom :: Domain) = PeriodToHz (DomainPeriod dom)++-- | Number of clock cycles required at the clock frequency of @dom@ before a minimum+-- @period@ has passed+type PeriodToCycles (dom :: Domain) (period :: Nat) =  period `DivRU` DomainPeriod dom++-- | Converts a period in picoseconds to a frequency in hertz. This might lead to rounding+-- errors.+type PeriodToHz (period :: Nat) = (Seconds 1) `Div` period++-- | Number of clock cycles required at the clock frequency of @dom@ before a minimum+-- @period@ has passed. The same as 'PeriodToCycles'.+type ClockDivider (dom :: Domain) (period :: Nat) = PeriodToCycles dom period+ -- | Singleton version of 'DomainConfiguration' data SDomainConfiguration (dom :: Domain) (conf :: DomainConfiguration) where   SDomainConfiguration ::+    1 <= period =>     { sName :: SSymbol dom       -- ^ Domain name     , sPeriod :: SNat period@@ -775,14 +827,15 @@ tail# :: Signal dom a -> Signal dom a tail# (_  :- xs') = xs' +instance HasField (x :: k) r a => HasField x (Signal dom r) (Signal dom a) where+  getField = fmap (getField @x @r @a)+ instance Show a => Show (Signal dom a) where   show (x :- xs) = show x ++ " " ++ show xs  instance Lift a => Lift (Signal dom a) where   lift ~(x :- _) = [| signal# x |]-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif  instance Default a => Default (Signal dom a) where   def = signal# def@@ -796,8 +849,7 @@   -- See -fstrict-mapSignal documentation in clash-prelude.cabal   theSeq = if fStrictMapSignal then seqX else flip const   go ~(xs@(a :- as)) = f a :- (a `theSeq` (xs `seq` go as))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE mapSignal# #-}+{-# OPAQUE mapSignal# #-} {-# ANN mapSignal# hasBlackBox #-}  instance Applicative (Signal dom) where@@ -806,14 +858,12 @@  signal# :: a -> Signal dom a signal# a = let s = a :- s in s--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE signal# #-}+{-# OPAQUE signal# #-} {-# ANN signal# hasBlackBox #-}  appSignal# :: Signal dom (a -> b) -> Signal dom a -> Signal dom b appSignal# (f :- fs) xs@(~(a :- as)) = f a :- (xs `seq` appSignal# fs as) -- See [NOTE: Lazy ap]--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE appSignal# #-}+{-# OPAQUE appSignal# #-} {-# ANN appSignal# hasBlackBox #-}  instance NFDataX a => NFDataX (Signal domain a) where@@ -854,8 +904,7 @@ -- Is currently treated as 'id' by the Clash compiler. joinSignal# :: Signal dom (Signal dom a) -> Signal dom a joinSignal# ~(xs :- xss) = head# xs :- joinSignal# (mapSignal# tail# xss)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE joinSignal# #-}+{-# OPAQUE joinSignal# #-} {-# ANN joinSignal# hasBlackBox #-}  instance Num a => Num (Signal dom a) where@@ -867,6 +916,17 @@   signum      = fmap signum   fromInteger = signal# . fromInteger +instance Bounded a => Bounded (Signal dom a) where+  minBound = pure minBound+  maxBound = pure maxBound++instance SaturatingNum a => SaturatingNum (Signal dom a) where+  satAdd mode = liftA2 (satAdd mode)+  satSub mode = liftA2 (satSub mode)+  satMul mode = liftA2 (satMul mode)+  satSucc mode = fmap (satSucc mode)+  satPred mode = fmap (satPred mode)+ -- | __NB__: Not synthesizable -- -- __NB__: In \"@'foldr' f z s@\":@@ -884,8 +944,7 @@ -- * The @z@ element will never be used. foldr# :: (a -> b -> b) -> b -> Signal dom a -> b foldr# f z (a :- s) = a `f` (foldr# f z s)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE foldr# #-}+{-# OPAQUE foldr# #-} {-# ANN foldr# hasBlackBox #-}  instance Traversable (Signal dom) where@@ -893,8 +952,7 @@  traverse# :: Applicative f => (a -> f b) -> Signal dom a -> f (Signal dom b) traverse# f (a :- s) = (:-) <$> f a <*> traverse# f s--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traverse# #-}+{-# OPAQUE traverse# #-} {-# ANN traverse# hasBlackBox #-}  -- * Clocks, resets, and enables@@ -1026,8 +1084,7 @@   => Signal testDom Bool   -> Clock testDom tbClockGen done = Clock (done `seq` SSymbol) Nothing--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE tbClockGen #-}+{-# OPAQUE tbClockGen #-} {-# ANN tbClockGen hasBlackBox #-}  -- | Femtoseconds expressed as an 'Int64'. Is a newtype to prevent accidental@@ -1105,8 +1162,7 @@   Clock dom tbDynamicClockGen periods ena =   Clock (ena `seq` periods `seq` SSymbol) (Just periods)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE tbDynamicClockGen #-}+{-# OPAQUE tbDynamicClockGen #-} {-# ANN tbDynamicClockGen hasBlackBox #-}  @@ -1156,8 +1212,7 @@   let asserted = replicate (snatToNum n) True in   unsafeFromActiveHigh (fromList (asserted ++ repeat False)) {-# ANN resetGenN hasBlackBox #-}--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE resetGenN #-}+{-# OPAQUE resetGenN #-}   -- | A reset signal belonging to a domain called /dom/.@@ -1181,7 +1236,7 @@ -- -- * <Clash-Explicit-Signal.html#metastability meta-stability> ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1201,7 +1256,7 @@ -- -- * <Clash-Explicit-Signal.html#metastability meta-stability> ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1219,7 +1274,7 @@ -- -- * <Clash-Explicit-Signal.html#metastability meta-stability> ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1239,7 +1294,7 @@ -- -- * <Clash-Explicit-Signal.html#metastability meta-stability> ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1256,7 +1311,7 @@ -- -- * <Clash-Explicit-Signal.html#metastability meta-stability> ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1267,12 +1322,11 @@   :: Reset dom   -> Signal dom Bool unsafeFromReset (Reset r) = r--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeFromReset #-}+{-# OPAQUE unsafeFromReset #-} {-# ANN unsafeFromReset hasBlackBox #-}  -- | 'unsafeToReset' is unsafe. For asynchronous resets it is unsafe--- because it can introduce combinatorial loops. In case of synchronous resets+-- because it can introduce combinational loops. In case of synchronous resets -- it can lead to <Clash-Explicit-Signal.html#metastability meta-stability> -- issues in the presence of asynchronous resets. --@@ -1283,14 +1337,13 @@   => Signal dom Bool   -> Reset dom unsafeToReset r = Reset r--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unsafeToReset #-}+{-# OPAQUE unsafeToReset #-} {-# ANN unsafeToReset hasBlackBox #-}  -- | Interpret a signal of bools as an active high reset and convert it to -- a reset signal corresponding to the domain's setting. ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1307,7 +1360,7 @@ -- | Interpret a signal of bools as an active high reset and convert it to -- a reset signal corresponding to the domain's setting. ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1326,7 +1379,7 @@ -- | Interpret a signal of bools as an active low reset and convert it to -- a reset signal corresponding to the domain's setting. ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1343,7 +1396,7 @@ -- | Interpret a signal of bools as an active low reset and convert it to -- a reset signal corresponding to the domain's setting. ----- For asynchronous resets it is unsafe because it can cause combinatorial+-- For asynchronous resets it is unsafe because it can cause combinational -- loops. In case of synchronous resets it can lead to -- <Clash-Explicit-Signal.html#metastability meta-stability> in the presence of -- asynchronous resets.@@ -1374,6 +1427,30 @@ (.||.) :: Applicative f => f Bool -> f Bool -> f Bool (.||.) = liftA2 (||) +infix 2 .||+-- | The above type is a generalization for:+--+-- @+-- __(.||)__ :: 'Ord' a => 'Clash.Signal.Signal' Bool -> 'Bool' -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('||') that allows comparing a @'Clash.Signal.Signal' Bool@ with a constant+-- @Bool@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.||) :: Functor f => f Bool -> Bool -> f Bool+a .|| b = fmap (|| b) a++infixr 2 ||.+-- | The above type is a generalization for:+--+-- @+-- __(||.)__ :: 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('||') that allows comparing a constant @Bool@ with a @'Clash.Signal.Signal' Bool@+-- and returns a 'Clash.Signal.Signal' of 'Bool'+(||.) :: Functor f => Bool -> f Bool -> f Bool+a ||. b = fmap (a ||) b+ infixr 3 .&&. -- | The above type is a generalization for: --@@ -1385,6 +1462,30 @@ (.&&.) :: Applicative f => f Bool -> f Bool -> f Bool (.&&.) = liftA2 (&&) +infixr 3 .&&+-- | The above type is a generalization for:+--+-- @+-- __(.&&)__ :: 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('&&') that allows comparing a @'Clash.Signal.Signal' Bool@ with a+-- constant @Bool@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.&&) :: (Functor f) => f Bool -> Bool -> f Bool+(.&&) a b = fmap (&& b) a++infixr 3 &&.+-- | The above type is a generalization for:+--+-- @+-- __(&&.)__ :: 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool' -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('&&') that allows comparing a constant @'Bool@ with a+-- @'Clash.Signal.Signal' Bool@ and returns a 'Clash.Signal.Signal' of 'Bool'+(&&.) :: (Functor f) => Bool -> f Bool -> f Bool+(&&.) a b = fmap (a &&) b+ -- [Note: register strictness annotations] -- -- In order to produce the first (current) value of the register's output@@ -1427,8 +1528,7 @@       let o' = if e then x else o       -- See [Note: register strictness annotations]       in  o `defaultSeqX` o :- (as `seq` go o' es xs)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE delay# #-}+{-# OPAQUE delay# #-} {-# ANN delay# hasBlackBox #-}  -- | A register with a power up and reset value. Power up values are not@@ -1461,8 +1561,7 @@       syncRegister# clk rst ena powerUpVal resetVal     SDomainConfiguration _name _period _edge SAsynchronous _init _polarity ->       asyncRegister# clk rst ena powerUpVal resetVal--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE register# #-}+{-# OPAQUE register# #-} {-# ANN register# hasBlackBox #-}  -- | Acts like 'id' if given domain allows powerup values, but returns a@@ -1507,8 +1606,7 @@         oE = if r then resetVal else (if e then x else o)         -- [Note: register strictness annotations]     in  o `defaultSeqX` oR :- (as `seq` enas `seq` go oE rs es xs)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE asyncRegister# #-}+{-# OPAQUE asyncRegister# #-} {-# ANN asyncRegister# hasBlackBox #-}  -- | Version of 'register#' that simulates a register on a synchronous@@ -1537,8 +1635,7 @@         oR = if r then resetVal else oE         -- [Note: register strictness annotations]     in  o `defaultSeqX` o :- (rt `seq` enas `seq` as `seq` go oR rs es xs)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE syncRegister# #-}+{-# OPAQUE syncRegister# #-} {-# ANN syncRegister# dontTranslate #-}  -- | The above type is a generalization for:@@ -1553,6 +1650,13 @@ mux = liftA3 (\b t f -> if b then t else f) {-# INLINE mux #-} +-- | A 'mux' extension muxing between a given argument and an updated version.+-- Given @apEn b f s@, output an updated version of @s@ (i.e., @f s@)+-- when @b@ is 'True', but return it unchanged (i.e., @s@) when @b@ is 'False'.+apEn :: Applicative f => f Bool -> (a -> a) -> f a -> f a+apEn cond upd x = mux cond (upd <$> x) x+{-# INLINE apEn #-}+ infix 4 .==. -- | The above type is a generalization for: --@@ -1564,6 +1668,30 @@ (.==.) :: (Eq a, Applicative f) => f a -> f a -> f Bool (.==.) = liftA2 (==) +infix 4 .==+-- | The above type is a generalization for:+--+-- @+-- __(.==)__ :: 'Eq' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('==') that allows comparing a @'Clash.Signal.Signal' a@ with a+-- constant @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.==) :: (Eq a, Functor f) => f a -> a -> f Bool+(.==) a b = fmap (==b) a++infix 4 ==.+-- | The above type is a generalization for:+--+-- @+-- __(==.)__ :: 'Eq' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('==') that allows comparing a @'Clash.Signal.Signal' a@ with a+-- constant @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(==.) :: (Eq a, Functor f) => a -> f a -> f Bool+(==.) a b = fmap (a==) b+ infix 4 ./=. -- | The above type is a generalization for: --@@ -1575,6 +1703,31 @@ (./=.) :: (Eq a, Applicative f) => f a -> f a -> f Bool (./=.) = liftA2 (/=) +infix 4 ./=+-- | The above type is a generalization for:+--+-- @+-- __(./=)__ :: 'Eq' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('/=') that allows comparing a @'Clash.Signal.Signal' a@ with a+-- constant @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(./=) :: (Eq a, Functor f) => f a -> a -> f Bool+(./=) a b = fmap (/=b) a++infix 4 /=.+-- | The above type is a generalization for:+--+-- @+-- __(/=.)__ :: 'Eq' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('/=') that allows comparing a @'Clash.Signal.Signal' a@ with a+-- constant @a@ and returns a 'Clash.Signal.Signal' of 'Bool'++(/=.) :: (Eq a, Functor f) => a -> f a -> f Bool+(/=.) a b = fmap (a /=) b+ infix 4 .<. -- | The above type is a generalization for: --@@ -1586,6 +1739,30 @@ (.<.) :: (Ord a, Applicative f) => f a -> f a -> f Bool (.<.) = liftA2 (<) +infix 4 <.+-- | The above type is a generalization for:+--+-- @+-- __(<.)__ :: 'Ord' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('<') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(<.) :: (Ord a, Functor f) => a -> f a -> f Bool+(<.) a b = fmap (a<) b++infix 4 .<+-- | The above type is a generalization for:+--+-- @+-- __(.<)__ :: 'Ord' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('<') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.<) :: (Ord a, Functor f) => f a -> a -> f Bool+(.<) a b = fmap (<b) a+ infix 4 .<=. -- | The above type is a generalization for: --@@ -1597,6 +1774,30 @@ (.<=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool (.<=.) = liftA2 (<=) +infix 4 .<=+-- | The above type is a generalization for:+--+-- @+-- __(.<=)__ :: 'Ord' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('GHC.TypeNats.<=') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.<=) :: (Ord a, Functor f) => f a -> a -> f Bool+(.<=) a b = fmap (<=b) a++infix 4 <=.+-- | The above type is a generalization for:+--+-- @+-- __(<=.)__ :: 'Ord' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('GHC.TypeNats.<=') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(<=.) :: (Ord a, Functor f) => a -> f a -> f Bool+(<=.) a b = fmap (a<=)b+ infix 4 .>. -- | The above type is a generalization for: --@@ -1608,6 +1809,30 @@ (.>.) :: (Ord a, Applicative f) => f a -> f a -> f Bool (.>.) = liftA2 (>) +infix 4 .>+-- | The above type is a generalization for:+--+-- @+-- __(.>)__ :: 'Ord' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('>') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.>) :: (Ord a, Functor f) => f a -> a -> f Bool+(.>) a b = fmap (>b) a++infix 4 >.+-- | The above type is a generalization for:+--+-- @+-- __(>.)__ :: 'Ord' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('>') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(>.) :: (Ord a, Functor f) => a -> f a -> f Bool+(>.) a b = fmap (a>) b+ infix 4 .>=. -- | The above type is a generalization for: --@@ -1619,6 +1844,30 @@ (.>=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool (.>=.) = liftA2 (>=) +infix 4 .>=+-- | The above type is a generalization for:+--+-- @+-- __(.>=)__ :: 'Ord' a => 'Clash.Signal.Signal' a -> a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('>=') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(.>=) :: (Ord a, Functor f) => f a -> a -> f Bool+(.>=) a b = fmap (>=b) a++infix 4 >=.+-- | The above type is a generalization for:+--+-- @+-- __(>=.)__ :: 'Ord' a => a -> 'Clash.Signal.Signal' a -> 'Clash.Signal.Signal' 'Bool'+-- @+--+-- It is a version of ('>=') that allows comparing a @'Clash.Signal.Signal' a@ with a constant+-- @a@ and returns a 'Clash.Signal.Signal' of 'Bool'+(>=.) :: (Ord a, Functor f) => a -> f a -> f Bool+(>=.) a b = fmap (a>=) b+ instance Fractional a => Fractional (Signal dom a) where   (/)          = liftA2 (/)   recip        = fmap recip@@ -1875,8 +2124,7 @@         return (out, next)    go inputRefs (dut inputs)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE signalAutomaton #-}+{-# OPAQUE signalAutomaton #-}  infiniteRefList :: a -> IO (Signal dom (IORef a)) infiniteRefList val = go

@@ -25,8 +25,7 @@   case knownDomain @dom of     SDomainConfiguration{sPeriod} ->       sPeriod--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE clockPeriod #-}+{-# OPAQUE clockPeriod #-} -- @NOINLINE: https://github.com/clash-lang/clash-compiler/issues/662  -- | Get 'ActiveEdge' from a KnownDomain context. Example usage:@@ -46,8 +45,7 @@   case knownDomain @dom of     SDomainConfiguration{sActiveEdge} ->       sActiveEdge--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE activeEdge #-}+{-# OPAQUE activeEdge #-} -- @NOINLINE: https://github.com/clash-lang/clash-compiler/issues/662  -- | Get 'ResetKind' from a KnownDomain context. Example usage:@@ -67,8 +65,7 @@   case knownDomain @dom of     SDomainConfiguration{sResetKind} ->       sResetKind--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE resetKind #-}+{-# OPAQUE resetKind #-} -- @NOINLINE: https://github.com/clash-lang/clash-compiler/issues/662  -- | Get 'InitBehavior' from a KnownDomain context. Example usage:@@ -88,8 +85,7 @@   case knownDomain @dom of     SDomainConfiguration{sInitBehavior} ->       sInitBehavior--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE initBehavior #-}+{-# OPAQUE initBehavior #-} -- @NOINLINE: https://github.com/clash-lang/clash-compiler/issues/662  -- | Get 'ResetPolarity' from a KnownDomain context. Example usage:@@ -109,8 +105,7 @@   case knownDomain @dom of     SDomainConfiguration{sResetPolarity} ->       sResetPolarity--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE resetPolarity #-}+{-# OPAQUE resetPolarity #-} -- @NOINLINE: https://github.com/clash-lang/clash-compiler/issues/662  -- | Like 'knownDomain but yields a 'VDomainConfiguration'. Should only be used

@@ -155,8 +155,7 @@ -- | Map of traces used by the non-internal trace and dumpvcd functions. traceMap# :: IORef TraceMap traceMap# = unsafePerformIO (newIORef Map.empty)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceMap# #-}+{-# OPAQUE traceMap# #-}  mkTrace   :: HasCallStack@@ -199,8 +198,7 @@       , signal)  where   width = snatToNum (SNat @(BitSize a))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceSignal# #-}+{-# OPAQUE traceSignal# #-}  -- | Trace a single vector signal: each element in the vector will show up as -- a different trace. If the trace name already exists, this function will emit@@ -226,8 +224,7 @@  where   trace' i s = traceSignal# traceMap period (name' i) s   name' i    = vecTraceName ++ "_" ++ show i--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceVecSignal# #-}+{-# OPAQUE traceVecSignal# #-}  -- | Trace a single signal. Will emit an error if a signal with the same name -- was previously registered.@@ -251,8 +248,7 @@     SDomainConfiguration{sPeriod} ->       unsafePerformIO $         traceSignal# traceMap# (snatToNum sPeriod) traceName signal--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceSignal #-}+{-# OPAQUE traceSignal #-} {-# ANN traceSignal hasBlackBox #-}  -- | Trace a single signal. Will emit an error if a signal with the same name@@ -273,8 +269,7 @@   -> Signal dom a traceSignal1 traceName signal =   unsafePerformIO (traceSignal# traceMap# 1 traceName signal)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceSignal1 #-}+{-# OPAQUE traceSignal1 #-} {-# ANN traceSignal1 hasBlackBox #-}  -- | Trace a single vector signal: each element in the vector will show up as@@ -301,8 +296,7 @@     SDomainConfiguration{sPeriod} ->       unsafePerformIO $         traceVecSignal# traceMap# (snatToNum sPeriod) traceName signal--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceVecSignal #-}+{-# OPAQUE traceVecSignal #-} {-# ANN traceVecSignal hasBlackBox #-}  -- | Trace a single vector signal: each element in the vector will show up as@@ -325,8 +319,7 @@   -> Signal dom (Vec (n+1) a) traceVecSignal1 traceName signal =   unsafePerformIO $ traceVecSignal# traceMap# 1 traceName signal--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE traceVecSignal1 #-}+{-# OPAQUE traceVecSignal1 #-} {-# ANN traceVecSignal1 hasBlackBox #-}  data VCDFile = VCDFile [DeclarationCommand] [SimulationCommand]

@@ -1,6 +1,6 @@ {-| Copyright  :  (C) 2013-2016, University of Twente,-                  2021,      QBayLogic B.V.,+                  2021-2025, QBayLogic B.V., License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com> @@ -113,7 +113,7 @@ import Control.Arrow              ((***), second) import Data.Bits                  (Bits (..), FiniteBits) import Data.Data                  (Data)-import Data.Default.Class         (Default (..))+import Data.Default               (Default (..)) import Data.Either                (isLeft) import Data.Kind                  (Type) import Text.Read                  (Read(..))@@ -126,15 +126,9 @@ import Language.Haskell.TH        (Q, appT, conT, litT, mkName,                                    numTyLit, sigE) import Language.Haskell.TH.Syntax (Lift(..))-#if MIN_VERSION_template_haskell(2,16,0) import Language.Haskell.TH.Compat-#endif-#if MIN_VERSION_template_haskell(2,17,0) import Language.Haskell.TH        (Quote) import qualified Language.Haskell.TH as TH-#else-import Language.Haskell.TH        (TExp, TypeQ)-#endif import Test.QuickCheck            (Arbitrary, CoArbitrary)  import Clash.Class.BitPack        (BitPack (..))@@ -558,15 +552,9 @@                           (decFixed (typeRep (asRepProxy f))                                     (natVal (asIntProxy f))                                     (natVal f))-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif -#if MIN_VERSION_template_haskell(2,17,0) decFixed :: Quote m => TypeRep -> Integer -> Integer -> m TH.Type-#else-decFixed :: TypeRep -> Integer -> Integer -> TypeQ-#endif decFixed r i f = do   foldl appT (conT ''Fixed) [ conT (mkName (show r))                             , litT (numTyLit i)@@ -715,11 +703,7 @@      , Bounded (rep size)      , Integral (rep size) )   => Double-#if MIN_VERSION_template_haskell(2,17,0)   -> TH.Code Q (Fixed rep int frac)-#else-  -> Q (TExp (Fixed rep int frac))-#endif fLit a = [|| Fixed (fromInteger sat) ||]   where     rMax      = toInteger (maxBound :: rep size)

@@ -1,5 +1,6 @@ {-| Copyright  :  (C) 2013-2016, University of Twente+                  2025     , QBayLogic B.V. License    :  BSD2 (see the file LICENSE) Maintainer :  Christiaan Baaij <christiaan.baaij@gmail.com> -}@@ -18,7 +19,6 @@ import GHC.TypeLits (KnownNat, type (^)) import GHC.TypeLits.Extra (CLog) -- documentation only -import Clash.Promoted.Nat (SNat (..), pow2SNat) import Clash.Sized.Internal.BitVector (BitVector) import Clash.Sized.Internal.Index 

@@ -2,7 +2,7 @@ Copyright  :  (C) 2013-2016, University of Twente,                   2019     , Gergő Érdi                   2016-2019, Myrtle Software Ltd,-                  2021-2024, QBayLogic B.V.+                  2021-2025, QBayLogic B.V.                   2023     , Nadia Chambers License    :  BSD2 (see the file LICENSE) Maintainer :  QBayLogic B.V. <devops@qbaylogic.com>@@ -140,7 +140,7 @@ import Control.Lens               (Index, Ixed (..), IxValue) import Data.Bits                  (Bits (..), FiniteBits (..)) import Data.Data                  (Data)-import Data.Default.Class         (Default (..))+import Data.Default               (Default (..)) import Data.Either                (isLeft) import Data.Proxy                 (Proxy (..)) import Data.Typeable              (Typeable, typeOf)@@ -149,41 +149,23 @@ import Numeric                    (readOct, readHex) import GHC.Exts   (Word#, Word (W#), eqWord#, int2Word#, isTrue#, uncheckedShiftRL#)-#if MIN_VERSION_base(4,15,0) import GHC.Exts (minusWord#, gtWord#, word2Int#, dataToTag#) import GHC.Num.BigNat (bigNatShiftR#, bigNatToWord) import GHC.Num.Integer (integerFromNatural, integerToNatural) import GHC.Num.Natural   (Natural (..), naturalFromWord, naturalShiftL, naturalShiftR, naturalToWord)-#else-import GHC.Exts ((>#), dataToTag#)-import qualified GHC.Exts-import GHC.Integer.GMP.Internals  (Integer (..), bigNatToWord, shiftRBigNat)-import GHC.Natural-  (Natural (..), naturalFromInteger, wordToNatural)-#endif import GHC.Natural                (naturalToInteger) import GHC.Stack                  (withFrozenCallStack) import GHC.TypeLits               (KnownNat, Nat, type (+), type (-))-#if MIN_VERSION_base(4,15,0) import GHC.TypeNats               (natVal)-#else-import GHC.TypeLits               (natVal)-#endif import GHC.TypeLits.Extra         (Max) import Language.Haskell.TH   (Lit (..), ExpQ, Type(ConT, AppT, LitT), Exp(VarE, AppE, SigE, LitE),    TyLit(NumTyLit), Pat, Q, appT, conT, litE, litP, litT, mkName, numTyLit,    sigE, tupE, tupP, varP) import Language.Haskell.TH.Syntax (Lift(..))-#if MIN_VERSION_template_haskell(2,16,0) import Language.Haskell.TH.Compat-#endif-#if MIN_VERSION_template_haskell(2,17,0) import Language.Haskell.TH        (Quote)-#else-import Language.Haskell.TH        (TypeQ)-#endif import System.IO.Unsafe               (unsafeDupablePerformIO) import Test.QuickCheck.Arbitrary  (Arbitrary (..), CoArbitrary (..),                                    arbitraryBoundedIntegral,@@ -267,15 +249,13 @@  -- * Constructions -- ** Initialisation--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE high #-}+{-# OPAQUE high #-} {-# ANN high hasBlackBox #-} -- | logic '1' high :: Bit high = Bit 0 1 --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE low #-}+{-# OPAQUE low #-} {-# ANN low hasBlackBox #-} -- | logic '0' low :: Bit@@ -305,9 +285,7 @@ instance Lift Bit where   lift (Bit m i) = [| fromInteger## $(litE (WordPrimL (toInteger m))) i |]   {-# NOINLINE lift #-}-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif  instance Eq Bit where   (==) = eq##@@ -315,14 +293,12 @@  eq## :: Bit -> Bit -> Bool eq## b1 b2 = eq# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE eq## #-}+{-# OPAQUE eq## #-} {-# ANN eq## hasBlackBox #-}  neq## :: Bit -> Bit -> Bool neq## b1 b2 = neq# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE neq## #-}+{-# OPAQUE neq## #-} {-# ANN neq## hasBlackBox #-}  instance Ord Bit where@@ -333,20 +309,16 @@  lt##,ge##,gt##,le## :: Bit -> Bit -> Bool lt## b1 b2 = lt# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE lt## #-}+{-# OPAQUE lt## #-} {-# ANN lt## hasBlackBox #-} ge## b1 b2 = ge# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE ge## #-}+{-# OPAQUE ge## #-} {-# ANN ge## hasBlackBox #-} gt## b1 b2 = gt# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE gt## #-}+{-# OPAQUE gt## #-} {-# ANN gt## hasBlackBox #-} le## b1 b2 = le# (pack# b1) (pack# b2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE le## #-}+{-# OPAQUE le## #-} {-# ANN le## hasBlackBox #-}  instance Enum Bit where@@ -355,8 +327,7 @@  toEnum## :: Int -> Bit toEnum## = fromInteger## 0## . toInteger--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE toEnum## #-}+{-# OPAQUE toEnum## #-} {-# ANN toEnum## hasBlackBox #-}  instance Bounded Bit where@@ -370,15 +341,14 @@   (+)         = xor##   (-)         = xor##   (*)         = and##-  negate      = complement##+  negate      = id   abs         = id   signum b    = b   fromInteger = fromInteger## 0##  fromInteger## :: Word# -> Integer -> Bit fromInteger## m# i = Bit ((W# m#) `mod` 2) (fromInteger i `mod` 2)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE fromInteger## #-}+{-# OPAQUE fromInteger## #-} {-# ANN fromInteger## hasBlackBox #-}  instance Real Bit where@@ -423,52 +393,37 @@ and##, or##, xor## :: Bit -> Bit -> Bit and## (Bit m1 v1) (Bit m2 v2) = Bit mask (v1 .&. v2 .&. complement mask)   where mask = (m1.&.v2 .|. m1.&.m2 .|. m2.&.v1)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE and## #-}+{-# OPAQUE and## #-} {-# ANN and## hasBlackBox #-}  or## (Bit m1 v1) (Bit m2 v2) = Bit mask ((v1 .|. v2) .&. complement mask)   where mask = m1 .&. complement v2 .|.  m1.&.m2  .|.  m2 .&. complement v1--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE or## #-}+{-# OPAQUE or## #-} {-# ANN or## hasBlackBox #-}  xor## (Bit m1 v1) (Bit m2 v2) = Bit mask ((v1 `xor` v2) .&. complement mask)   where mask = m1 .|. m2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE xor## #-}+{-# OPAQUE xor## #-} {-# ANN xor## hasBlackBox #-}  complement## :: Bit -> Bit complement## (Bit m v) = Bit m (complementB v .&. complementB m)   where complementB (W# b#) = W# (int2Word# (eqWord# b# 0##))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE complement## #-}+{-# OPAQUE complement## #-} {-# ANN complement## hasBlackBox #-}  -- *** BitPack pack# :: Bit -> BitVector 1-#if MIN_VERSION_base(4,15,0) pack# (Bit (W# m) (W# b)) = BV (NS m) (NS b)-#else-pack# (Bit (W# m) (W# b)) = BV (NatS# m) (NatS# b)-#endif--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE pack# #-}+{-# OPAQUE pack# #-} {-# ANN pack# hasBlackBox #-}  unpack# :: BitVector 1 -> Bit unpack# (BV m b) = Bit (go m) (go b)  where-#if MIN_VERSION_base(4,15,0)   go (NS w) = W# w   go (NB w) = bigNatToWord w-#else-  go (NatS# w) = W# w-  go (NatJ# w) = W# (bigNatToWord w)-#endif--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE unpack# #-}+{-# OPAQUE unpack# #-} {-# ANN unpack# hasBlackBox #-}  -- * Instances@@ -635,15 +590,13 @@   (==) = eq#   (/=) = neq# --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE eq# #-}+{-# OPAQUE eq# #-} {-# ANN eq# hasBlackBox #-} eq# :: KnownNat n => BitVector n -> BitVector n -> Bool eq# (BV 0 v1) (BV 0 v2 ) = v1 == v2 eq# bv1 bv2 = undefErrorI "==" bv1 bv2 --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE neq# #-}+{-# OPAQUE neq# #-} {-# ANN neq# hasBlackBox #-} neq# :: KnownNat n => BitVector n -> BitVector n -> Bool neq# (BV 0 v1) (BV 0 v2) = v1 /= v2@@ -656,23 +609,19 @@   (<=) = le#  lt#,ge#,gt#,le# :: KnownNat n => BitVector n -> BitVector n -> Bool--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE lt# #-}+{-# OPAQUE lt# #-} {-# ANN lt# hasBlackBox #-} lt# (BV 0 n) (BV 0 m) = n < m lt# bv1 bv2 = undefErrorI "<" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE ge# #-}+{-# OPAQUE ge# #-} {-# ANN ge# hasBlackBox #-} ge# (BV 0 n) (BV 0 m) = n >= m ge# bv1 bv2 = undefErrorI ">=" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE gt# #-}+{-# OPAQUE gt# #-} {-# ANN gt# hasBlackBox #-} gt# (BV 0 n) (BV 0 m) = n > m gt# bv1 bv2 = undefErrorI ">" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE le# #-}+{-# OPAQUE le# #-} {-# ANN le# hasBlackBox #-} le# (BV 0 n) (BV 0 m) = n <= m le#  bv1 bv2 = undefErrorI "<=" bv1 bv2@@ -691,26 +640,19 @@  toEnum# :: forall n. KnownNat n => Int -> BitVector n toEnum# = fromInteger# 0 . toInteger--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE toEnum# #-}+{-# OPAQUE toEnum# #-} {-# ANN toEnum# hasBlackBox #-}  fromEnum# :: forall n. KnownNat n => BitVector n -> Int fromEnum# = fromEnum . toInteger#--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE fromEnum# #-}+{-# OPAQUE fromEnum# #-} {-# ANN fromEnum# hasBlackBox #-}  enumFrom# :: forall n. KnownNat n => BitVector n -> [BitVector n] enumFrom# (BV 0 x) = map (BV 0 . (`mod` m)) [x .. unsafeToNatural (maxBound :: BitVector n)]-#if MIN_VERSION_base(4,15,0)   where m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  where m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif enumFrom# bv = undefErrorU "enumFrom" bv--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE enumFrom# #-}+{-# OPAQUE enumFrom# #-}  enumFromThen#   :: forall n@@ -723,14 +665,9 @@  where   bound = if x <= y then maxBound else minBound :: BitVector n   toBvs = map (BV 0 . (`mod` m))-#if MIN_VERSION_base(4,15,0)   m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif enumFromThen# bv1 bv2 = undefErrorP "enumFromThen" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE enumFromThen# #-}+{-# OPAQUE enumFromThen# #-}  enumFromTo#   :: forall n@@ -739,14 +676,9 @@   -> BitVector n   -> [BitVector n] enumFromTo# (BV 0 x) (BV 0 y) = map (BV 0 . (`mod` m)) [x .. y]-#if MIN_VERSION_base(4,15,0)   where m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  where m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif enumFromTo# bv1 bv2 = undefErrorP "enumFromTo" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE enumFromTo# #-}+{-# OPAQUE enumFromTo# #-}  enumFromThenTo#   :: forall n@@ -756,14 +688,9 @@   -> BitVector n   -> [BitVector n] enumFromThenTo# (BV 0 x1) (BV 0 x2) (BV 0 y) = map (BV 0 . (`mod` m)) [x1, x2 .. y]-#if MIN_VERSION_base(4,15,0)   where m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  where m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif enumFromThenTo# bv1 bv2 bv3 = undefErrorP3 "enumFromTo" bv1 bv2 bv3--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE enumFromThenTo# #-}+{-# OPAQUE enumFromThenTo# #-}   instance KnownNat n => Bounded (BitVector n) where@@ -772,14 +699,12 @@  minBound# :: BitVector n minBound# = BV 0 0--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE minBound# #-}+{-# OPAQUE minBound# #-} {-# ANN minBound# hasBlackBox #-}  maxBound# :: forall n. KnownNat n => BitVector n maxBound# = let m = 1 `shiftL` natToNum @n in BV 0 (m-1)--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE maxBound# #-}+{-# OPAQUE maxBound# #-} {-# ANN maxBound# hasBlackBox #-}  -- | __NB__: 'fromInteger'/'fromIntegral' can cause unexpected truncation, as@@ -795,50 +720,34 @@   fromInteger = fromInteger# 0  (+#),(-#),(*#) :: forall n . KnownNat n => BitVector n -> BitVector n -> BitVector n--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE (+#) #-}+{-# OPAQUE (+#) #-} {-# ANN (+#) hasBlackBox #-} (+#) = go   where     go (BV 0 i) (BV 0 j) = BV 0 (addMod m i j)     go bv1 bv2 = undefErrorI "+" bv1 bv2 -#if MIN_VERSION_base(4,15,0)     m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-    m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE (-#) #-}+{-# OPAQUE (-#) #-} {-# ANN (-#) hasBlackBox #-} (-#) = go   where     go (BV 0 i) (BV 0 j) = BV 0 (subMod m i j)     go bv1 bv2 = undefErrorI "-" bv1 bv2 -#if MIN_VERSION_base(4,15,0)     m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-    m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE (*#) #-}+{-# OPAQUE (*#) #-} {-# ANN (*#) hasBlackBox #-} (*#) = go  where   go (BV 0 i) (BV 0 j) = BV 0 (mulMod2 m i j)   go bv1 bv2 = undefErrorI "*" bv1 bv2 -#if MIN_VERSION_base(4,15,0)   m = (1 `naturalShiftL` naturalToWord (natVal (Proxy @n))) - 1-#else-  m = (1 `shiftL` fromInteger (natVal (Proxy @n))) - 1-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE negate# #-}+{-# OPAQUE negate# #-} {-# ANN negate# hasBlackBox #-} negate# :: forall n . KnownNat n => BitVector n -> BitVector n negate# = go@@ -846,27 +755,16 @@   go (BV 0 i) = BV 0 (negateMod m i)   go bv = undefErrorU "negate" bv -#if MIN_VERSION_base(4,15,0)   m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE fromInteger# #-}+{-# OPAQUE fromInteger# #-} {-# ANN fromInteger# hasBlackBox #-} fromInteger# :: KnownNat n => Natural -> Integer -> BitVector n fromInteger# m i = sz `seq` mx   where-#if MIN_VERSION_base(4,15,0)     mx = BV (m `mod` sz)             (integerToNatural (i `mod` integerFromNatural sz))     sz  = 1 `naturalShiftL` naturalToWord (natVal mx)-#else-    mx = BV (m `mod` naturalFromInteger sz)-            (naturalFromInteger (i `mod` sz))-    sz  = 1 `shiftL` fromInteger (natVal mx) :: Integer-#endif  instance (KnownNat m, KnownNat n) => ExtendingNum (BitVector m) (BitVector n) where   type AResult (BitVector m) (BitVector n) = BitVector (Max m n + 1)@@ -875,15 +773,13 @@   type MResult (BitVector m) (BitVector n) = BitVector (m + n)   mul = times# --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE plus# #-}+{-# OPAQUE plus# #-} {-# ANN plus# hasBlackBox #-} plus# :: (KnownNat m, KnownNat n) => BitVector m -> BitVector n -> BitVector (Max m n + 1) plus# (BV 0 a) (BV 0 b) = BV 0 (a + b) plus# bv1 bv2 = undefErrorP "add" bv1 bv2 --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE minus# #-}+{-# OPAQUE minus# #-} {-# ANN minus# hasBlackBox #-} minus# :: forall m n . (KnownNat m, KnownNat n) => BitVector m -> BitVector n                                                 -> BitVector (Max m n + 1)@@ -892,14 +788,9 @@   go (BV 0 a) (BV 0 b) = BV 0 (subMod m a b)   go bv1 bv2 = undefErrorP "sub" bv1 bv2 -#if MIN_VERSION_base(4,15,0)   m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @(Max m n + 1)))-#else-  m = 1 `shiftL` fromInteger (natVal (Proxy @(Max m n + 1)))-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE times# #-}+{-# OPAQUE times# #-} {-# ANN times# hasBlackBox #-} times# :: (KnownNat m, KnownNat n) => BitVector m -> BitVector n -> BitVector (m + n) times# (BV 0 a) (BV 0 b) = BV 0 (a * b)@@ -921,24 +812,25 @@   toInteger   = toInteger#  quot#,rem# :: KnownNat n => BitVector n -> BitVector n -> BitVector n--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE quot# #-}+{-# OPAQUE quot# #-} {-# ANN quot# hasBlackBox #-} quot# (BV 0 i) (BV 0 j) = BV 0 (i `quot` j) quot# bv1 bv2 = undefErrorP "quot" bv1 bv2--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE rem# #-}+{-# OPAQUE rem# #-} {-# ANN rem# hasBlackBox #-} rem# (BV 0 i) (BV 0 j) = BV 0 (i `rem` j) rem# bv1 bv2 = undefErrorP "rem" bv1 bv2 --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE toInteger# #-}+{-# OPAQUE toInteger# #-} {-# ANN toInteger# hasBlackBox #-} toInteger# :: KnownNat n => BitVector n -> Integer toInteger# (BV 0 i) = naturalToInteger i toInteger# bv = undefErrorU "toInteger" bv +-- | @'shiftR' a n@:+--+-- * Returns 0 if @n >= 'bitSize' a@+-- * 'Clash.XException.XException' if @n < 0@ instance KnownNat n => Bits (BitVector n) where   (.&.)             = and#   (.|.)             = or#@@ -972,8 +864,7 @@ countTrailingZerosBV = V.foldl (\l r -> if eq## r low then 1 + l else 0) 0 . V.bv2v {-# INLINE countTrailingZerosBV #-} --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE reduceAnd# #-}+{-# OPAQUE reduceAnd# #-} {-# ANN reduceAnd# hasBlackBox #-} reduceAnd# :: KnownNat n => BitVector n -> Bit reduceAnd# bv@(BV 0 i) = Bit 0 (W# (int2Word# (dataToTag# check)))@@ -992,8 +883,7 @@     sz    = natVal bv     maxI  = (2 ^ sz) - 1 --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE reduceOr# #-}+{-# OPAQUE reduceOr# #-} {-# ANN reduceOr# hasBlackBox #-} reduceOr# :: KnownNat n => BitVector n -> Bit reduceOr# (BV 0 i) = Bit 0 (W# (int2Word# (dataToTag# check)))@@ -1005,8 +895,7 @@   complementN = complementMod $ natVal bv   defI = i .&. (complementN m) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE reduceXor# #-}+{-# OPAQUE reduceXor# #-} {-# ANN reduceXor# hasBlackBox #-} reduceXor# :: KnownNat n => BitVector n -> Bit reduceXor# (BV 0 i) = Bit 0 (fromIntegral (popCount i `mod` 2))@@ -1017,29 +906,18 @@  -- * Accessors -- ** Length information--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE size# #-}+{-# OPAQUE size# #-} {-# ANN size# hasBlackBox #-} size# :: KnownNat n => BitVector n -> Int-#if MIN_VERSION_base(4,15,0) size# bv = fromIntegral (natVal bv)-#else-size# bv = fromInteger (natVal bv)-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE maxIndex# #-}+{-# OPAQUE maxIndex# #-} {-# ANN maxIndex# hasBlackBox #-} maxIndex# :: KnownNat n => BitVector n -> Int-#if MIN_VERSION_base(4,15,0) maxIndex# bv = fromIntegral (natVal bv) - 1-#else-maxIndex# bv = fromInteger (natVal bv) - 1-#endif  -- ** Indexing--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE index# #-}+{-# OPAQUE index# #-} {-# ANN index# hasBlackBox #-} index# :: KnownNat n => BitVector n -> Int -> Bit index# bv@(BV m v) i@@ -1047,19 +925,14 @@                              (W# (int2Word# (dataToTag# (testBit v i))))     | otherwise        = err   where-#if MIN_VERSION_base(4,15,0)     sz  = fromIntegral (natVal bv)-#else-    sz  = fromInteger (natVal bv)-#endif     err = error $ concat [ "(!): "                          , show i                          , " is out of range "                          , formatRange 0 (sz - 1)                          ] --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE msb# #-}+{-# OPAQUE msb# #-} {-# ANN msb# hasBlackBox #-} -- | MSB msb# :: forall n . KnownNat n => BitVector n -> Bit@@ -1067,7 +940,6 @@   = Bit (msbN m)         (msbN v)  where-#if MIN_VERSION_base(4,15,0)   !(NS i#) = natVal (Proxy @n)    msbN (NS w) =@@ -1075,26 +947,15 @@     then W# 0##     else W# (w `uncheckedShiftRL#` (word2Int# (i# `minusWord#` 1##)))   msbN (NB bn) = bigNatToWord (bigNatShiftR# bn (i# `minusWord#` 1##))-#else-  !(S# i#) = natVal (Proxy @n) -  msbN (NatS# w) =-    if isTrue# (i# ># WORD_SIZE_IN_BITS#)-    then W# 0##-    else W# (w `uncheckedShiftRL#` (i# GHC.Exts.-# 1#))-  msbN (NatJ# bn) = W# (bigNatToWord (shiftRBigNat bn (i# GHC.Exts.-# 1#)))-#endif---- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE lsb# #-}+{-# OPAQUE lsb# #-} {-# ANN lsb# hasBlackBox #-} -- | LSB lsb# :: BitVector n -> Bit lsb# (BV m v) = Bit (W# (int2Word# (dataToTag# (testBit m 0))))                     (W# (int2Word# (dataToTag# (testBit v 0)))) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE slice# #-}+{-# OPAQUE slice# #-} {-# ANN slice# hasBlackBox #-} slice# :: BitVector (m + 1 + i) -> SNat m -> SNat n -> BitVector (m + 1 - n) slice# (BV msk i) m n = BV (shiftR (msk .&. mask) n')@@ -1108,50 +969,33 @@ -- * Constructions  -- ** Concatenation--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE (++#) #-}+{-# OPAQUE (++#) #-} {-# ANN (++#) hasBlackBox #-} -- | Concatenate two 'BitVector's (++#) :: KnownNat m => BitVector n -> BitVector m -> BitVector (n + m) (BV m1 v1) ++# bv2@(BV m2 v2) = BV (m1' .|. m2) (v1' .|. v2)   where-#if MIN_VERSION_base(4,15,0)     size2 = fromIntegral (natVal bv2)     v1' = naturalShiftL v1 size2     m1' = naturalShiftL m1 size2-#else-    size2 = fromInteger (natVal bv2)-    v1' = shiftL v1 size2-    m1' = shiftL m1 size2-#endif  -- * Modifying BitVectors--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE replaceBit# #-}+{-# OPAQUE replaceBit# #-} {-# ANN replaceBit# hasBlackBox #-} replaceBit# :: KnownNat n => BitVector n -> Int -> Bit -> BitVector n replaceBit# bv@(BV m v) i (Bit mb b)-#if MIN_VERSION_base(4,15,0)     | i >= 0 && i < sz = BV (clearBit m i .|. (naturalFromWord mb `shiftL` i))-#else-    | i >= 0 && i < sz = BV (clearBit m i .|. (wordToNatural mb `shiftL` i))-#endif                             (if testBit b 0 && mb == 0 then setBit v i else clearBit v i)     | otherwise        = err   where-#if MIN_VERSION_base(4,15,0)     sz   = fromIntegral (natVal bv)-#else-    sz   = fromInteger (natVal bv)-#endif     err  = error $ concat [ "replaceBit: "                           , show i                           , " is out of range "                           , formatRange 0 (sz - 1)                           ] --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE setSlice# #-}+{-# OPAQUE setSlice# #-} {-# ANN setSlice# hasBlackBox #-} setSlice#   :: forall m i n@@ -1173,8 +1017,7 @@  where   complementN = complementMod (natVal (Proxy @(m + 1 + i))) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE split# #-}+{-# OPAQUE split# #-} {-# ANN split# hasBlackBox #-} split#   :: forall n m@@ -1182,26 +1025,16 @@   => BitVector (m + n)   -> (BitVector m, BitVector n) split# (BV m i) =-#if MIN_VERSION_base(4,15,0)   let n     = naturalToWord (natVal (Proxy @n))       mask  = maskMod (natVal (Proxy @n))       r     = mask i       rMask = mask m       l     = i `naturalShiftR` n       lMask = m `naturalShiftR` n-#else-  let n     = fromInteger (natVal (Proxy @n))-      mask  = maskMod (natVal (Proxy @n))-      r     = mask i-      rMask = mask m-      l     = i `shiftR` n-      lMask = m `shiftR` n-#endif   in  (BV lMask l, BV rMask r)  and#, or#, xor# :: forall n . KnownNat n => BitVector n -> BitVector n -> BitVector n--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE and# #-}+{-# OPAQUE and# #-} {-# ANN and# hasBlackBox #-} and# =   \(BV m1 v1) (BV m2 v2) ->@@ -1210,8 +1043,7 @@   where     complementN = complementMod (natVal (Proxy @n)) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE or# #-}+{-# OPAQUE or# #-} {-# ANN or# hasBlackBox #-} or# =   \(BV m1 v1) (BV m2 v2) ->@@ -1220,8 +1052,7 @@   where     complementN = complementMod (natVal (Proxy @n)) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE xor# #-}+{-# OPAQUE xor# #-} {-# ANN xor# hasBlackBox #-} xor# =   \(BV m1 v1) (BV m2 v2) ->@@ -1230,8 +1061,7 @@   where     complementN = complementMod (natVal (Proxy @n)) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE complement# #-}+{-# OPAQUE complement# #-} {-# ANN complement# hasBlackBox #-} complement# :: forall n . KnownNat n => BitVector n -> BitVector n complement# = \(BV m v) -> BV m (complementN v .&. complementN m)@@ -1240,8 +1070,7 @@ shiftL#, shiftR#, rotateL#, rotateR#   :: forall n . KnownNat n => BitVector n -> Int -> BitVector n --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE shiftL# #-}+{-# OPAQUE shiftL# #-} {-# ANN shiftL# hasBlackBox #-} shiftL# = \(BV msk v) i ->   if | i < 0@@ -1251,29 +1080,23 @@      | otherwise      -> BV ((shiftL msk i) `mod` m) ((shiftL v i) `mod` m)  where-#if MIN_VERSION_base(4,15,0)   sz = naturalToWord (natVal (Proxy @n))   m = 1 `naturalShiftL` sz-#else-  sz = fromInteger (natVal (Proxy @n))-  m = 1 `shiftL` sz-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE shiftR# #-}+{-# OPAQUE shiftR# #-} {-# ANN shiftR# hasBlackBox #-} shiftR# (BV m v) i   | i < 0     = error               $ "'shiftR' undefined for negative number: " ++ show i   | otherwise = BV (shiftR m i) (shiftR v i) --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE rotateL# #-}+{-# OPAQUE rotateL# #-} {-# ANN rotateL# hasBlackBox #-} rotateL# =   \(BV msk v) b ->-    if b >= 0 then-#if MIN_VERSION_base(4,15,0)+    if sz == 0 then+      BV msk v+    else if b >= 0 then       let vl    = naturalShiftL v b'           vr    = naturalShiftR v b'' @@ -1281,59 +1104,33 @@           mr    = naturalShiftR msk b''            b'   = fromIntegral b `mod` sz-#else-      let vl    = shiftL v b'-          vr    = shiftR v b''--          ml    = shiftL msk b'-          mr    = shiftR msk b''--          b'   = b `mod` sz-#endif           b''  = sz - b'       in  BV ((ml .|. mr) `mod` m) ((vl .|. vr) `mod` m)     else       error $ "'rotateL' undefined for negative number: " ++ show b  where-#if MIN_VERSION_base(4,15,0)   sz = naturalToWord (natVal (Proxy @n))   m  = 1 `naturalShiftL` sz-#else-  sz = fromInteger (natVal (Proxy @n)) :: Int-  m  = 1 `shiftL` sz-#endif --- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE rotateR# #-}+{-# OPAQUE rotateR# #-} {-# ANN rotateR# hasBlackBox #-} rotateR# =   \(BV msk v) b ->-    if b >= 0 then-#if MIN_VERSION_base(4,15,0)+    if sz == 0 then+      BV msk v+    else if b >= 0 then       let vl   = naturalShiftR v b'           vr   = naturalShiftL v b''           ml   = naturalShiftR msk b'           mr   = naturalShiftL msk b''           b'   = fromIntegral b `mod` sz-#else-      let vl   = shiftR v b'-          vr   = shiftL v b''-          ml   = shiftR msk b'-          mr   = shiftL msk b''-          b'   = b `mod` sz-#endif           b''  = sz - b'       in  BV ((ml .|. mr) `mod` m) ((vl .|. vr) `mod` m)     else       error $ "'rotateR' undefined for negative number: " ++ show b  where-#if MIN_VERSION_base(4,15,0)   sz = naturalToWord (natVal (Proxy @n))   m  = 1 `naturalShiftL` sz-#else-  sz = fromInteger (natVal (Proxy @n)) :: Int-  m  = 1 `shiftL` sz-#endif  popCountBV :: forall n . KnownNat n => BitVector (n+1) -> I.Index (n+2) popCountBV bv =@@ -1355,29 +1152,17 @@  truncateB# :: forall a b . KnownNat a => BitVector (a + b) -> BitVector a truncateB# = \(BV msk i) -> BV (msk `mod` m) (i `mod` m)-#if MIN_VERSION_base(4,15,0)   where m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @a))-#else-  where m = 1 `shiftL` fromInteger (natVal (Proxy @a))-#endif--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE truncateB# #-}+{-# OPAQUE truncateB# #-} {-# ANN truncateB# hasBlackBox #-}  instance KnownNat n => Lift (BitVector n) where   lift bv@(BV m i) = sigE [| fromInteger# m $(litE (IntegerL (toInteger i))) |] (decBitVector (natVal bv))   {-# NOINLINE lift #-}-#if MIN_VERSION_template_haskell(2,16,0)   liftTyped = liftTypedFromUntyped-#endif -#if MIN_VERSION_template_haskell(2,17,0) decBitVector :: Quote m => Natural -> m Type decBitVector n = appT (conT ''BitVector) (litT $ numTyLit (integerFromNatural n))-#else-decBitVector :: Integer -> TypeQ-decBitVector n = appT (conT ''BitVector) (litT $ numTyLit n)-#endif  instance KnownNat n => SaturatingNum (BitVector n) where   satAdd SatWrap a b = a +# b@@ -1499,21 +1284,15 @@   where     ty = typeOf res     res = undefError (show ty ++ ".unpack") [bv]--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE checkUnpackUndef #-}+{-# OPAQUE checkUnpackUndef #-} {-# ANN checkUnpackUndef hasBlackBox #-}  -- | Create a BitVector with all its bits undefined undefined# :: forall n . KnownNat n => BitVector n undefined# =-#if MIN_VERSION_base(4,15,0)   let m = 1 `naturalShiftL` naturalToWord (natVal (Proxy @n))-#else-  let m = 1 `shiftL` fromInteger (natVal (Proxy @n))-#endif   in  BV (m-1) 0--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE undefined# #-}+{-# OPAQUE undefined# #-} {-# ANN undefined# hasBlackBox #-}  -- | Check if one BitVector is similar to another, interpreting undefined bits@@ -1542,8 +1321,7 @@     in  e' == c' && e' == c''  where   complementN = complementMod (natVal (Proxy @n))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE isLike# #-}+{-# OPAQUE isLike# #-}  fromBits :: [Bit] -> Integer fromBits = L.foldl (\v b -> v `shiftL` 1 .|. fromIntegral b) 0@@ -1613,6 +1391,5 @@ xToBV x =   unsafeDupablePerformIO (catch (evaluate x)                                 (\(XException _) -> return undefined#))--- See: https://github.com/clash-lang/clash-compiler/pull/2511-{-# CLASH_OPAQUE xToBV #-}+{-# OPAQUE xToBV #-} {-# ANN xToBV hasBlackBox #-}