ghcBindists = let version = ghc.version; in {

     aarch64-darwin = hostPkgs.fetchurl {

       url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-aarch64-apple-darwin.tar.xz";

     };

     x86_64-darwin = hostPkgs.fetchurl {

       url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";

     };

   };

   ghc = pkgs.stdenv.mkDerivation rec {

     name = "ghc";

     src = ghcBindists.${pkgs.stdenv.hostPlatform.system};

     configureFlags = [

 optimised and built in various ways (eg. profiling libs are built).

 It can take a long time.  To customise the build, see the file `HACKING.md`.

 Filing bugs and feature requests

 ================================

   | InitArray           -- .init_array on ELF, .ctor on Windows

   | FiniArray           -- .fini_array on ELF, .dtor on Windows

   | CString

   | OtherSection String

   deriving (Show)

     CString                 -> ReadOnlySection

     Data                    -> ReadWriteSection

     UninitialisedData       -> ReadWriteSection

     (OtherSection _)        -> ReadWriteSection

 {-

   InitArray               -> text "initarray"

   FiniArray               -> text "finiarray"

   CString                 -> text "cstring"

   OtherSection s'         -> text s'

        Data

         | ppc64          -> text ".align 3"

         | otherwise      -> text ".align 2"

        ReadOnlyData

         | ppc64          -> text ".align 3"

         | otherwise      -> text ".align 2"

         | OSMinGW32 <- platformOS platform

                     -> text ".rdata"

         | otherwise -> text ".rodata.str"

       OtherSection _ ->

         panic "PprBase.pprGNUSectionHeader: unknown section type"

     flags = case t of

         | OSMinGW32 <- platformOS platform

                     -> empty

         | otherwise -> text ",\"aMS\"," <> sectionType platform "progbits" <> text ",1"

       _ -> empty

 {-# SPECIALIZE pprGNUSectionHeader :: NCGConfig -> SectionType -> CLabel -> SDoc #-}

 {-# SPECIALIZE pprGNUSectionHeader :: NCGConfig -> SectionType -> CLabel -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

   RelocatableReadOnlyData -> text ".csect .text[PR] # RelocatableReadOnlyData"

   CString                 -> text ".csect .text[PR] # CString"

   UninitialisedData       -> text ".csect .data[BS]"

   _                       -> panic "pprXcoffSectionHeader: unknown section type"

 {-# SPECIALIZE pprXcoffSectionHeader :: SectionType -> SDoc #-}

 {-# SPECIALIZE pprXcoffSectionHeader :: SectionType -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

   InitArray               -> text ".section\t__DATA,__mod_init_func,mod_init_funcs"

   FiniArray               -> panic "pprDarwinSectionHeader: fini not supported"

   CString                 -> text ".section\t__TEXT,__cstring,cstring_literals"

   OtherSection _          -> panic "pprDarwinSectionHeader: unknown section type"

 {-# SPECIALIZE pprDarwinSectionHeader :: SectionType -> SDoc #-}

 {-# SPECIALIZE pprDarwinSectionHeader :: SectionType -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

     CString                 -> case platformOS p of

                                  OSMinGW32 -> fsLit ".rdata$str"

                                  _         -> fsLit ".rodata.str"

     InitArray               -> panic "llvmSectionType: InitArray"

     FiniArray               -> panic "llvmSectionType: FiniArray"

     OtherSection _          -> panic "llvmSectionType: unknown section type"

 If the field indicates that the data has been compressed, the entry data and

 strings table are decompressed before continuing with the normal IPE map

 construction.

 -}

 emitIpeBufferListNode ::

         ipe_buffer_lbl :: CLabel

         ipe_buffer_lbl = mkIPELabel this_mod

         ipe_buffer_node :: [CmmStatic]

         ipe_buffer_node = map CmmStaticLit

           [ -- 'next' field

             zeroCLit platform

             -- 'compressed' field

           , int do_compress

     -- Emit the strings table

     emitDecl $ CmmData

     -- Emit the list of IPE buffer entries

     emitDecl $ CmmData

     -- Emit the IPE buffer list node

     emitDecl $ CmmData

     In a test compiling GHC itself, the size of the :ghc-flag:`-finfo-table-map`

     enabled build results was reduced by over 20% when compression was enabled.

     :since: 9.10

     :implies: :ghc-flag:`-finfo-table-map-with-stack`

     :implies: :ghc-flag:`-finfo-table-map-with-fallback`

    -- inferred unrestricted

    let ~(x, y) = u in …

 Data types

 ----------

 By default, all fields in algebraic data types are linear (even if

   See `GHC Proposal #229 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0229-whitespace-bang-patterns.rst>`__

   for the precise rules.

 Strict bindings

 ~~~~~~~~~~~~~~~

 When the user looks up an IPE entry, we convert it to the user-facing

 InfoProvEnt representation.

 */

 typedef struct {

     uint32_t idx;

 } IpeMapEntry;

 #if defined(THREADED_RTS)

 static Mutex ipeMapLock;

 #endif

 // Accessed atomically

 static IpeBufferListNode *ipeBufferList = NULL;

 static void decompressIPEBufferListNodeIfCompressed(IpeBufferListNode*);

 static void updateIpeMap(void);

 #if defined(THREADED_RTS)

 void initIpe(void) { initMutex(&ipeMapLock); }

 {

     CHECK(idx < node->count);

     CHECK(!node->compressed);

     return (InfoProvEnt) {

             .info = node->tables[idx],

             .prov = {

                 .table_name = &strings[ent->table_name],

                 .closure_desc = ent->closure_desc,

                 .ty_desc = &strings[ent->ty_desc],

 static void traceIPEFromHashTable(void *data STG_UNUSED, StgWord key STG_UNUSED,

                                   const void *value) {

     const IpeMapEntry *map_ent = (const IpeMapEntry *)value;

 }

 void dumpIPEToEventLog(void) {

     // Dump pending entries

     IpeBufferListNode *node = RELAXED_LOAD(&ipeBufferList);

     while (node != NULL) {

         }

         node = node->next;

     }

 A performance test for IPE registration and lookup can be found here:

 https://gitlab.haskell.org/ghc/ghc/-/merge_requests/5724#note_370806

 */

 void registerInfoProvList(IpeBufferListNode *node) {

     while (true) {

         IpeBufferListNode *old = RELAXED_LOAD(&ipeBufferList);

         node->next = old;

         if (cas_ptr((volatile void **) &ipeBufferList, old, node) == (void *) old) {

             return;

         }

 bool lookupIPE(const StgInfoTable *info, InfoProvEnt *out) {

     updateIpeMap();

     IpeMapEntry *map_ent = (IpeMapEntry *) lookupHashTable(ipeMap, (StgWord)info);

         *out = ipeBufferEntryToIpe(map_ent->node, map_ent->idx);

         return true;

     } else {

     }

 }

 void updateIpeMap(void) {

     // Check if there's any work at all. If not so, we can circumvent locking,

     // which decreases performance.

 #include "Printer.h"

 #include "Trace.h"

 #include "sm/GCThread.h"

 #include <fs_rts.h>

 #include <string.h>

             return closure_type_names[info->type];

         }

     }

     default:

         barf("closureIdentity");

 }

 #endif

 /* -----------------------------------------------------------------------------

  * Print out the results of a heap census.

  * -------------------------------------------------------------------------- */

     }

 #endif

     for (ctr = census->ctrs; ctr != NULL; ctr = ctr->next) {

 #if defined(PROFILING)

                                       count * sizeof(W_));

             break;

         case HEAP_BY_INFO_TABLE:

             break;

 #if defined(PROFILING)

         case HEAP_BY_CCS:

             fprint_ccs(hp_file, (CostCentreStack *)ctr->identity,

         fprintf(hp_file, "\t%" FMT_Word "\n", (W_)count * sizeof(W_));

     }

     traceHeapProfSampleEnd(era);

     printSample(false, census->time);

     CHECK(!ensureRoomForVariableEvent(&eventBuf, len));

     postEventHeader(&eventBuf, EVENT_IPE);

     postPayloadSize(&eventBuf, len);

     postStringLen(&eventBuf, ipe->prov.table_name, table_name_len);

     postStringLen(&eventBuf, closure_desc_buf, closure_desc_len);

     postStringLen(&eventBuf, ipe->prov.ty_desc, ty_desc_len);

 #pragma once

 typedef struct InfoProv_ {

     const char *table_name;

     uint32_t closure_desc; // closure type

     const char *ty_desc;

 GHC_STATIC_ASSERT(sizeof(IpeBufferEntry) % (WORD_SIZE_IN_BITS / 8) == 0, "sizeof(IpeBufferEntry) must be a multiple of the word size");

 typedef struct IpeBufferListNode_ {

     struct IpeBufferListNode_ *next;

     // Everything below is read-only and generated by the codegen

     // This flag should be treated as a boolean

     // When TNTC is enabled, these will point to the entry code

     // not the info table itself.

     const StgInfoTable **tables;

     StgWord entries_size; // decompressed size

     StgWord string_table_size; // decompressed size

     // Shared by all entries

 // Returns true on success, initializes `out`.

 bool lookupIPE(const StgInfoTable *info, InfoProvEnt *out);

 #if defined(DEBUG)

 void printIPE(const StgInfoTable *info);

 #endif

     // Allocate buffers for IPE buffer list node

     IpeBufferListNode *node = malloc(sizeof(IpeBufferListNode));

     node->tables = malloc(sizeof(StgInfoTable *));

     StringTable st;

     init_string_table(&st);

     node->compressed = 0;

     node->count = 1;

     node->tables[0] = get_itbl(fortyTwo);

     node->entries_size = sizeof(IpeBufferEntry);

     node->string_table_size = st.size;

     registerInfoProvList(node);

     // Allocate buffers for IPE buffer list node

     IpeBufferListNode *node = malloc(sizeof(IpeBufferListNode));

     node->tables = malloc(sizeof(StgInfoTable *));

     StringTable st;

     init_string_table(&st);

     node->compressed = 0;

     node->count = 1;

     node->tables[0] = get_itbl(twentyThree);

     node->entries_size = sizeof(IpeBufferEntry);

     node->string_table_size = st.size;

     registerInfoProvList(node);

     // Allocate buffers for IPE buffer list node

     IpeBufferListNode *node = malloc(sizeof(IpeBufferListNode));

     node->tables = malloc(sizeof(StgInfoTable *) * 2);

     StringTable st;

     init_string_table(&st);

     node->count = 2;

     node->tables[0] = get_itbl(one);

     node->tables[1] = get_itbl(two);

     node->entries_size = sizeof(IpeBufferEntry) * 2;

     node->string_table_size = st.size;

     registerInfoProvList(node);

     IpeBufferListNode *node = malloc(sizeof(IpeBufferListNode));

     node->count = 0;

     node->next = NULL;

     registerInfoProvList(node);

     // Allocate buffers for IpeBufferListNode

     IpeBufferListNode *node = malloc(sizeof(IpeBufferListNode));

     node->tables = malloc(sizeof(StgInfoTable *) * n);

     StringTable st;

     init_string_table(&st);

     for (int i=start; i < end; i++) {

         HaskellObj closure = rts_mkInt(cap, 42);

         node->tables[i]  = get_itbl(closure);

     }

     // Set the rest of the fields

     node->next = NULL;

     node->compressed = 0;

     node->count = n;

     return node;

 }