Carview!

at least

2025 Aug    - LTS 9.14 released
2028 Spring - LTS 9.22 released
2028 Summer - LTS 9.14.X - last 9.14 point release
2031 Spring  - LTS 9.X released
2031 Summer - Last 9.22 point release
...
hadrian <args>
hadrian <stage>:{lib,exe}:<package name>
hadrian/build --flavour=release binary-dist
# Build only the documentation for the base package, without using sphinx
hadrian {..} docs:base --docs=no-sphinx
hadrian {..} "*.*.ghc.*.opts += -my-ghc-option"
hadrian {..} "*.ghc.ghc.*.opts += -my-ghc-option"
foreign import ccall "hello_world" helloWorld :: IO ()
foreign import capi "stdio.h puts" c_puts :: Ptr CChar -> IO CInt
#include "stdio.h"
HsInt32 ghczuwrapperZC0ZCmainZCHelloZCputs(void* a1) {
    return puts(a1);
}
-- Recall that:
--   newPinnedByteArray       :: Int -> IO (MutableByteArray RealWorld)
--   setByteArray             :: Prim a => MutableByteArray RealWorld -> Int -> Int -> a -> IO ()
--   mutableByteArrayContents :: MutableByteArray RealWorld -> Ptr a
import Data.Primitive.ByteArray

main = printDots 10

printDots :: Int -> IO ()
printDots len = do
    arr <- newPinnedByteArray len
    setByteArray arr 0 len (fromIntegral $ ord '.' :: Word8)
    let ptr :: Ptr CChar
        ptr = byteArrayContents arr
    puts ptr

-- Recall that:
--   void puts(const char *);
foreign import ccall "puts"
    puts :: Ptr CChar -> IO ()
touch :: forall a. a -> IO ()
printDots len = 
    arr <- newPinnedByteArray len
    setByteArray arr 0 len (fromIntegral $ ord '.' :: Word8)
    puts (byteArrayContents arr)
    touch arr
hdl <- openFile "hello.txt"
hPutStrLn hdl "hello world!"
hClose hdl
withFile "hello.txt" $ \hdl ->
    hPutStrLn hdl "hello world!"
doThings =
    case error "hello world" :: Int of
      0  ->  {- some large expression -}
      1  ->  {- another large expression -}
      ...
doThings =
    case error "hello world" :: Int of { }
printManyDots :: Int -> IO ()
printManyDots len = do
    arr <- newPinnedByteArray len
    setByteArray arr 0 len (fromIntegral $ ord '.' :: Word8)
    forever $ puts (byteArrayContents arr)
    touch arr
with :: a -> (a -> m b) -> m b
readWord8_touch :: ForeignPtr Word8 -> IO Word8
readWord8_touch fptr = do
    n <- peek (unsafeForeignPtrToPtr fptr)
    touch fptr
    return n
readWord8_touch :: ForeignPtr Word8 -> IO Word8
readWord8_touch fptr = IO (\s0 ->
    case readWord8# (unsafeForeignPtrToPtr fptr) s0 of (# s1, n #) ->
    case touch# fptr s1 of s2 -> 
      (# s2, W8# n #)
-- The worker:
worker_readWord8_touch :: ForeignPtr Word8 -> State# RealWorld -> (# State# RealWorld, Word8# #)
worker_readWord8_touch fptr s0 =
    case peek (unsafeForeignPtrToPtr fptr) s0 of (# s0, n #) ->
    case touch# fptr s0 of s1 ->
      (# s1, n #)

-- The wrapper:
readWord8_touch :: ForeignPtr Word8 -> IO Word8
readWord8_touch fptr = IO $ \s ->
    case worker_readWord fptr s of (# s1, n #) ->
      (# s1, W8# n #)
{-# INLINE readWord8_touch #-}
readWord8_with :: ForeignPtr Word8 -> IO Word8
readWord8_with fptr = with fptr $ \fptr' -> IO $ \s0 ->
    case peek (unsafeForeignPtrToPtr fptr') s0 of (# s1, n #) ->
      (# s1, W8# n #)
with# :: forall a (r :: RuntimeRep) (b :: TYPE r).
         a -> (a -> b) -> b
with# :: forall a (r :: RuntimeRep) (b :: TYPE r).
         a -> State# s -> (State# s -> b) -> b
case (with# x s (\s' -> k)) of alt -> rhs
with# x s (\s' -> case k of alt -> rhs)
IO $ \s0 ->
  case readWord8 fptr s0 of (# s1, n #) ->
  case n of W8# n# ->
    doSomething n#
IO $ \s0 ->
  case (
    with# fptr s0 (\s1 ->
      case peek (unsafeForeignPtrToPtr fptr') s1 of (# s2, n# #) ->
        (# s2, W8# n# #)
    )
  ) of (# s3, n #) ->
  case n of W8# n# ->
    doSomething n#
IO $ \s0 ->
  with# fptr s0 (\s1 ->
    case (
      case peek (unsafeForeignPtrToPtr fptr') s1 of (# s2, n# #) ->
        (# s2, W8# n# #)
    ) of (# s3, n #) ->
    case n of W8# n# ->
      doSomething n#
  )
IO $ \s0 ->
  with# fptr s0 (\s1 ->
    case peek (unsafeForeignPtrToPtr fptr') s1 of (# s2, n# #) ->
      doSomething n#
  )
sumArray :: ForeignPtr Word8    -- ^ an array of Word8s
         -> Int                 -- ^ array length
         -> IO Word8
sumArray fptr n = IO (go 0# n)
  where
    go :: Word8# -> Int -> State# RealWorld -> (# State# RealWorld, Word8 #)
    go accum 0 s0 = (# s0, W8# accum #)
    go accum i s0 =
      case readWord8 (fptr `plusForeignPtr` i) s0 of (# s1, n #) ->
      case n of W8# n# ->
        go (accum +# n#) (i-1) s1
    go accum i s0 =
      with# (fptr `plusForeignPtr` i) s0 (\s1 ->
        case peek (unsafeForeignPtrToPtr (fptr `plusForeignPtr` i)) s1 of (# s2, n# #) ->
          go (accum +# n#) (i-1) s1
with# :: forall a (r :: RuntimeRep) (b :: TYPE r).
        a -> State# s -> (State# s -> b) -> b
-- Recall that
--   with# :: forall a (r :: RuntimeRep) (b :: TYPE r).
--            a -> State# s -> (State# s -> b) -> b

with# x s0 (\s0 -> k)
case k s0 of r ->
case touch# x s0 of s1 ->
  r
keepAlive# :: forall (lev :: Levity) (a :: TYPE (BoxedRep lev))
                     (rep :: RuntimeRep) (b :: TYPE rep) s.
              a
           -> State# s
           -> (State# s -> b)
           -> b
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr fptr k = do
    k (unsafeForeignPtrToPtr fptr)
    touch fptr
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr fptr k = IO $ \s0 -> 
    keepAlive# fptr s0 (unIO $ k (unsafeForeignPtrToPtr fptr))
withForeignPtr fptr (peek @Word8)
foo :: ByteArray -> IO ()
foo x = do
    doSomething x                        -- (a)
    ...
    doForeignCall (byteArrayContents x)  -- (b)
    ...
    touch x                              -- (c)
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr fptr k = do
    k (unsafeForeignPtrToPtr fptr)
    touch fptr
data Word8 = W8# Word#
foreign import ccall "f" f :: Word8 -> IO ()
-- today we have:
data Word8 = W8# Word#

-- in the glorious future we will have:
data Word8 = W8# Word8#
indexWord8Array# :: ByteArray# -> Int# -> Word#
-- today:
indexWord8Array# :: ByteArray# -> Int# -> Word#

-- the glorious future:
indexWord8Array# :: ByteArray# -> Int# -> Word8#
GHC.Exts.narrowWord8#  :: GHC.Prim.Word#    -> GHC.Prim.Word8#
GHC.Exts.extendWord8#  :: GHC.Prim.Word8#   -> GHC.Prim.Word#

GHC.Exts.narrowWord16# :: GHC.Prim.Word#    -> GHC.Prim.Word16#
GHC.Exts.extendWord16# :: GHC.Prim.Word16#  -> GHC.Prim.Word#

GHC.Exts.narrowInt8#   :: GHC.Prim.Int#     -> GHC.Prim.Int8#
GHC.Exts.extendInt8#   :: GHC.Prim.Int8#    -> GHC.Prim.Int#

GHC.Exts.narrowInt16#  :: GHC.Prim.Int#     -> GHC.Prim.Int16#
GHC.Exts.extendInt16#  :: GHC.Prim.Int16#   -> GHC.Prim.Int#
GHC.Exts.narrowWord64#  :: GHC.Prim.Word#   -> GHC.Prim.Word64#
GHC.Exts.extendWord64#  :: GHC.Prim.Word64# -> GHC.Prim.Word#
GHC.Exts.wordToWord64#  :: GHC.Prim.Word#   -> GHC.Prim.Word64#
GHC.Exts.word64ToWord#  :: GHC.Prim.Word64# -> GHC.Prim.Word#

GHC.Exts.wordToWord32#  :: GHC.Prim.Word#   -> GHC.Prim.Word32#
GHC.Exts.word32ToWord#  :: GHC.Prim.Word32# -> GHC.Prim.Word#

-- et cetera
$ cabal unpack optics-th
$ cd optics-th-0.3
$ cabal v2-build lib:optics-th \
    --enable-profiling --write-ghc-environment-files=always
$ ghc -prof -fexternal-interpreter -opti+RTS -opti-p tests/Optics/TH/Tests/T799.hs 
$ cat ghc-iserv-prof.prof 
	Sun May 24 17:20 2020 Time and Allocation Profiling Report  (Final)
	   ghc-iserv-prof +RTS -p -RTS 12 13
	total time  =        0.25 secs   (253 ticks @ 1000 us, 1 processor)
	total alloc =   4,607,184 bytes  (excludes profiling overheads)
COST CENTRE         MODULE                       SRC                                                     %time %alloc
MAIN                MAIN                         <built-in>                                               96.8   82.0
reifyDatatype       Language.Haskell.TH.Datatype src/Language/Haskell/TH/Datatype.hs:353:1-70              1.2    1.9
makeFieldOptics     Optics.TH.Internal.Product   src/Optics/TH/Internal/Product.hs:63:1-101                0.8    7.6
resolveTypeSynonyms Language.Haskell.TH.Datatype src/Language/Haskell/TH/Datatype.hs:(1257,1)-(1303,28)    0.4    5.7
...
$ ghc -prof -fexternal-interpreter -opti+RTS -opti-p -opti-hy tests/Optics/TH/Tests/T799.hs 
$ sudo apt-get install llvm-9
$ wget https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-armv7-deb9-linux.tar.xz
$ tar -xf ghc-8.10.1-armv7-deb9-linux.tar.gz
$ cd ghc-8.10.1
$ ./configure CONF_CC_OPTS_STAGE2="-marm -march=armv7-a" CFLAGS="-marm -march=armv7-a"
$ sudo make install
$ ghc --version
$ cat > Hello.hs <<EOF
> main = putStrLn "hello world!"
> EOF
$ ghc Hello.hs
$ ./Hello
hello world!
$ ghci
GHCi, version 8.10.1: https://www.haskell.org/ghc/  :? for help
Prelude> putStrLn $ cycle "turtles all the way down.\n"
turtles all the way down.
turtles all the way down.
turtles all the way down.
...
f :: (Int, String) -> Int
f (x, _) = x + 4
f :: (Int, String) -> Int
f pair =
  case pair of (x, _) -> 
  case x of I# x# ->
  case $wf x# of result ->
    I# result

$wf :: Int# -> Int#
$wf x# = x# + 4
$ perf record vector-tests-O0
Samples: 145K of event 'cycles:ppp', Event count (approx.): 98781024840
Overhead  Command          Shared Object       Symbol
  10.19%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_quotInteger_info
   5.02%  vector-tests-O0  vector-tests-O0     [.] evacuate
   3.58%  vector-tests-O0  vector-tests-O0     [.] stg_upd_frame_info+0xffffffffffc00000
   3.28%  vector-tests-O0  vector-tests-O0     [.] QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziGen_zdwzdsgamma_info
   2.96%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_timesInteger_info
   2.93%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_minusInteger_info
   2.67%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_testBitInteger_info
   2.34%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_eqIntegerzh_info
   2.30%  vector-tests-O0  vector-tests-O0     [.] randomzm1zi1zmc60864d5616c60090371cdf8e600240f388e8a9bd87aa769d8045bda89826ee2_SystemziRandom_zdwrandomIvalInteger_info
   2.18%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_plusInteger_info
   2.16%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_divInteger_info
   1.71%  vector-tests-O0  vector-tests-O0     [.] QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziGen_zdwilog2_info
   1.63%  vector-tests-O0  vector-tests-O0     [.] stg_ap_p_info+0xffffffffffc00010
   1.52%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_remInteger_info
   1.36%  vector-tests-O0  vector-tests-O0     [.] hs_popcnt64
   1.34%  vector-tests-O0  vector-tests-O0     [.] stg_PAP_apply
   1.23%  vector-tests-O0  vector-tests-O0     [.] stg_ap_0_fast
   1.22%  vector-tests-O0  vector-tests-O0     [.] stg_gc_noregs
   1.20%  vector-tests-O0  vector-tests-O0     [.] stg_newByteArrayzh
   1.15%  vector-tests-O0  vector-tests-O0     [.] stg_ap_pp_info+0xffffffffffc00000
   1.11%  vector-tests-O0  vector-tests-O0     [.] _randomzm1zi1zmc60864d5616c60090371cdf8e600240f388e8a9bd87aa769d8045bda89826ee2_SystemziRandom_b1_siHV_entry
   0.98%  vector-tests-O0  vector-tests-O0     [.] integerzmwiredzmin_GHCziIntegerziType_geIntegerzh_info
   0.98%  vector-tests-O0  vector-tests-O0     [.] stg_BLACKHOLE_info+0xffffffffffc00069
   0.92%  vector-tests-O0  vector-tests-O0     [.] scavenge_block
...
$ vector-tests-O0 >/dev/null & sleep 0.2; kill -QUIT %1
Caught SIGQUIT; Backtrace:
                 0x1387442    set_initial_registers (rts/Libdw.c:288.0)
            0x7feecbf2b0e0    dwfl_thread_getframes (/nix/store/35vnzk39hwsx18d1bkcd30r5xrx026mr-elfutils-0.176/lib/libdw-0.176.so)
            0x7feecbf2ab4e    get_one_thread_cb (/nix/store/35vnzk39hwsx18d1bkcd30r5xrx026mr-elfutils-0.176/lib/libdw-0.176.so)
            0x7feecbf2aea3    dwfl_getthreads (/nix/store/35vnzk39hwsx18d1bkcd30r5xrx026mr-elfutils-0.176/lib/libdw-0.176.so)
            0x7feecbf2b479    dwfl_getthread_frames (/nix/store/35vnzk39hwsx18d1bkcd30r5xrx026mr-elfutils-0.176/lib/libdw-0.176.so)
                 0x1387abd    libdwGetBacktrace (rts/Libdw.c:259.0)
                 0x1373b26    backtrace_handler (rts/posix/Signals.c:534.0)
            0x7feecbf7185f    (null) (/nix/store/g2p6fwjc995jrq3d8vph7k45l9zhdf8f-glibc-2.27/lib/libpthread-2.27.so)
                 0x137f24f    _rts_stgzuapzup_ret (_build/stage1/rts/build/cmm/AutoApply.cmm:654.18)
                 0x137de10    stg_upd_frame_info (rts/Updates.cmm:31.1)
                  0xa7cc80    _randomzm1zi1zmc60864d5616c60090371cdf8e600240f388e8a9bd87aa769d8045bda89826ee2_SystemziRandom_lvl6_siHP_entry (System/Random.hs:489.70)
                 0x12c52d8    integerzmwiredzmin_GHCziIntegerziType_minusInteger_info (libraries/integer-gmp/src/GHC/Integer/Type.hs:437.1)
                  0xa7d098    randomzm1zi1zmc60864d5616c60090371cdf8e600240f388e8a9bd87aa769d8045bda89826ee2_SystemziRandom_zdwrandomIvalInteger_info (System/Random.hs:487.20)
                  0x98da50    _QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziArbitrary_sat_sx8e_entry (Test/QuickCheck/Arbitrary.hs:988.26)
                 0x137de10    stg_upd_frame_info (rts/Updates.cmm:31.1)
...
                 0x137c810    stg_stop_thread_info (rts/StgStartup.cmm:42.1)
                 0x136571b    StgRunJmp (rts/StgCRun.c:370.0)
                 0x136241b    scheduleWaitThread (rts/Capability.h:219.0)
                 0x135f35e    hs_main (rts/RtsMain.c:73.0)
                  0x455df4    (null) (/opt/exp/ghc/ghc-8.10/vector/dist-newstyle/build/x86_64-linux/ghc-8.10.0.20191231/vector-0.13.0.1/t/vector-tests-O0/build/vector-tests-O0/vector-tests-O0)
            0x7feecbd4ab8e    __libc_start_main (/nix/store/g2p6fwjc995jrq3d8vph7k45l9zhdf8f-glibc-2.27/lib/libc-2.27.so)
                  0x40a82a    _start (../sysdeps/x86_64/start.S:122.0)
-- | A source location.
data Location = {- ... -}

-- | Returns a stack trace of the calling thread or 'Nothing'
-- if the runtime system lacks libdw support.
getStackTrace :: IO (Maybe [Location])
getThreadStackTrace :: ThreadId -> IO (Maybe [Location])
data WithStack e = WithStack (Maybe [Location]) e
instance Exception (WithStack e)

throwIOWithStack :: e -> IO a
throwIOWithStack exc = do
 stack <- getStackTrace
 throwM $ WithStack stack exc

throwWithStack :: e -> a
throwWithStack = unsafePerformIO . throwIOWithStack

-- | Attach a stack trace to any exception thrown by the enclosed action.
-- Note that this is idempotent.
addStack :: IO a -> IO a
addStack = handle f
  where
    f :: SomeException -> IO b
    f exc | WithStack{} <- fromException exc =
      throwIO exc  -- ensure idempotency
    f (SomeException exc) =
      throwIOWithStack exc
data SomeException where
    SomeException :: forall e. Exception e
                  => Maybe [Location]  -- ^ backtrace, if available
                  -> e                 -- ^ the exception
                  -> SomeException

-- | A representation of source locations consolidating 'GHC.Stack.SrcLoc',
-- 'GHC.Stack.CostCentre', and 'GHC.ExecutionStack.Location'.
data Location = {- ... -}

-- | Throws an exception with no stack trace.
throwIO :: e -> IO a

-- | Throws an exception with a stack trace captured via
-- 'GHC.Stack.getStackTrace'.
throwIOWithExecutionStack :: e -> IO a

-- | Throws an exception with a `HasCallStack` stack trace.
throwIOWithCallStack :: HasCallStack => e -> IO a
-- | Throws an exception with a stack trace using the most
-- precise method available in the current build configuration.
throwIOWithStack :: HasCallStack => e -> IO a
throwIOWithStack
  | profiling_enabled = throwIOWithCostCentreStack
  | dwarf_enabled     = throwIOWithExecutionStack
  | otherwise         = throwIOWithCallStack
catchWithLocation :: IO a -> (e -> Maybe [Location] -> IO a) -> IO a
$ gdb vector-tests-O0
GNU gdb (GDB) 8.3
...
Reading symbols from dist-newstyle/.../vector-tests-O0...
(gdb) run
Using host libthread_db library "/nix/store/pnd2kl27sag76h23wa5kl95a76n3k9i3-glibc-2.27/lib/libthread_db.so.1".
Data.Vector.Fusion.Bundle:
  fromList.toList == id: [OK, passed 100 tests]
  toList.fromList == id: [OK, passed 100 tests]
...
  postscanr: [OK, passed 100 tests]
  postscanr': [OK, passed 100 tests]
^C
Program received signal SIGINT, Interrupt.
stg_ap_pp_fast () at _build/stage1/rts/build/cmm/AutoApply.cmm:3708
3708	        default: {
(gdb) bt
#0  stg_ap_pp_fast () at _build/stage1/rts/build/cmm/AutoApply.cmm:3708
#1  0x000000000137de10 in _rts_stgzuupdzuframe_ret ()
#2  0x0000000000997668 in QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziArbitrary_zdfCoArbitraryAll1_info () at Test/QuickCheck/Arbitrary.hs:1230
#3  0x000000000137de10 in _rts_stgzuupdzuframe_ret ()
...
#54 0x0000000000997668 in QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziArbitrary_zdfCoArbitraryAll1_info () at Test/QuickCheck/Arbitrary.hs:1230
#55 0x000000000137de10 in _rts_stgzuupdzuframe_ret ()
#56 0x0000000001316510 in ghczmprim_GHCziClasses_zdfEqBoolzuzdczeze_info () at libraries/ghc-prim/GHC/Classes.hs:205
#57 0x0000000000643698 in r5bd2_info () at Data/Vector.hs:289
#58 0x000000000137de10 in _rts_stgzuupdzuframe_ret ()
#59 0x00000000009bc478 in s1TRr_info () at Test/QuickCheck/Property.hs:225
#60 0x00000000009bbc88 in s1TQC_info () at Test/QuickCheck/Property.hs:190
#61 0x0000000001375f50 in _rts_stgzucatchzuframe_ret () at rts/Exception.cmm:335
#62 0x00000000009bbe08 in s1TQX_info () at Test/QuickCheck/Property.hs:252
#63 0x00000000009b7670 in s1TIa_info () at Test/QuickCheck/Property.hs:216
...
#68 0x00000000009b7670 in s1TIa_info () at Test/QuickCheck/Property.hs:216
#69 0x00000000009b7c18 in s1TIJ_info () at Test/QuickCheck/Property.hs:207
#70 0x00000000009b7670 in s1TIa_info () at Test/QuickCheck/Property.hs:216
#71 0x00000000009b7670 in s1TIa_info () at Test/QuickCheck/Property.hs:216
#72 0x00000000009bff88 in QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziProperty_reduceRose1_info () at Test/QuickCheck/Property.hs:232
#73 0x00000000009e18a8 in s2eT1_info () at Test/QuickCheck/Test.hs:331
#74 0x0000000001375f50 in _rts_stgzucatchzuframe_ret () at rts/Exception.cmm:335
#75 0x00000000009e2380 in QuickCheckzm2zi13zi2zmac90a2a0d9e0dd2c227d795a9d4d9de22a119c3781b679f3b245300e1b658c43_TestziQuickCheckziTest_quickCheck4_info () at Test/QuickCheck/Test.hs:333
#76 0x00000000007479b0 in s4py_info () at Test/Framework/Providers/QuickCheck2.hs:114
#77 0x0000000000755cf8 in s2dc_info () at Test/Framework/Improving.hs:68
#78 0x0000000000762080 in r6ny_info () at Test/Framework/Runners/ThreadPool.hs:62
#79 0x0000000001375f50 in _rts_stgzucatchzuframe_ret () at rts/Exception.cmm:335
#80 0x000000000137c810 in _rts_stgzustopzuthread_ret ()
#81 0x000000000136571b in StgRunIsImplementedInAssembler () at rts/StgCRun.c:370
#82 0x000000000136241b in schedule (task=0x175aa00, initialCapability=<optimized out>) at rts/Schedule.c:467
#83 scheduleWaitThread (tso=<optimized out>, ret=ret@entry=0x0, pcap=pcap@entry=0x7fffffff5210) at rts/Schedule.c:2600
#84 0x000000000138b204 in rts_evalLazyIO (cap=cap@entry=0x7fffffff5210, p=p@entry=0x14122d0, ret=ret@entry=0x0) at rts/RtsAPI.c:530
#85 0x000000000135f35e in hs_main (argc=<optimized out>, argv=<optimized out>, main_closure=0x14122d0, rts_config=...) at rts/RtsMain.c:72
#86 0x0000000000455df4 in main ()
(gdb) 
f :: [Int] -> Int
f = sum . map (* 42)
tail_caller :: [Int] -> Int
tail_caller xs = sum xs

sum :: [Int] -> Int
sum xs = foldl' (+) 0 xs
(gdb) break Test/Framework/Improving.hs:68
(gdb) cont
Continuing.
Breakpoint 1, s2dc_info () at Test/Framework/Improving.hs:68
68	Test/Framework/Improving.hs: No such file or directory.
(gdb) bt
#0  s2dc_info () at Test/Framework/Improving.hs:68
#1  0x0000000000762080 in r6ny_info () at Test/Framework/Runners/ThreadPool.hs:62
#2  0x0000000001375f50 in _rts_stgzucatchzuframe_ret () at rts/Exception.cmm:335
#3  0x000000000137c810 in _rts_stgzustopzuthread_ret ()
#4  0x000000000136571b in StgRunIsImplementedInAssembler () at rts/StgCRun.c:370
#5  0x000000000136241b in schedule (task=0x175aa00, initialCapability=<optimized out>) at rts/Schedule.c:467
#6  scheduleWaitThread (tso=<optimized out>, ret=ret@entry=0x0, pcap=pcap@entry=0x7fffffff5210) at rts/Schedule.c:2600
#7  0x000000000138b204 in rts_evalLazyIO (cap=cap@entry=0x7fffffff5210, p=p@entry=0x14122d0, ret=ret@entry=0x0) at rts/RtsAPI.c:530
#8  0x000000000135f35e in hs_main (argc=<optimized out>, argv=<optimized out>, main_closure=0x14122d0, rts_config=...) at rts/RtsMain.c:72
#9  0x0000000000455df4 in main ()
$ git clone https://github.com/haskell/vector
$ cd vector
$ cat >>cabal.project.local <<EOF
allow-newer: base
package vector
  tests: True
package *
  debug-info: 2
EOF
$ cabal new-build vector-tests-O0

flavour name	description
`perf`	A fully optimised bindist
`release`	The same configuration as `perf`, but with additional build products such as interface files containing Haddock docs

Make variable	Hadrian flavour transformer
`GhcProfiled`	`profiled_ghc`
`GhcDebugged`	`debug_ghc`
`SplitObjs`	`split_sections`

Make variable	Hadrian key-value setting
`GhcLibOpts`	`..ghc.*.opts`
`GhcRtsHcOpts`	`..rts.*.opts`
`SRC_HC_OPTS`, `EXTRA_HC_OPTS`	`..ghc.hs.opts`
`SRC_CC_OPTS`, `EXTRA_CC_OPTS`	`..ghc.c.opts` with `-optc` prefix
`SRC_CPP_OPTS`, `EXTRA_CPP_OPTS`	a combination of `..ghc.c.opts` with `-optc` prefix and `..cc.c.opts`
`SRC_LD_OPTS`, `EXTRA_LD_OPTS`	`..ghc.link.opts` with `-optl` prefix
`<pkg>_EXTRA_LD_OPTS`	`*.<pkg>.ghc.link.opts` with `-optl` prefix
`<pkg>_CONFIGURE_OPTS`	`*.<pkg>.cabal.configure.opts`
`utils/hsc2hs_dist-install_EXTRA_LD_OPTS`	`..hsc2hs.run.opt` with `-L` prefix

Attribute	`perf`	cost-center profiler
Runtime impact	negligible	anywhere from moderate to high
Relatability to source program	often hard to relate back to source program	profile structure directly reflects cost centers declared in source program
Provides call graphs	yes, with limited depth	yes
Provides call graphs on Haskell programs	not currently	yes
Profiled variables	time, allocations, micro-architectural counters, system calls, user- and kernel-space probe points	time, allocations
Determinism	profile is statistical and will likely vary from run to run	deterministic

attribute	frame pointer	LBR	DWARF
maximum depth	unlimited	32 on Skylake	unlimited
runtime overhead	negligible	negligible	small
compatible with GHC execution model	no	yes?	not currently

mangled	`ghczmprim_GHCziClasses_zdfEqBoolzuzdczeze_info`
demangled	`ghc-prim_GHC.Classes_$fEqBool_$c==_info`

zubin - 2025-12-27

zubin - 2025-12-19

wz1000 - 2025-12-11

zubin - 2025-12-01

wz1000 - 2025-11-11

zubin - 2025-11-04

bgamari - 2025-10-30

bgamari - 2025-10-09

wz1000 - 2025-09-22

bgamari - 2025-09-12

Zubin Duggal - 2025-09-10

bgamari - 2025-08-19

wz1000 - 2025-08-18

wz1000 - 2025-08-08

wz1000 - 2025-08-06

wz1000 - 2025-07-28

Andreas Klebinger - 2025-07-07

GHC will start maintaining an LTS release/branch in the near future

Non-LTS releases

Why LTS releases?

Why not make post-hoc LTS releases official instead?

Next steps

Zubin Duggal - 2025-05-03

bgamari - 2025-04-18

Luite Stegeman - 2025-03-24

Ben Gamari - 2025-03-14

Ben Gamari - 2025-02-26

Zubin Duggal - 2024-12-16

Ben Gamari - 2024-12-02

Zubin Duggal - 2024-11-29

Zubin Duggal - 2024-11-14

Zubin Duggal - 2024-11-05

Ben Gamari - 2024-10-20

Zubin Duggal - 2024-10-16

Zubin Duggal - 2024-07-01

Hécate - 2024-06-13

Zubin Duggal - 2024-05-21

9.10

9.6

9.8

Conclusion

bgamari - 2024-05-10

bgamari - 2024-04-27

Zubin Duggal - 2024-04-16

bgamari - 2024-04-15

bgamari - 2024-03-29

bgamari - 2024-03-13

Zubin Duggal - 2024-02-23

Zubin Duggal - 2024-01-09

Zubin Duggal - 2023-11-10

bgamari - 2023-10-09

bgamari - 2023-09-29

Bryan Richter - 2023-09-25

bgamari - 2023-09-19

Zubin Duggal - 2023-08-25

bgamari - 2023-08-23

bgamari - 2023-08-09

Zubin Duggal - 2023-08-07

bgamari - 2023-07-27

Zubin Duggal - 2023-05-26

Ben Gamari - 2023-05-23

Zubin Duggal - 2023-04-18

bgamari - 2023-03-10

bgamari - 2023-03-03

Zubin Duggal - 2023-02-27

bgamari - 2023-02-13

Zubin Duggal - 2023-02-10

bgamari - 2023-01-30

bgamari - 2023-01-13

bgamari - 2022-12-24

Zubin Duggal - 2022-11-07

bgamari - 2022-11-03

bgamari - 2022-08-22

bgamari - 2022-08-07

Sam Derbyshire - 2022-08-05

The Hadrian build system

Building Hadrian

Bootstrapping Hadrian

Using Hadrian

How does Hadrian replace make?

Safe foreign calls via `CApiFFI`

The shortcomings of `touch#`

Generating code for `with#`

`keepAlive#` in GHC 9.0

Introducing `unsafeWithForeignPtr`