Add own version of OverridingBool

Fixes #2754

clash-ghc/src-bin-8.10/Clash/GHCi/UI.hs

@@ -150,6 +150,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 
 import           Clash.GHC.PartialEval
@@ -2191,7 +2192,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-bin-9.0/Clash/GHCi/UI.hs

@@ -153,6 +153,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 import           Clash.GHC.Evaluator
 import           Clash.GHC.GenerateBindings
@@ -2230,7 +2231,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-bin-9.2/Clash/GHCi/UI.hs

@@ -166,6 +166,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 import           Clash.GHC.Evaluator
 import           Clash.GHC.GenerateBindings
@@ -2307,7 +2308,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-bin-9.4/Clash/GHCi/UI.hs

@@ -173,6 +173,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 import           Clash.GHC.Evaluator
 import           Clash.GHC.GenerateBindings
@@ -2391,7 +2392,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-bin-9.6/Clash/GHCi/UI.hs

@@ -176,6 +176,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 import           Clash.GHC.Evaluator
 import           Clash.GHC.GenerateBindings
@@ -2412,7 +2413,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-bin-9.8/Clash/GHCi/UI.hs

@@ -178,6 +178,7 @@ import           Clash.Backend.SystemVerilog (SystemVerilogState)
 import           Clash.Backend.VHDL (VHDLState)
 import           Clash.Backend.Verilog (VerilogState)
 import qualified Clash.Driver
+import           Clash.Driver.Bool (fromGhcOverridingBool)
 import           Clash.Driver.Types (ClashOpts(..), ClashEnv(..), ClashDesign(..))
 import           Clash.GHC.Evaluator
 import           Clash.GHC.GenerateBindings
@@ -2413,7 +2414,7 @@ makeHDL Proxy startAction optsRef srcs = do
   dflags <- GHC.getSessionDynFlags
   liftIO $ do startTime <- Clock.getCurrentTime
               opts0  <- readIORef optsRef
-              let opts1  = opts0 { opt_color = useColor dflags }
+              let opts1  = opts0 { opt_color = fromGhcOverridingBool (useColor dflags) }
               let iw     = opt_intWidth opts1
                   hdl    = hdlKind backend
                   -- determine whether `-outputdir` was used

clash-ghc/src-ghc/Clash/GHC/GenerateBindings.hs

@@ -88,6 +88,7 @@ import           Clash.Core.VarEnv
 import qualified Clash.Data.UniqMap as UniqMap
 import           Clash.Debug             (traceIf)
 import           Clash.Driver            (compilePrimitive)
+import           Clash.Driver.Bool       (toGhcOverridingBool)
 import           Clash.Driver.Types      (BindingMap, Binding(..), IsPrim(..), ClashEnv(..), ClashDesign(..), ClashOpts(..))
 import           Clash.GHC.GHC2Core
   (C2C, GHC2CoreState, GHC2CoreEnv (..), tyConMap, coreToId, coreToName, coreToTerm,
@@ -133,7 +134,7 @@ generateBindings opts startAction primDirs importDirs dbs hdl modName dflagsM =
    , partitionEithers -> (unresolvedPrims, pFP)
    , customBitRepresentations
    , primGuards
-   , domainConfs ) <- loadModules startAction (opt_color opts) hdl modName dflagsM importDirs
+   , domainConfs ) <- loadModules startAction (toGhcOverridingBool (opt_color opts)) hdl modName dflagsM importDirs
   startTime <- Clock.getCurrentTime
   primMapR <- generatePrimMap unresolvedPrims primGuards (concat [pFP, primDirs, importDirs])
   tdir <- maybe ghcLibDir (pure . GHC.topDir) dflagsM

clash-lib/clash-lib.cabal

@@ -241,6 +241,7 @@ Library
                       Clash.Debug
 
                       Clash.Driver
+                      Clash.Driver.Bool
                       Clash.Driver.BrokenGhcs
                       Clash.Driver.Manifest
                       Clash.Driver.Types

clash-lib/src/Clash/Driver/Bool.hs

@@ -0,0 +1,34 @@
+{-|
+  Copyright   :  (C) 2024, Martijn Bastiaan
+  License     :  BSD2 (see the file LICENSE)
+  Maintainer  :  QBayLogic B.V. <[email protected]>
+-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE DeriveAnyClass #-}
+
+module Clash.Driver.Bool where
+
+import Control.DeepSeq (NFData)
+import Data.Hashable (Hashable)
+import GHC.Generics (Generic)
+
+#if MIN_VERSION_ghc(9,4,0)
+import qualified GHC.Data.Bool as Ghc
+#elif MIN_VERSION_ghc(9,0,0)
+import qualified GHC.Utils.Misc as Ghc
+#else
+import qualified Util as Ghc
+#endif
+
+data OverridingBool = Auto | Never | Always
+  deriving (Show, Read, Eq, Ord, Enum, Bounded, Hashable, Generic, NFData)
+
+toGhcOverridingBool :: OverridingBool -> Ghc.OverridingBool
+toGhcOverridingBool Auto = Ghc.Auto
+toGhcOverridingBool Never = Ghc.Never
+toGhcOverridingBool Always = Ghc.Always
+
+fromGhcOverridingBool :: Ghc.OverridingBool -> OverridingBool
+fromGhcOverridingBool Ghc.Auto = Auto
+fromGhcOverridingBool Ghc.Never = Never
+fromGhcOverridingBool Ghc.Always = Always

clash-lib/src/Clash/Driver/Manifest.hs

@@ -54,6 +54,7 @@ import           Text.Read (readMaybe)
 import           Clash.Annotations.TopEntity.Extra ()
 import           Clash.Backend (Backend (hdlType), Usage (External))
 import           Clash.Core.Name (nameOcc)
+import           Clash.Driver.Bool (OverridingBool(..))
 import           Clash.Driver.Types
 import           Clash.Primitives.Types
 import           Clash.Core.Var (Id, varName)
@@ -66,14 +67,6 @@ import           Clash.Primitives.Util (hashCompiledPrimMap)
 import           Clash.Signal (VDomainConfiguration(..))
 import           Clash.Util.Graph (callGraphBindings)
 
-#if MIN_VERSION_ghc(9,4,0)
-import GHC.Data.Bool (OverridingBool(..))
-#elif MIN_VERSION_ghc(9,0,0)
-import GHC.Utils.Misc (OverridingBool(..))
-#else
-import Util (OverridingBool(..))
-#endif
-
 data PortDirection
   = In | Out | InOut
   deriving (Generic, Eq, Read, Show)

clash-lib/src/Clash/Driver/Types.hs

@@ -45,15 +45,12 @@ import           GHC.Generics                   (Generic)
 #if MIN_VERSION_ghc(9,4,0)
 import           GHC.Types.Basic                (InlineSpec)
 import           GHC.Types.SrcLoc               (SrcSpan)
-import           GHC.Data.Bool                  (OverridingBool(..))
 #elif MIN_VERSION_ghc(9,0,0)
 import           GHC.Types.Basic                (InlineSpec)
 import           GHC.Types.SrcLoc               (SrcSpan)
-import           GHC.Utils.Misc                 (OverridingBool(..))
 #else
 import           BasicTypes                     (InlineSpec)
 import           SrcLoc                         (SrcSpan)
-import           Util                           (OverridingBool(..))
 #endif
 
 import           Clash.Annotations.BitRepresentation.Internal (CustomReprs)
@@ -65,6 +62,7 @@ import           Clash.Core.Term                (Term)
 import           Clash.Core.TyCon               (TyConMap, TyConName)
 import           Clash.Core.Var                 (Id)
 import           Clash.Core.VarEnv              (VarEnv)
+import           Clash.Driver.Bool              (OverridingBool(..))
 import           Clash.Netlist.BlackBox.Types   (HdlSyn (..))
 import {-# SOURCE #-} Clash.Netlist.Types       (PreserveCase(..), TopEntityT)
 import           Clash.Primitives.Types         (CompiledPrimMap)
@@ -405,118 +403,7 @@ data ClashOpts = ClashOpts
   -- ^ Don't error if we see a (potentially) broken GHC / platform combination.
   -- See the project's @README.md@ for more information.
   }
-  deriving (Show)
-
-instance NFData ClashOpts where
-  rnf o =
-    opt_werror o `deepseq`
-    opt_inlineLimit o `deepseq`
-    opt_specLimit o `deepseq`
-    opt_inlineFunctionLimit o `deepseq`
-    opt_inlineConstantLimit o `deepseq`
-    opt_evaluatorFuelLimit o `deepseq`
-    opt_cachehdl o `deepseq`
-    opt_clear o `deepseq`
-    opt_primWarn o `deepseq`
-    opt_color o `seq`
-    opt_intWidth o `deepseq`
-    opt_hdlDir o `deepseq`
-    opt_hdlSyn o `deepseq`
-    opt_errorExtra o `deepseq`
-    opt_importPaths o `deepseq`
-    opt_componentPrefix o `deepseq`
-    opt_newInlineStrat o `deepseq`
-    opt_escapedIds o `deepseq`
-    opt_lowerCaseBasicIds o `deepseq`
-    opt_ultra o `deepseq`
-    opt_forceUndefined o `deepseq`
-    opt_checkIDir o `deepseq`
-    opt_aggressiveXOpt o `deepseq`
-    opt_aggressiveXOptBB o `deepseq`
-    opt_inlineWFCacheLimit o `deepseq`
-    opt_edalize o `deepseq`
-    opt_renderEnums o `deepseq`
-    opt_timescalePrecision o `deepseq`
-    opt_ignoreBrokenGhcs o `deepseq`
-    ()
-
-instance Eq ClashOpts where
-  s0 == s1 =
-    opt_werror s0 == opt_werror s1 &&
-    opt_inlineLimit s0 == opt_inlineLimit s1 &&
-    opt_specLimit s0 == opt_specLimit s1 &&
-    opt_inlineFunctionLimit s0 == opt_inlineFunctionLimit s1 &&
-    opt_inlineConstantLimit s0 == opt_inlineConstantLimit s1 &&
-    opt_evaluatorFuelLimit s0 == opt_evaluatorFuelLimit s1 &&
-    opt_cachehdl s0 == opt_cachehdl s1 &&
-    opt_clear s0 == opt_clear s1 &&
-    opt_primWarn s0 == opt_primWarn s1 &&
-    (opt_color s0 `eqOverridingBool` opt_color s1) &&
-    opt_intWidth s0 == opt_intWidth s1 &&
-    opt_hdlDir s0 == opt_hdlDir s1 &&
-    opt_hdlSyn s0 == opt_hdlSyn s1 &&
-    opt_errorExtra s0 == opt_errorExtra s1 &&
-    opt_importPaths s0 == opt_importPaths s1 &&
-    opt_componentPrefix s0 == opt_componentPrefix s1 &&
-    opt_newInlineStrat s0 == opt_newInlineStrat s1 &&
-    opt_escapedIds s0 == opt_escapedIds s1 &&
-    opt_lowerCaseBasicIds s0 == opt_lowerCaseBasicIds s1 &&
-    opt_ultra s0 == opt_ultra s1 &&
-    opt_forceUndefined s0 == opt_forceUndefined s1 &&
-    opt_checkIDir s0 == opt_checkIDir s1 &&
-    opt_aggressiveXOpt s0 == opt_aggressiveXOpt s1 &&
-    opt_aggressiveXOptBB s0 == opt_aggressiveXOptBB s1 &&
-    opt_inlineWFCacheLimit s0 == opt_inlineWFCacheLimit s1 &&
-    opt_edalize s0 == opt_edalize s1 &&
-    opt_renderEnums s0 == opt_renderEnums s1 &&
-    opt_timescalePrecision s0 == opt_timescalePrecision s1 &&
-    opt_ignoreBrokenGhcs s0 == opt_ignoreBrokenGhcs s1
-
-   where
-    eqOverridingBool :: OverridingBool -> OverridingBool -> Bool
-    eqOverridingBool Auto Auto = True
-    eqOverridingBool Always Always = True
-    eqOverridingBool Never Never = True
-    eqOverridingBool _ _ = False
-
-instance Hashable ClashOpts where
-  hashWithSalt s ClashOpts {..} =
-    s `hashWithSalt`
-    opt_werror `hashWithSalt`
-    opt_inlineLimit `hashWithSalt`
-    opt_specLimit `hashWithSalt`
-    opt_inlineFunctionLimit `hashWithSalt`
-    opt_inlineConstantLimit `hashWithSalt`
-    opt_evaluatorFuelLimit `hashWithSalt`
-    opt_cachehdl `hashWithSalt`
-    opt_clear `hashWithSalt`
-    opt_primWarn `hashOverridingBool`
-    opt_color `hashWithSalt`
-    opt_intWidth `hashWithSalt`
-    opt_hdlDir `hashWithSalt`
-    opt_hdlSyn `hashWithSalt`
-    opt_errorExtra `hashWithSalt`
-    opt_importPaths `hashWithSalt`
-    opt_componentPrefix `hashWithSalt`
-    opt_newInlineStrat `hashWithSalt`
-    opt_escapedIds `hashWithSalt`
-    opt_lowerCaseBasicIds `hashWithSalt`
-    opt_ultra `hashWithSalt`
-    opt_forceUndefined `hashWithSalt`
-    opt_checkIDir `hashWithSalt`
-    opt_aggressiveXOpt `hashWithSalt`
-    opt_aggressiveXOptBB `hashWithSalt`
-    opt_inlineWFCacheLimit `hashWithSalt`
-    opt_edalize `hashWithSalt`
-    opt_renderEnums `hashWithSalt`
-    opt_timescalePrecision `hashWithSalt`
-    opt_ignoreBrokenGhcs
-   where
-    hashOverridingBool :: Int -> OverridingBool -> Int
-    hashOverridingBool s1 Auto = hashWithSalt s1 (0 :: Int)
-    hashOverridingBool s1 Always = hashWithSalt s1 (1 :: Int)
-    hashOverridingBool s1 Never = hashWithSalt s1 (2 :: Int)
-    infixl 0 `hashOverridingBool`
+  deriving (Show, Eq, NFData, Generic, Hashable)
 
 defClashOpts :: ClashOpts
 defClashOpts

clash-lib/src/Clash/Netlist/BlackBox.hs

@@ -52,13 +52,6 @@ import           System.Console.ANSI
   , ConsoleIntensity(BoldIntensity), ConsoleLayer(Foreground), ColorIntensity(Vivid))
 import           System.IO
   (hPutStrLn, stderr, hFlush, hIsTerminalDevice)
-#if MIN_VERSION_ghc(9,4,0)
-import           GHC.Data.Bool                 (OverridingBool(..))
-#elif MIN_VERSION_ghc(9,0,0)
-import           GHC.Utils.Misc                (OverridingBool(..))
-#else
-import           Util                          (OverridingBool(..))
-#endif
 
 import           Clash.Annotations.Primitive
   ( PrimitiveGuard(HasBlackBox, DontTranslate)
@@ -92,6 +85,7 @@ import {-# SOURCE #-} Clash.Netlist
 import qualified Clash.Backend                 as Backend
 import qualified Clash.Data.UniqMap as UniqMap
 import           Clash.Debug                   (debugIsOn)
+import           Clash.Driver.Bool             (OverridingBool(..))
 import           Clash.Driver.Types
   (ClashOpts(opt_primWarn, opt_color, opt_werror))
 import           Clash.Netlist.BlackBox.Types  as B