GitLab

Brandon Chinn pushed to branch wip/T26961 at Glasgow Haskell Compiler / GHC

Commits:

9a9ae4df

by Duncan Coutts at 2026-05-05T14:44:37-04:00

Use __attribute__((dllimport)) for external RTS symbol declarations

This is needed to be hygenic about DLL symbol imports and exports.
The attribute is ignored on platforms other than Windows.

Use of the attribute however means that external data symbols do not
have a compile-time constant address (they are loaded using an
indirection). This means we have to adjust the rtsSyms initial linker
table so that it is a local constant in a function, rather than a global
constant. We now define it within a function that pre-populates the
symbol table with the RTS symbols.

2ad3e01e

by Duncan Coutts at 2026-05-05T14:44:37-04:00

Fix the rts linker declarations for a few data symbols

and ensure that the (windows only) rts_IOManagerIsWin32Native data
symbol is marked as externally visible.

8ff4fdb5

by David Eichmann at 2026-05-05T14:44:37-04:00

Hadrian: Disable runtime pseudo relocations for RTS on windows hosts

96974723

by Teo Camarasu at 2026-05-05T14:45:20-04:00

ghci/TH: refactor to use IORef QState

This is a pure refactor and shouldn't modify semantics at all

eff6bfaf

by Teo Camarasu at 2026-05-05T14:45:20-04:00

iserv: recover/getQ/putQ should behave same as internal interpreter

The internal and external interpreter should behave the same when
handling `recover`, the exeception recovery method of Q.
In practice, they diverge. In case of failure, the internal interpreter
only restores error message state to before the computation, wheras the
external interperter restores error message state *and* the state of putQ/getQ.

As far as I can tell this is a simple mistake in the implementation.
Note [TH recover with -fexternal-interpreter] describes the correct
behaviour but the implementation doesn't mirror this.

This change restores the correct behaviour by keeping the effects of
putQ in the erroring computation.

This is a breaking change since it modifies the behaviour of programs
that rely on recover ignoring putQ from failling computations when used
with the external interpreter. Although I highly doubt anyone relies on
this behaviour.

This divergence was first introduced in d00c308633fe7d216d31a1087e00e63532d87d6d.
As far as I can tell this was unintentional and tha commit was trying to solve a different bug.

Resolves #27022

1cb1d672

by Wen Kokke at 2026-05-06T09:53:40-04:00

rts: Add dynamic trace flags API

This commit adds an API to the RTS (exposed via Rts.h) that allows users to dynamically change the trace flags.
Prior to this commit, users were able to stop and start the profiling and heap profiling timers (via startProfTimer/stopProfTimer and startHeapProfTimer/stopHeapProfTimer).
This extends that functionality to also cover the core event types.

The getTraceFlag/setTraceFlag functions read and write the values of the trace flag cache, which is allocated by Trace.c, rather than modifying the members of RtsFlags.TraceFlags.
This is done under the assumption that the members of RtsFlags should not be modified after RTS initialisation.
Consequently, if the user modifies the trace flags using setTraceFlag, the object returned by getTraceFlags (from base) will not reflect these changes.

The trace flags are not protected by locks of any sort.
Hence, these functions are not thread-safe.
However, the trace flags are not modified by the RTS after initialisation, only read, so the race conditions introduced by one user modifying them are most likely benign.

This PR also puts the trace flag cache in a single global struct, as opposed to a collection of global variables, and changes the types of the individual flags from uint8_t to bool, as these have the same size on both Clang and GCC and are a better semantic match.
Prior to the change to uint8_t, they had type int, see 42c47cd6.
Even with its deprecation in C23, I don't think there should be any issue depending on stdbool.h.
The TRACE_X macros are redefined to access the global struct, with values cast to const bool to ensure they are read-only.

9d54dc94

by Wen Kokke at 2026-05-06T09:53:40-04:00

rts: Ensure TRACE_X values are used in place of RtsFlags.TraceFlags.X

418d737b

by Wen Kokke at 2026-05-06T09:53:40-04:00

rts: Fix nonmoving-GC tracing

The current nonmoving-GC tracing functions were written in a different
style from the other tracing functions. They were directly implemented
as, e.g., a traceConcMarkEnd function that called postConcMarkEnd.
The other tracing functions are implemented as, e.g., traceThreadLabel_,
a function that posts the thread label event, and traceThreadLabel, a
macro that checks whether TRACE_scheduler is set. This commit fixes that
implementation, and ensures that the nonmoving-GC tracing functions only
emit events if nonmoving-GC tracing is enabled.

99f4afa4
by Wen Kokke at 2026-05-06T09:53:40-04:00
```
rts: Add SymI_HasProto for get/setTraceFlag
```

7e9eb8b9

by Wen Kokke at 2026-05-06T09:53:40-04:00

rts: Add SymI_HasProto for start/endEventLogging

3a3045fb
by Wen Kokke at 2026-05-06T09:53:41-04:00
```
rts: Add changelog entry
```

a3b339a4

by Teo Camarasu at 2026-05-06T09:54:25-04:00

interface-stability/base: don't distinguish ws-32

The interface of base is identical when the Word size is 32bits.
Therefore, there is no need to have another file for this case.
So, we delete it.

Step towards: #26752

fcd24663
by Brandon Chinn at 2026-05-07T13:26:57-07:00
```
Add Data.RealFloat
```

c7466bcc

by Brandon Chinn at 2026-05-07T13:27:03-07:00

Add Infinity/NegInfinity/NaN pattern synonyms (#26961)

4d31f85d
by Brandon Chinn at 2026-05-07T13:27:04-07:00
```
Address feedback
```

24 changed files:

+ changelog.d/T27022
+ changelog.d/dynamic-trace-flags
hadrian/src/Settings/Packages.hs
libraries/base/base.cabal.in
libraries/base/changelog.md
+ libraries/base/src/Data/RealFloat.hs
libraries/ghci/GHCi/TH.hs
rts/IOManager.h
rts/Linker.c
rts/LinkerInternals.h
rts/RtsSymbols.c
rts/RtsSymbols.h
rts/Trace.c
rts/Trace.h
rts/include/rts/EventLogWriter.h
rts/linker/Elf.c
rts/sm/NonMoving.c
testsuite/tests/interface-stability/base-exports.stdout
testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
testsuite/tests/interface-stability/base-exports.stdout-mingw32
− testsuite/tests/interface-stability/base-exports.stdout-ws-32
+ testsuite/tests/th/T27022.hs
+ testsuite/tests/th/T27022.stdout
testsuite/tests/th/all.T

Changes:

changelog.d/T27022

 +section: compiler
 +synopsis: Fix a divergence in the interaction between ``recover`` and ``putQ`` between the internal and external interpreter
 +description: The ``recover`` method in TemplateHaskell now behaves the same
 +  with the internal and external interpreter.
 +  In the past, when an error was encountered in a computation in a ``recover`` block,
 +  the external interpreter would discard any state changes from ``putQ``,
 +  whereas the internal interpreter would not.
 +  This was a long-standing error in the implementation of the external interpreter.
 +  Both now keep state changes from ``putQ`` in ``recover`` blocks.
 +mrs: !15994
 +issues: #27022

changelog.d/dynamic-trace-flags

 +section: compiler
 +synopsis: Support dynamic trace flags in RTS
 +issues: #27186
 +mrs: !15936
++
 +description: {
 +    The RTS API now exposes the `RUNTIME_TRACE_FLAG` type and
 +    the `getTraceFlags` and `setTraceFlags` functions that can be used to
 +    change the trace flags at runtime.
 +}

hadrian/src/Settings/Packages.hs

@@ -322,6 +322,7 @@ rtsPackageArgs = package rts ? do
            , Profiling `wayUnit` way          ? arg "-DPROFILING"
            , Threaded  `wayUnit` way          ? arg "-DTHREADED_RTS"
            , notM targetSupportsSMP           ? arg "-optc-DNOSMP"
 +          , isWinHost                        ? arg "-optl-Wl,--disable-runtime-pseudo-reloc"
              -- See Note [AutoApply.cmm for vectors] in genapply/Main.hs
              --

libraries/base/base.cabal.in

@@ -111,6 +111,7 @@ Library
          , Data.Monoid
          , Data.Ord
          , Data.Proxy
 +        , Data.RealFloat
          , Data.STRef
          , Data.STRef.Strict
          , Data.String

libraries/base/changelog.md

@@ -2,6 +2,8 @@
  ## 4.24.0.0 *TBA*
    * Add `Bounded` instances for `Double`, `Float`, `CDouble` and `CFloat`. ([CLC proposal #402](https://github.com/haskell/core-libraries-committee/issues/402))
 +  * Add new `Data.RealFloat` module re-exporting `RealFloat` from `GHC.Float` ([CLC proposal #394](https://github.com/haskell/core-libraries-committee/issues/394))
 +  * Add `Infinity`, `NegInfinity`, and `NaN` pattern synonyms to `Data.RealFloat` ([CLC proposal #394](https://github.com/haskell/core-libraries-committee/issues/394))
  ## 4.23.0.0 *TBA*
    * Add `System.IO.hGetNewlineMode`. ([CLC proposal #370](https://github.com/haskell/core-libraries-committee/issues/370))

libraries/base/src/Data/RealFloat.hs

 +{-# LANGUAGE PatternSynonyms #-}
 +{-# LANGUAGE Safe #-}
 +{-# LANGUAGE ViewPatterns #-}
++
 +-- |
 +--
 +-- Module      :  Data.RealFloat
 +-- Copyright   :  (c) The University of Glasgow 2026
 +-- License     :  BSD-style (see the file libraries/base/LICENSE)
 +--
 +-- Maintainer  :  libraries@haskell.org
 +-- Stability   :  stable
 +-- Portability :  portable
 +--
++
 +module Data.RealFloat (
 +  RealFloat (..),
++
 +  -- * Infinity + NaN
 +  pattern Infinity,
 +  pattern NegInfinity,
 +  pattern NaN,
 +) where
++
 +import Data.Bool (Bool (..), (&&))
 +import GHC.Internal.Data.Ord ((<), (>))
 +import GHC.Internal.Float (RealFloat (..))
 +import GHC.Internal.Real ((/))
++
 +pattern Infinity :: (RealFloat a) => a
 +pattern Infinity <- ((\x -> isInfinite x && x > 0) -> True) where Infinity = 1/0
++
 +-- | Negative infinity
 +--
 +-- Provided for convenience. Could also use the following instead:
 +--   * Pattern matching: @(negate -> Infinity)@
 +--   * Expressions: @-Infinity@
 +pattern NegInfinity :: (RealFloat a) => a
 +pattern NegInfinity <- ((\x -> isInfinite x && x < 0) -> True) where NegInfinity = -1/0
++
 +-- | A pattern synonym for NaN values.
 +--
 +-- Note: Per IEEE 754, NaN is never equal to itself, thus these two snippets
 +-- have different behavior:
 +--
 +-- @
 +-- -- foo1 NaN == "a"
 +-- foo1 NaN = "a"
 +-- foo1 _ = "b"
 +--
 +-- -- foo2 NaN == "b"
 +-- foo2 x = if x == NaN then "a" else "b"
 +-- @
 +pattern NaN :: (RealFloat a) => a
 +pattern NaN <- (isNaN -> True) where NaN = 0/0

libraries/ghci/GHCi/TH.hs

@@ -119,7 +119,7 @@ initQState :: Pipe -> QState
  initQState p = QState M.empty Nothing p
  -- | The monad in which we run TH computations on the server
 -newtype GHCiQ a = GHCiQ { runGHCiQ :: QState -> IO (a, QState) }
 +newtype GHCiQ a = GHCiQ { runGHCiQ :: IORef QState -> IO a }
  -- | The exception thrown by "fail" in the GHCiQ monad
  data GHCiQException = GHCiQException QState String
@@ -128,52 +128,54 @@ data GHCiQException = GHCiQException QState String
  instance Exception GHCiQException
  instance Functor GHCiQ where
 -  fmap f (GHCiQ s) = GHCiQ $ fmap (\(x,s') -> (f x,s')) . s
 +  fmap f (GHCiQ m) = GHCiQ $ fmap f . m
  instance Applicative GHCiQ where
    f <*> a = GHCiQ $ \s ->
 -    do (f',s')  <- runGHCiQ f s
 -       (a',s'') <- runGHCiQ a s'
 -       return (f' a', s'')
 -  pure x = GHCiQ (\s -> return (x,s))
 +    do f'  <- runGHCiQ f s
 +       a' <- runGHCiQ a s
 +       return $ f' a'
 +  pure x = GHCiQ $ \_ -> return x
  instance Monad GHCiQ where
    m >>= f = GHCiQ $ \s ->
 -    do (m', s')  <- runGHCiQ m s
 -       (a,  s'') <- runGHCiQ (f m') s'
 -       return (a, s'')
 +    do m'  <- runGHCiQ m s
 +       a <- runGHCiQ (f m') s
 +       return a
  instance MonadFail GHCiQ where
 -  fail err  = GHCiQ $ \s -> throwIO (GHCiQException s err)
 +  fail err  = GHCiQ $ \sRef -> readIORef sRef >>= \s -> throwIO (GHCiQException s err)
  getState :: GHCiQ QState
 -getState = GHCiQ $ \s -> return (s,s)
 +getState = GHCiQ $ \sRef -> readIORef sRef
  noLoc :: TH.Loc
  noLoc = TH.Loc "<no file>" "<no package>" "<no module>" (0,0) (0,0)
  -- | Send a 'THMessage' to GHC and return the result.
  ghcCmd :: Binary a => THMessage (THResult a) -> GHCiQ a
 -ghcCmd m = GHCiQ $ \s -> do
 +ghcCmd m = GHCiQ $ \sRef -> do
 +  s <- readIORef sRef
    r <- remoteTHCall (qsPipe s) m
    case r of
      THException str -> throwIO (GHCiQException s str)
 -    THComplete res -> return (res, s)
 +    THComplete res -> return res
  instance MonadIO GHCiQ where
 -  liftIO m = GHCiQ $ \s -> fmap (,s) m
 +  liftIO m = GHCiQ $ \_ -> m
  instance TH.Quasi GHCiQ where
    qNewName str = ghcCmd (NewName str)
    qReport isError msg = ghcCmd (Report isError msg)
    -- See Note [TH recover with -fexternal-interpreter] in GHC.Tc.Gen.Splice
 -  qRecover (GHCiQ h) a = GHCiQ $ \s -> mask $ \unmask -> do
 +  qRecover (GHCiQ h) a = GHCiQ $ \sRef -> mask $ \unmask -> do
 +    s <- readIORef sRef
      remoteTHCall (qsPipe s) StartRecover
 -    e <- try $ unmask $ runGHCiQ (a <* ghcCmd FailIfErrs) s
 +    e <- try $ unmask $ runGHCiQ (a <* ghcCmd FailIfErrs) sRef
      remoteTHCall (qsPipe s) (EndRecover (isLeft e))
      case e of
 -      Left GHCiQException{} -> h s
 +      Left GHCiQException{} -> h sRef
        Right r -> return r
    qLookupName isType occ = ghcCmd (LookupName isType occ)
    qReify name = ghcCmd (Reify name)
@@ -200,15 +202,16 @@ instance TH.Quasi GHCiQ where
    qAddTempFile suffix = ghcCmd (AddTempFile suffix)
    qAddTopDecls decls = ghcCmd (AddTopDecls decls)
    qAddForeignFilePath lang fp = ghcCmd (AddForeignFilePath lang fp)
 -  qAddModFinalizer fin = GHCiQ (\s -> mkRemoteRef fin >>= return . (, s)) >>=
 +  qAddModFinalizer fin = GHCiQ (\_ -> mkRemoteRef fin) >>=
                           ghcCmd . AddModFinalizer
    qAddCorePlugin str = ghcCmd (AddCorePlugin str)
 -  qGetQ = GHCiQ $ \s ->
 +  qGetQ = do
 +    s <- getState
      let lookup :: forall a. Typeable a => Map TypeRep Dynamic -> Maybe a
          lookup m = fromDynamic =<< M.lookup (typeOf (undefined::a)) m
 -    in return (lookup (qsMap s), s)
 -  qPutQ k = GHCiQ $ \s ->
 -    return ((), s { qsMap = M.insert (typeOf k) (toDyn k) (qsMap s) })
 +    return $ lookup (qsMap s)
 +  qPutQ k = GHCiQ $ \sRef ->
 +    modifyIORef' sRef (\s -> s { qsMap = M.insert (typeOf k) (toDyn k) (qsMap s) })
    qIsExtEnabled x = ghcCmd (IsExtEnabled x)
    qExtsEnabled = ghcCmd ExtsEnabled
    qPutDoc l s = ghcCmd (PutDoc l s)
@@ -231,7 +234,8 @@ runModFinalizerRefs pipe rstate qrefs = do
    qs <- mapM localRef qrefs
    qstateref <- localRef rstate
    qstate <- readIORef qstateref
 -  _ <- runGHCiQ (TH.runQ $ sequence_ qs) qstate { qsPipe = pipe }
 +  qstate' <- newIORef $ qstate { qsPipe = pipe }
 +  _ <- runGHCiQ (TH.runQ $ sequence_ qs) qstate'
    return ()
  -- | The implementation of the 'RunTH' message
@@ -267,8 +271,6 @@ runTHQ
    -> IO ByteString
  runTHQ pipe rstate mb_loc ghciq = do
    qstateref <- localRef rstate
 -  qstate <- readIORef qstateref
 -  let st = qstate { qsLocation = mb_loc, qsPipe = pipe }
 -  (r,new_state) <- runGHCiQ (TH.runQ ghciq) st
 -  writeIORef qstateref new_state
 +  modifyIORef' qstateref (\qstate -> qstate { qsLocation = mb_loc, qsPipe = pipe })
 +  r <- runGHCiQ (TH.runQ ghciq) qstateref
    return $! LB.toStrict (runPut (put r))

rts/IOManager.h

@@ -21,6 +21,15 @@
  #include "sm/GC.h" // for evac_fn
 +#if defined(mingw32_HOST_OS)
 +/* Global var (only on Windows) that is exported (hence before BeginPrivate.h)
 + * to be shared with the I/O code in the base library to tell us which style
 + * of I/O manager we are using: one that uses the Windows native API HANDLEs,
 + * or one that uses Posix style fds.
 + */
 +extern bool rts_IOManagerIsWin32Native;
 +#endif
++
  #include "BeginPrivate.h"
  /* The ./configure gives us a set of CPP flags, one for each named I/O manager:
@@ -160,14 +169,6 @@ typedef enum {
  /* Global var to tell us which I/O manager impl we are using */
  extern IOManagerType iomgr_type;
 -#if defined(mingw32_HOST_OS)
 -/* Global var (only on Windows) that is exported to be shared with the I/O code
 - * in the base library to tell us which style of I/O manager we are using: one
 - * that uses the Windows native API HANDLEs, or one that uses Posix style fds.
 - */
 -extern bool rts_IOManagerIsWin32Native;
 -#endif
+-
  /* The CapIOManager is the per-capability data structure belonging to the I/O
   * manager. It is defined in full in IOManagerInternals.h. The opaque forward

rts/Linker.c

@@ -478,16 +478,7 @@ initLinker_ (int retain_cafs)
      symhash = allocStrHashTable();
      /* populate the symbol table with stuff from the RTS */
 -    IF_DEBUG(linker, debugBelch("populating linker symbol table with built-in RTS symbols\n"));
 -    for (const RtsSymbolVal *sym = rtsSyms; sym->lbl != NULL; sym++) {
 -        IF_DEBUG(linker, debugBelch("initLinker: inserting rts symbol %s, %p\n", sym->lbl, sym->addr));
 -        if (! ghciInsertSymbolTable(WSTR("(GHCi built-in symbols)"),
 -                                    symhash, sym->lbl, sym->addr,
 -                                    sym->strength, sym->type, 0, NULL)) {
 -            barf("ghciInsertSymbolTable failed");
 -        }
 -    }
 -    IF_DEBUG(linker, debugBelch("done with built-in RTS symbols\n"));
 +    initLinkerRtsSyms(symhash);
      /* Add extra symbols. rtsExtraSyms() is a weakly defined symbol in the rts,
       * that can be overrided by linking in an object with a corresponding

rts/LinkerInternals.h

@@ -502,4 +502,6 @@ ObjectCode* mkOc( ObjectType type, pathchar *path, char *image, int imageSize,
  void initSegment(Segment *s, void *start, size_t size, SegmentProt prot, int n_sections);
  void freeSegments(ObjectCode *oc);
 +void initLinkerRtsSyms(StrHashTable *symhash);
++
  #include "EndPrivate.h"

rts/RtsSymbols.c

@@ -9,6 +9,8 @@
  #include "ghcplatform.h"
  #include "Rts.h"
  #include "RtsSymbols.h"
 +#include "LinkerInternals.h"
 +#include "PathUtils.h"
  #include "TopHandler.h"
  #include "HsFFI.h"
@@ -51,6 +53,20 @@ extern char **environ;
  /* -----------------------------------------------------------------------------
   * Symbols to be inserted into the RTS symbol table.
 + *
 + * Note [Naming Scheme for Symbol Macros]
 + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 + *
 + * SymI_*: symbol is internal to the RTS. It resides in an object
 + *         file/library that is linked into the RTS library (as a static
 + *         archive or dynamic shared library).
 + * SymE_*: symbol is external to the RTS library. It might be linked
 + *         dynamically.
 + *
 + * Sym*_HasProto  : the symbol prototype is imported in an include file
 + *                  or defined explicitly
 + * Sym*_NeedsProto: the symbol is undefined and we add a dummy
 + *                  default proto extern void sym(void);
   */
  #define Maybe_Stable_Names      SymI_HasProto(stg_mkWeakzh)                   \
@@ -162,7 +178,7 @@ extern char **environ;
        SymI_HasProto(stg_asyncWritezh)                    \
        SymI_HasProto(stg_asyncDoProczh)                   \
        SymI_HasProto(rts_InstallConsoleEvent)             \
 -      SymI_HasProto(rts_IOManagerIsWin32Native)          \
 +      SymI_HasDataProto(rts_IOManagerIsWin32Native)          \
        SymI_HasProto(rts_ConsoleHandlerDone)              \
        SymI_NeedsProto(__mingw_module_is_dll)             \
        RTS_WIN64_ONLY(SymI_NeedsProto(___chkstk_ms))      \
@@ -524,7 +540,12 @@ extern char **environ;
        SymI_HasProto(__word_encodeFloat)                                 \
        SymI_HasDataProto(stg_atomicallyzh)                                   \
        SymI_HasProto(barf)                                               \
 +      SymI_HasProto(startEventLogging)                                  \
 +      SymI_HasProto(endEventLogging)                                    \
        SymI_HasProto(flushEventLog)                                      \
 +      SymI_HasProto(flushEventLog)                                      \
 +      SymI_HasProto(getTraceFlag)                                       \
 +      SymI_HasProto(setTraceFlag)                                       \
        SymI_HasProto(deRefStablePtr)                                     \
        SymI_HasProto(debugBelch)                                         \
        SymI_HasProto(errorBelch)                                         \
@@ -914,7 +935,7 @@ extern char **environ;
        SymI_HasProto(freeExecPage)                                       \
        SymI_HasProto(getAllocations)                                     \
        SymI_HasProto(revertCAFs)                                         \
 -      SymI_HasProto(RtsFlags)                                           \
 +      SymI_HasDataProto(RtsFlags)                                           \
        SymI_NeedsDataProto(rts_breakpoint_io_action)                     \
        SymI_NeedsDataProto(rts_stop_next_breakpoint)                     \
        SymI_NeedsDataProto(rts_stop_on_exception)                        \
@@ -925,9 +946,9 @@ extern char **environ;
        SymI_NeedsProto(rts_enableStopAfterReturn)                        \
        SymI_NeedsProto(rts_disableStopAfterReturn)                       \
        SymI_HasProto(stopTimer)                                          \
 -      SymI_HasProto(n_capabilities)                                     \
 -      SymI_HasProto(max_n_capabilities)                                 \
 -      SymI_HasProto(enabled_capabilities)                               \
 +      SymI_HasDataProto(n_capabilities)                                     \
 +      SymI_HasDataProto(max_n_capabilities)                                 \
 +      SymI_HasDataProto(enabled_capabilities)                               \
        SymI_HasDataProto(stg_traceEventzh)                                   \
        SymI_HasDataProto(stg_traceMarkerzh)                                  \
        SymI_HasDataProto(stg_traceBinaryEventzh)                             \
@@ -1145,12 +1166,27 @@ extern char **environ;
        SymI_HasProto(hs_word2float64)
 -/* entirely bogus claims about types of these symbols */
 -#define SymI_NeedsProto(vvv)  extern void vvv(void);
 -#define SymI_NeedsDataProto(vvv)  extern StgWord vvv[];
 -#define SymE_NeedsProto(vvv)  SymI_NeedsProto(vvv);
 -#define SymE_NeedsDataProto(vvv)  SymI_NeedsDataProto(vvv);
 -#define SymE_HasProto(vvv)    SymI_HasProto(vvv);
 +/* Declare prototypes for the symbols that need it, so we can refer
 + * to them in the rtsSyms table below.
 + *
 + * In particular, for the external ones (SymE_*) we use the dllimport attribute
 + * to indicate that (on Windows) they come from external DLLs. This attribute
 + * is ignored on other platforms.
 + *
 + * The claims about the types of these symbols are entirely bogus.
 + */
 +#if defined(mingw32_HOST_OS) && defined(DYNAMIC)
 +#define DLLIMPORT __attribute__((dllimport))
 +#else
 +#define DLLIMPORT /**/
 +#endif
++
 +#define SymI_NeedsProto(vvv)      extern           void vvv(void);
 +#define SymI_NeedsDataProto(vvv)  extern           StgWord vvv[];
 +#define SymE_NeedsProto(vvv)      extern DLLIMPORT void vvv(void);
 +#define SymE_NeedsDataProto(vvv)  extern DLLIMPORT StgWord vvv[];
++
 +#define SymE_HasProto(vvv) /**/
  #define SymI_HasProto(vvv) /**/
  #define SymI_HasDataProto(vvv) /**/
  #define SymI_HasProto_redirect(vvv,xxx,strength,ty) /**/
@@ -1179,6 +1215,8 @@ RTS_SYMBOLS_PRIM
  #undef SymE_NeedsProto
  #undef SymE_NeedsDataProto
 +/* See Note [Naming Scheme for Symbol Macros] */
++
  #define SymI_HasProto(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
                      (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE },
  #define SymI_HasDataProto(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
@@ -1199,7 +1237,16 @@ RTS_SYMBOLS_PRIM
      { MAYBE_LEADING_UNDERSCORE_STR(#vvv),    \
        (void*)(&(xxx)), strength, ty },
 -RtsSymbolVal rtsSyms[] = {
++
++
 +/* Initialize (if not already initialized) and return an array of symbols with stuff from the RTS. */
 +void initLinkerRtsSyms (StrHashTable *symhash) {
 +    /* The address of data symbols with the dllimport attribute are not
 +     * compile-time constants and so cannot be used in constant initialisers.
 +     * For this reason, rtsSyms is a local variable within this function
 +     * rather than a global constant (as it was historically).
 +     */
 +    const RtsSymbolVal rtsSyms[] = {
        RTS_SYMBOLS
        RTS_RET_SYMBOLS
        RTS_POSIX_ONLY_SYMBOLS
@@ -1214,7 +1261,20 @@ RtsSymbolVal rtsSyms[] = {
        RTS_SYMBOLS_PRIM
        SymI_HasDataProto(nonmoving_write_barrier_enabled)
        { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE } /* sentinel */
 -};
 +    };
++
 +    IF_DEBUG(linker, debugBelch("populating linker symbol table with built-in RTS symbols\n"));
 +    for (const RtsSymbolVal *sym = rtsSyms; sym->lbl != NULL; sym++) {
 +        IF_DEBUG(linker, debugBelch("initLinker: inserting rts symbol %s, %p\n", sym->lbl, sym->addr));
 +        if (! ghciInsertSymbolTable(WSTR("(GHCi built-in symbols)"),
 +                                    symhash, sym->lbl, sym->addr,
 +                                    sym->strength, sym->type, 0, NULL)) {
 +            barf("ghciInsertSymbolTable failed");
 +        }
 +    }
 +    IF_DEBUG(linker, debugBelch("done with built-in RTS symbols\n"));
 +}
++
  // Note [Extra RTS symbols]

rts/RtsSymbols.h

@@ -46,8 +46,6 @@ typedef struct _RtsSymbolVal {
      SymType type;
  } RtsSymbolVal;
 -extern RtsSymbolVal rtsSyms[];
+-
  extern RtsSymbolVal* __attribute__((weak)) rtsExtraSyms(void);
  /* See Note [_iob_func symbol].  */

rts/Trace.c

@@ -29,14 +29,54 @@
  #include <unistd.h>
  #endif
 -// events
 -uint8_t TRACE_sched;
 -uint8_t TRACE_gc;
 -uint8_t TRACE_nonmoving_gc;
 -uint8_t TRACE_spark_sampled;
 -uint8_t TRACE_spark_full;
 -uint8_t TRACE_user;
 -uint8_t TRACE_cap;
 +RUNTIME_TRACE_FLAG_CACHE RuntimeTraceFlagCache = {0};
++
 +bool getTraceFlag(RUNTIME_TRACE_FLAG flag) {
 +  switch (flag) {
 +  case TRACE_SCHEDULER:
 +    return RuntimeTraceFlagCache.scheduler;
 +  case TRACE_GC:
 +    return RuntimeTraceFlagCache.gc;
 +  case TRACE_NONMOVING_GC:
 +    return RuntimeTraceFlagCache.nonmoving_gc;
 +  case TRACE_SPARK_SAMPLED:
 +    return RuntimeTraceFlagCache.spark_sampled;
 +  case TRACE_SPARK_FULL:
 +    return RuntimeTraceFlagCache.spark_full;
 +  case TRACE_USER:
 +    return RuntimeTraceFlagCache.user;
 +  case TRACE_CAP:
 +    return RuntimeTraceFlagCache.cap;
 +  default:
 +    return false;
 +  }
 +}
++
 +void setTraceFlag(RUNTIME_TRACE_FLAG flag, bool value) {
 +  switch (flag) {
 +  case TRACE_SCHEDULER:
 +    RuntimeTraceFlagCache.scheduler = value;
 +    break;
 +  case TRACE_GC:
 +    RuntimeTraceFlagCache.gc = value;
 +    break;
 +  case TRACE_NONMOVING_GC:
 +    RuntimeTraceFlagCache.nonmoving_gc = value;
 +    break;
 +  case TRACE_SPARK_SAMPLED:
 +    RuntimeTraceFlagCache.spark_sampled = value;
 +    break;
 +  case TRACE_SPARK_FULL:
 +    RuntimeTraceFlagCache.spark_full = value;
 +    break;
 +  case TRACE_USER:
 +    RuntimeTraceFlagCache.user = value;
 +    break;
 +  case TRACE_CAP:
 +    RuntimeTraceFlagCache.cap = value;
 +    break;
 +  }
 +}
  #if defined(THREADED_RTS)
  static Mutex trace_utx;
@@ -51,43 +91,41 @@ static void traceCap_stderr(Capability *cap, char *msg, ...);
   --------------------------------------------------------------------------- */
  /*
 - * Update the TRACE_* globals. Must be called whenever RtsFlags.TraceFlags is
 - * modified.
 + * Initialise the runtime trace flags from RtsFlags.TraceFlags.
   */
 -static void updateTraceFlagCache (void)
 -{
 -    // -Ds turns on scheduler tracing too
 -    TRACE_sched =
 -        RtsFlags.TraceFlags.scheduler ||
 -        RtsFlags.DebugFlags.scheduler;
+-
 -    // -Dg turns on gc tracing too
 -    TRACE_gc =
 -        RtsFlags.TraceFlags.gc ||
 -        RtsFlags.DebugFlags.gc ||
 -        RtsFlags.DebugFlags.scheduler;
+-
 -    TRACE_nonmoving_gc =
 -        RtsFlags.TraceFlags.nonmoving_gc;
+-
 -    TRACE_spark_sampled =
 -        RtsFlags.TraceFlags.sparks_sampled;
+-
 -    // -Dr turns on full spark tracing
 -    TRACE_spark_full =
 -        RtsFlags.TraceFlags.sparks_full ||
 -        RtsFlags.DebugFlags.sparks;
+-
 -    TRACE_user =
 -        RtsFlags.TraceFlags.user;
+-
 -    // We trace cap events if we're tracing anything else
 -    TRACE_cap =
 -        TRACE_sched ||
 -        TRACE_gc ||
 -        TRACE_spark_sampled ||
 -        TRACE_spark_full ||
 -        TRACE_user;
 +static void updateTraceFlagCache(void) {
 +  // -Ds turns on scheduler tracing too
 +  RuntimeTraceFlagCache.scheduler =
 +    RtsFlags.TraceFlags.scheduler ||
 +    RtsFlags.DebugFlags.scheduler;
++
 +  // -Dg turns on gc tracing too
 +  RuntimeTraceFlagCache.gc =
 +    RtsFlags.TraceFlags.gc ||
 +    RtsFlags.DebugFlags.gc ||
 +    RtsFlags.DebugFlags.scheduler;
++
 +  RuntimeTraceFlagCache.nonmoving_gc =
 +    RtsFlags.TraceFlags.nonmoving_gc;
++
 +  RuntimeTraceFlagCache.spark_sampled =
 +    RtsFlags.TraceFlags.sparks_sampled;
++
 +  // -Dr turns on full spark tracing
 +  RuntimeTraceFlagCache.spark_full =
 +      RtsFlags.TraceFlags.sparks_full ||
 +      RtsFlags.DebugFlags.sparks;
++
 +  RuntimeTraceFlagCache.user =
 +    RtsFlags.TraceFlags.user;
++
 +  // We trace cap events if we're tracing anything else
 +  RuntimeTraceFlagCache.cap =
 +    TRACE_sched ||
 +    TRACE_gc ||
 +    TRACE_spark_sampled ||
 +    TRACE_spark_full ||
 +    TRACE_user;
+ }
  void initTracing (void)
@@ -880,59 +918,65 @@ void traceThreadLabel_(Capability *cap,
+     }
+ }
 -void traceConcMarkBegin(void)
 +void traceNonmovingGcEvent_ (EventTypeNum tag)
+ {
 -    if (eventlog_enabled)
 -        postEventNoCap(EVENT_CONC_MARK_BEGIN);
 +#if defined(DEBUG)
 +    if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
 +        /* nothing - no string representation for nonmoving GC events  */
 +    } else
 +#endif
 +    {
 +        /* currently most non-moving GC events are nullary events */
 +        postEventNoCap(tag);
 +    }
+ }
 -void traceConcMarkEnd(StgWord32 marked_obj_count)
 +void traceConcMarkEnd_(StgWord32 marked_obj_count)
+ {
 -    if (eventlog_enabled)
 +#if defined(DEBUG)
 +    if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
 +        /* nothing - no string representation for nonmoving GC events  */
 +    } else
 +#endif
 +    {
          postConcMarkEnd(marked_obj_count);
 +    }
+ }
 -void traceConcSyncBegin(void)
 -{
 -    if (eventlog_enabled)
 -        postEventNoCap(EVENT_CONC_SYNC_BEGIN);
 -}
+-
 -void traceConcSyncEnd(void)
 -{
 -    if (eventlog_enabled)
 -        postEventNoCap(EVENT_CONC_SYNC_END);
 -}
+-
 -void traceConcSweepBegin(void)
 -{
 -    if (eventlog_enabled)
 -        postEventNoCap(EVENT_CONC_SWEEP_BEGIN);
 -}
+-
 -void traceConcSweepEnd(void)
 -{
 -    if (eventlog_enabled)
 -        postEventNoCap(EVENT_CONC_SWEEP_END);
 -}
+-
 -void traceConcUpdRemSetFlush(Capability *cap)
 +void traceConcUpdRemSetFlush_(Capability *cap)
+ {
 -    if (eventlog_enabled)
 +#if defined(DEBUG)
 +    if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
 +        /* nothing - no string representation for nonmoving GC events  */
 +    } else
 +#endif
 +    {
          postConcUpdRemSetFlush(cap);
 +    }
+ }
 -void traceNonmovingHeapCensus(uint16_t blk_size,
 -                              const struct NonmovingAllocCensus *census)
 +void traceNonmovingHeapCensus_(uint16_t blk_size, const struct NonmovingAllocCensus *census)
+ {
 -    if (eventlog_enabled && TRACE_nonmoving_gc)
 +#if defined(DEBUG)
 +    if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
 +        /* nothing - no string representation for nonmoving GC events  */
 +    } else
 +#endif
 +    {
          postNonmovingHeapCensus(blk_size, census);
 +    }
+ }
 -void traceNonmovingPrunedSegments(uint32_t pruned_segments, uint32_t free_segments)
 +void traceNonmovingPrunedSegments_(uint32_t pruned_segments, uint32_t free_segments)
+ {
 -    if (eventlog_enabled && TRACE_nonmoving_gc)
 +#if defined(DEBUG)
 +    if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
 +        /* nothing - no string representation for nonmoving GC events  */
 +    } else
 +#endif
 +    {
          postNonmovingPrunedSegments(pruned_segments, free_segments);
 +    }
+ }
  void traceThreadStatus_ (StgTSO *tso USED_IF_DEBUG)

rts/Trace.h

@@ -70,16 +70,35 @@ enum CapsetType { CapsetTypeCustom = CAPSET_TYPE_CUSTOM,
  #define DEBUG_continuation RtsFlags.DebugFlags.continuation
  #define DEBUG_iomanager   RtsFlags.DebugFlags.iomanager
 -// Event-enabled flags
 -// These semantically booleans but we use a dense packing to minimize their
 -// cache impact.
 -extern uint8_t TRACE_sched;
 -extern uint8_t TRACE_gc;
 -extern uint8_t TRACE_nonmoving_gc;
 -extern uint8_t TRACE_spark_sampled;
 -extern uint8_t TRACE_spark_full;
 -extern uint8_t TRACE_cap;
 -/* extern uint8_t TRACE_user; */  // only used in Trace.c
 +// These trace flags are shorthand for the members of the RuntimeTraceFlagCache
 +// struct. Within the RTS, these should be treated as read-only variables.
 +#define TRACE_sched         ((const bool)RuntimeTraceFlagCache.scheduler)
 +#define TRACE_gc            ((const bool)RuntimeTraceFlagCache.gc)
 +#define TRACE_nonmoving_gc  ((const bool)RuntimeTraceFlagCache.nonmoving_gc)
 +#define TRACE_spark_sampled ((const bool)RuntimeTraceFlagCache.spark_sampled)
 +#define TRACE_spark_full    ((const bool)RuntimeTraceFlagCache.spark_full)
 +#define TRACE_user          ((const bool)RuntimeTraceFlagCache.user)
 +#define TRACE_cap           ((const bool)RuntimeTraceFlagCache.cap)
++
 +/*
 + * Runtime trace flags.
 + */
 +typedef struct {
 +  bool scheduler;
 +  bool gc;
 +  bool nonmoving_gc;
 +  bool spark_sampled;
 +  bool spark_full;
 +  bool user;
 +  bool cap;
 +} RUNTIME_TRACE_FLAG_CACHE;
++
 +/*
 + * These flags should be used to determine whether or not some value should
 + * be traced at runtime, rather than the values in RtsFlags. These flags can
 + * be modified at runtime using setTraceFlag in `rts/EventLogWriter.h`.
 + */
 +extern RUNTIME_TRACE_FLAG_CACHE RuntimeTraceFlagCache;
  // -----------------------------------------------------------------------------
  // Posting events
@@ -136,6 +155,52 @@ void traceGcEvent_ (Capability *cap, EventTypeNum tag);
  void traceGcEventAtT_ (Capability *cap, StgWord64 ts, EventTypeNum tag);
 +/*
 + * Record a nonmoving GC event.
 + */
 +#define traceConcMarkBegin()                                           \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingGcEvent_(EVENT_CONC_MARK_BEGIN);                 \
 +    }
 +#define traceConcMarkEnd(marked_obj_count)                             \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceConcMarkEnd_(marked_obj_count);                           \
 +    }
 +#define traceConcSyncBegin()                                           \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingGcEvent_(EVENT_CONC_SYNC_BEGIN);                 \
 +    }
 +#define traceConcSyncEnd()                                             \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingGcEvent_(EVENT_CONC_SYNC_END);                   \
 +    }
 +#define traceConcSweepBegin()                                          \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingGcEvent_(EVENT_CONC_SWEEP_BEGIN);                \
 +    }
 +#define traceConcSweepEnd()                                            \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingGcEvent_(EVENT_CONC_SWEEP_END);                  \
 +    }
 +#define traceConcUpdRemSetFlush(cap)                                   \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceConcUpdRemSetFlush_(cap);                                 \
 +    }
 +#define traceNonmovingHeapCensus(blk_size, census)                     \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingHeapCensus_(blk_size, census);                   \
 +    }
 +#define traceNonmovingPrunedSegments(pruned_segments, free_segments)   \
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc)) {                            \
 +        traceNonmovingPrunedSegments_(pruned_segments, free_segments); \
 +    }
++
 +void traceNonmovingGcEvent_ (EventTypeNum tag);
 +void traceConcMarkEnd_(StgWord32 marked_obj_count);
 +void traceConcUpdRemSetFlush_(Capability *cap);
 +void traceNonmovingHeapCensus_(uint16_t blk_size, const struct NonmovingAllocCensus *census);
 +void traceNonmovingPrunedSegments_(uint32_t pruned_segments, uint32_t free_segments);
++
  /*
   * Record a heap event
   */
@@ -321,17 +386,6 @@ void traceProfSampleCostCentre(Capability *cap,
  void traceProfBegin(void);
  #endif /* PROFILING */
 -void traceConcMarkBegin(void);
 -void traceConcMarkEnd(StgWord32 marked_obj_count);
 -void traceConcSyncBegin(void);
 -void traceConcSyncEnd(void);
 -void traceConcSweepBegin(void);
 -void traceConcSweepEnd(void);
 -void traceConcUpdRemSetFlush(Capability *cap);
 -void traceNonmovingHeapCensus(uint16_t blk_size,
 -                              const struct NonmovingAllocCensus *census);
 -void traceNonmovingPrunedSegments(uint32_t pruned_segments, uint32_t free_segments);
+-
  void traceIPE(const InfoProvEnt *ipe);
  void flushTrace(void);
@@ -384,6 +438,7 @@ void flushTrace(void);
  #define traceConcSweepEnd() /* nothing */
  #define traceConcUpdRemSetFlush(cap) /* nothing */
  #define traceNonmovingHeapCensus(blk_size, census) /* nothing */
 +#define traceNonmovingPrunedSegments(pruned_segments, free_segments) /* nothing */
  #define flushTrace() /* nothing */

rts/include/rts/EventLogWriter.h

@@ -78,3 +78,34 @@ void endEventLogging(void);
   * Flush the eventlog. cap can be NULL if one is not held.
   */
  void flushEventLog(Capability **cap);
++
 +/*
 + * An enumeration for the runtime trace flags.
 + */
 +typedef enum {
 +  TRACE_SCHEDULER,
 +  TRACE_GC,
 +  TRACE_NONMOVING_GC,
 +  TRACE_SPARK_SAMPLED,
 +  TRACE_SPARK_FULL,
 +  TRACE_USER,
 +  TRACE_CAP,
 +} RUNTIME_TRACE_FLAG;
++
 +/*
 + * Get the value of the given runtime trace flag.
 + *
 + * Warning: The trace flag cache is not thread-safe. After initialisation, the
 + * RTS never writes to these values, but concurrently using getTraceFlag and
 + * setTraceFlag for the same flag is a race condition.
 + */
 +bool getTraceFlag(RUNTIME_TRACE_FLAG flag);
++
 +/*
 + * Set the value of the given runtime trace flag.
 + *
 + * Warning: The trace flag cache is not thread-safe. After initialisation, the
 + * RTS never writes to these values. However, inconsistent reads may lead to
 + * incorrect tracing for a short time after setting a trace flag.
 + */
 +void setTraceFlag(RUNTIME_TRACE_FLAG flag, bool value);

rts/linker/Elf.c

@@ -76,18 +76,6 @@
+  *
   * See bug #781
   * See thread http://www.haskell.org/pipermail/cvs-ghc/2007-September/038458.html
 - *
 - * Naming Scheme for Symbol Macros
 - *
 - * SymI_*: symbol is internal to the RTS. It resides in an object
 - *         file/library that is statically.
 - * SymE_*: symbol is external to the RTS library. It might be linked
 - *         dynamically.
 - *
 - * Sym*_HasProto  : the symbol prototype is imported in an include file
 - *                  or defined explicitly
 - * Sym*_NeedsProto: the symbol is undefined and we add a dummy
 - *                  default proto extern void sym(void);
   */
  #define X86_64_ELF_NONPIC_HACK (!RtsFlags.MiscFlags.linkerAlwaysPic)

rts/sm/NonMoving.c

@@ -1339,7 +1339,7 @@ concurrent_marking:
          nonmovingPrintAllocatorCensus(!concurrent);
  #endif
  #if defined(TRACING)
 -    if (RtsFlags.TraceFlags.nonmoving_gc)
 +    if (RTS_UNLIKELY(TRACE_nonmoving_gc))
          nonmovingTraceAllocatorCensus();
  #endif

testsuite/tests/interface-stability/base-exports.stdout

@@ -1597,6 +1597,29 @@ module Data.Ratio where
    denominator :: forall a. Ratio a -> a
    numerator :: forall a. Ratio a -> a
 +module Data.RealFloat where
 +  -- Safety: Safe
 +  pattern Infinity :: forall a. RealFloat a => a
 +  pattern NaN :: forall a. RealFloat a => a
 +  pattern NegInfinity :: forall a. RealFloat a => a
 +  type RealFloat :: * -> Constraint
 +  class (GHC.Internal.Real.RealFrac a, GHC.Internal.Float.Floating a) => RealFloat a where
 +    floatRadix :: a -> GHC.Internal.Bignum.Integer.Integer
 +    floatDigits :: a -> GHC.Internal.Types.Int
 +    floatRange :: a -> (GHC.Internal.Types.Int, GHC.Internal.Types.Int)
 +    decodeFloat :: a -> (GHC.Internal.Bignum.Integer.Integer, GHC.Internal.Types.Int)
 +    encodeFloat :: GHC.Internal.Bignum.Integer.Integer -> GHC.Internal.Types.Int -> a
 +    exponent :: a -> GHC.Internal.Types.Int
 +    significand :: a -> a
 +    scaleFloat :: GHC.Internal.Types.Int -> a -> a
 +    isNaN :: a -> GHC.Internal.Types.Bool
 +    isInfinite :: a -> GHC.Internal.Types.Bool
 +    isDenormalized :: a -> GHC.Internal.Types.Bool
 +    isNegativeZero :: a -> GHC.Internal.Types.Bool
 +    isIEEE :: a -> GHC.Internal.Types.Bool
 +    atan2 :: a -> a -> a
 +    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
++
  module Data.STRef where
    -- Safety: Safe
    type role STRef nominal representational
@@ -11960,6 +11983,8 @@ instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.In
  instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. (GHC.Internal.Enum.Enum a, GHC.Internal.Enum.Bounded a, GHC.Internal.Classes.Eq a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Enum.Enum (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
@@ -11999,8 +12024,6 @@ instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUSeconds -- Define
  instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Enum.Enum GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
@@ -12047,18 +12070,18 @@ instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Flo
  instance forall a b. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Float.RealFloat (f (g a)) => GHC.Internal.Float.RealFloat (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12387,6 +12410,8 @@ instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.
  instance forall (f :: * -> *) a. (GHC.Internal.Base.Applicative f, GHC.Internal.Num.Num a) => GHC.Internal.Num.Num (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Num.Num (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
  instance GHC.Internal.Num.Num GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
@@ -12421,8 +12446,6 @@ instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CULong -- Defined in
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Num.Num GHC.Internal.Types.Int -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Integer.Integer -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Num’
@@ -12564,10 +12587,10 @@ instance forall a b. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractio
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Fractional (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Integral (f (g a)) => GHC.Internal.Real.Integral (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12619,6 +12642,8 @@ instance GHC.Internal.Real.Real GHC.Internal.Bignum.Integer.Integer -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Real (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
  instance GHC.Internal.Real.Real GHC.Internal.Types.Word -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
@@ -12651,18 +12676,16 @@ instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CULong -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k a (b :: k). GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.RealFrac (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.RealFrac (f (g a)) => GHC.Internal.Real.RealFrac (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.RealFrac (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
  instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
@@ -12776,6 +12799,8 @@ instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Inter
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance GHC.Internal.Show.Show GHC.Internal.Real.FractionalExponentBase -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
@@ -12831,8 +12856,6 @@ instance GHC.Internal.Show.Show ghc-internal-10.100.0:GHC.Internal.Event.Manager
  instance GHC.Internal.Show.Show ghc-internal-10.100.0:GHC.Internal.Event.Manager.State -- Defined in ‘ghc-internal-10.100.0:GHC.Internal.Event.Manager’
  instance GHC.Internal.Show.Show ghc-internal-10.100.0:GHC.Internal.Event.TimerManager.State -- Defined in ‘ghc-internal-10.100.0:GHC.Internal.Event.TimerManager’
  instance GHC.Internal.Show.Show GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). GHC.Internal.Show.Show (f (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’

testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs

@@ -1597,6 +1597,29 @@ module Data.Ratio where
    denominator :: forall a. Ratio a -> a
    numerator :: forall a. Ratio a -> a
 +module Data.RealFloat where
 +  -- Safety: Safe
 +  pattern Infinity :: forall a. RealFloat a => a
 +  pattern NaN :: forall a. RealFloat a => a
 +  pattern NegInfinity :: forall a. RealFloat a => a
 +  type RealFloat :: * -> Constraint
 +  class (GHC.Internal.Real.RealFrac a, GHC.Internal.Float.Floating a) => RealFloat a where
 +    floatRadix :: a -> GHC.Internal.Bignum.Integer.Integer
 +    floatDigits :: a -> GHC.Internal.Types.Int
 +    floatRange :: a -> (GHC.Internal.Types.Int, GHC.Internal.Types.Int)
 +    decodeFloat :: a -> (GHC.Internal.Bignum.Integer.Integer, GHC.Internal.Types.Int)
 +    encodeFloat :: GHC.Internal.Bignum.Integer.Integer -> GHC.Internal.Types.Int -> a
 +    exponent :: a -> GHC.Internal.Types.Int
 +    significand :: a -> a
 +    scaleFloat :: GHC.Internal.Types.Int -> a -> a
 +    isNaN :: a -> GHC.Internal.Types.Bool
 +    isInfinite :: a -> GHC.Internal.Types.Bool
 +    isDenormalized :: a -> GHC.Internal.Types.Bool
 +    isNegativeZero :: a -> GHC.Internal.Types.Bool
 +    isIEEE :: a -> GHC.Internal.Types.Bool
 +    atan2 :: a -> a -> a
 +    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
++
  module Data.STRef where
    -- Safety: Safe
    type role STRef nominal representational
@@ -11987,6 +12010,8 @@ instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.In
  instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. (GHC.Internal.Enum.Enum a, GHC.Internal.Enum.Bounded a, GHC.Internal.Classes.Eq a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Enum.Enum (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
@@ -12026,8 +12051,6 @@ instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUSeconds -- Define
  instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Enum.Enum GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
@@ -12076,18 +12099,18 @@ instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Flo
  instance forall a b. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Float.RealFloat (f (g a)) => GHC.Internal.Float.RealFloat (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12416,6 +12439,8 @@ instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.
  instance forall (f :: * -> *) a. (GHC.Internal.Base.Applicative f, GHC.Internal.Num.Num a) => GHC.Internal.Num.Num (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Num.Num (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
  instance GHC.Internal.Num.Num GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
@@ -12450,8 +12475,6 @@ instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CULong -- Defined in
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Num.Num GHC.Internal.Types.Int -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Integer.Integer -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Num’
@@ -12593,10 +12616,10 @@ instance forall a b. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractio
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Fractional (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Integral (f (g a)) => GHC.Internal.Real.Integral (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12648,6 +12671,8 @@ instance GHC.Internal.Real.Real GHC.Internal.Bignum.Integer.Integer -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Real (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
  instance GHC.Internal.Real.Real GHC.Internal.Types.Word -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
@@ -12680,18 +12705,16 @@ instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CULong -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k a (b :: k). GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.RealFrac (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.RealFrac (f (g a)) => GHC.Internal.Real.RealFrac (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.RealFrac (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
  instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
@@ -12805,6 +12828,8 @@ instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Inter
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance GHC.Internal.Show.Show GHC.Internal.Real.FractionalExponentBase -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
@@ -12853,8 +12878,6 @@ instance forall a. GHC.Internal.Show.Show (GHC.Internal.Foreign.C.ConstPtr.Const
  instance forall a b. (GHC.Internal.Ix.Ix a, GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (GHC.Internal.Arr.Array a b) -- Defined in ‘GHC.Internal.Arr’
  instance GHC.Internal.Show.Show GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
  instance GHC.Internal.Show.Show GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). GHC.Internal.Show.Show (f (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’

testsuite/tests/interface-stability/base-exports.stdout-mingw32

@@ -1597,6 +1597,29 @@ module Data.Ratio where
    denominator :: forall a. Ratio a -> a
    numerator :: forall a. Ratio a -> a
 +module Data.RealFloat where
 +  -- Safety: Safe
 +  pattern Infinity :: forall a. RealFloat a => a
 +  pattern NaN :: forall a. RealFloat a => a
 +  pattern NegInfinity :: forall a. RealFloat a => a
 +  type RealFloat :: * -> Constraint
 +  class (GHC.Internal.Real.RealFrac a, GHC.Internal.Float.Floating a) => RealFloat a where
 +    floatRadix :: a -> GHC.Internal.Bignum.Integer.Integer
 +    floatDigits :: a -> GHC.Internal.Types.Int
 +    floatRange :: a -> (GHC.Internal.Types.Int, GHC.Internal.Types.Int)
 +    decodeFloat :: a -> (GHC.Internal.Bignum.Integer.Integer, GHC.Internal.Types.Int)
 +    encodeFloat :: GHC.Internal.Bignum.Integer.Integer -> GHC.Internal.Types.Int -> a
 +    exponent :: a -> GHC.Internal.Types.Int
 +    significand :: a -> a
 +    scaleFloat :: GHC.Internal.Types.Int -> a -> a
 +    isNaN :: a -> GHC.Internal.Types.Bool
 +    isInfinite :: a -> GHC.Internal.Types.Bool
 +    isDenormalized :: a -> GHC.Internal.Types.Bool
 +    isNegativeZero :: a -> GHC.Internal.Types.Bool
 +    isIEEE :: a -> GHC.Internal.Types.Bool
 +    atan2 :: a -> a -> a
 +    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
++
  module Data.STRef where
    -- Safety: Safe
    type role STRef nominal representational
@@ -12218,6 +12241,8 @@ instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.In
  instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. (GHC.Internal.Enum.Enum a, GHC.Internal.Enum.Bounded a, GHC.Internal.Classes.Eq a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Enum.Enum (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
@@ -12258,8 +12283,6 @@ instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUShort -- Defined
  instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Enum.Enum GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
  instance GHC.Internal.Enum.Enum GHC.Internal.Event.Windows.ConsoleEvent.ConsoleEvent -- Defined in ‘GHC.Internal.Event.Windows.ConsoleEvent’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Enum.Enum GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
  instance GHC.Internal.Enum.Enum GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
@@ -12306,18 +12329,18 @@ instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Flo
  instance forall a b. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.Floating GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Float.RealFloat (f (g a)) => GHC.Internal.Float.RealFloat (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Float.RealFloat GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
  instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12658,6 +12681,8 @@ instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.
  instance forall (f :: * -> *) a. (GHC.Internal.Base.Applicative f, GHC.Internal.Num.Num a) => GHC.Internal.Num.Num (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Num.Num (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
  instance GHC.Internal.Num.Num GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
@@ -12692,8 +12717,6 @@ instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CULong -- Defined in
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Num.Num GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Num.Num GHC.Internal.Types.Int -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Integer.Integer -- Defined in ‘GHC.Internal.Num’
  instance GHC.Internal.Num.Num GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Num’
@@ -12836,10 +12859,10 @@ instance forall a b. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractio
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Fractional (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Fractional GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Integral (f (g a)) => GHC.Internal.Real.Integral (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
@@ -12891,6 +12914,8 @@ instance GHC.Internal.Real.Real GHC.Internal.Bignum.Integer.Integer -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Bignum.Natural.Natural -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Real (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
  instance GHC.Internal.Real.Real GHC.Internal.Types.Word -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
  instance GHC.Internal.Real.Real GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
@@ -12923,18 +12948,16 @@ instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CULong -- Defined i
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Real.Real GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k a (b :: k). GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.RealFrac (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
  instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.RealFrac (f (g a)) => GHC.Internal.Real.RealFrac (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
  instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.RealFrac (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 -instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
  instance GHC.Internal.Real.RealFrac GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
 +instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
  instance forall k a (b :: k). GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
  instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
@@ -13048,6 +13071,8 @@ instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Inter
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
  instance GHC.Internal.Show.Show GHC.Internal.Real.FractionalExponentBase -- Defined in ‘GHC.Internal.Real’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 +instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
  instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
@@ -13100,8 +13125,6 @@ instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Inter
  instance GHC.Internal.Show.Show GHC.Internal.Event.Windows.HandleKey -- Defined in ‘GHC.Internal.Event.Windows’
  instance GHC.Internal.Show.Show GHC.Internal.Event.Windows.FFI.IOCP -- Defined in ‘GHC.Internal.Event.Windows.FFI’
  instance GHC.Internal.Show.Show GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Double -- Defined in ‘GHC.Internal.Float’
 -instance GHC.Internal.Show.Show GHC.Internal.Types.Float -- Defined in ‘GHC.Internal.Float’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
  instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). GHC.Internal.Show.Show (f (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’

testsuite/tests/interface-stability/base-exports.stdout-ws-32 deleted The diff for this file was not included because it is too large.

testsuite/tests/th/T27022.hs

 +{-# LANGUAGE TemplateHaskell #-}
 +-- | This tests the behaviour of TH's recover method.
 +-- It should behave the same in the internal and external interperter.
 +-- In the past, they have diverged, and the external interpreter would roll back the state of putQ/getQ whereas the internal interpreter would not.
 +module Main where
++
 +import Language.Haskell.TH.Syntax
 +main = print $(putQ "0" >> recover (pure ()) (putQ "42" >> fail "oops")  >> getQ @String >>= lift )

testsuite/tests/th/T27022.stdout

+Just "42"

testsuite/tests/th/all.T

@@ -650,3 +650,4 @@ test('GadtConSigs_th_dump1', normal, compile, ['-v0 -ddump-splices -dsuppress-un
  test('T26099', normal, compile_fail, [''])
  test('T8306_th', only_ways(['ghci']), ghci_script, ['T8306_th.script'])
  test('T26862_th', only_ways(['ghci']), ghci_script, ['T26862_th.script'])
 +test('T27022', normal, compile_and_run, [''])