+  | IPE

+    IPE                     -> ReadWriteSection

+  IPE                     -> text "ipe"

+       IPE

+        | ppc64          -> text ".align 3"

+        | otherwise      -> text ".align 2"

+      IPE

+        | OSMinGW32 <- platformOS platform

+                    -> text ".rdata"

+        | otherwise -> text ".ipe"

+      IPE

+        | OSMinGW32 <- platformOS platform

+                    -> empty

+        | otherwise -> text ",\"a\"," <> sectionType platform "progbits"

+  IPE                     -> text ".csect .text[PR] #IPE"

+  IPE                     -> text ".const"

+    IPE                     -> fsLit ".ipe"

+import Data.Char

+

+Note [IPE Stripping and magic words]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+For systems which support ELF executables:

+

+The metadata part of IPE info is placed into a separate ELF section (.ipe).

+This can then be stripped afterwards if you don't require the metadata

+

+```

+-- Remove the section

+objcopy --remove-section .ipe <your-exe>

+-- Repack and compress the executable

+upx <your-exe>

+```

+

+The .ipe section starts with a magic 64-bit word "IPE\0IPE\0`, encoded as ascii.

+

+The RTS checks to see if the .ipe section starts with the magic word. If the

+section has been stripped then it won't start with the magic word and the

+metadata won't be accessible for the info tables.

+

+        strings = [CmmString (ipe_header `mappend` strings_bytes)]

+        entries = [CmmString (ipe_header `mappend` entries_bytes)]

+        -- A string which fits into one 64-bit word.

+        ipe_header_word :: Word64

+        ipe_header_word = stringToWord64BE "IPE\0IPE\0"

+

+        -- Convert 8 bytes to Word64 using big-endian interpretation

+        stringToWord64BE :: String -> Word64

+        stringToWord64BE = foldl' (\acc b -> GHC.Prelude.shiftL acc 8 .|. fromIntegral (ord b)) 0

+

+        -- A magic word we can use to see if the IPE information has been stripped

+        -- or not

+        -- See Note [IPE Stripping and magic words]

+        -- When read then literally the string should read IPE\0IPE\0 in hex dumps.

+        --

+        -- There is some complexity here to turn this into a ByteString rather than

+        -- a simpler CmmStaticLit, since the unregistered backend does not cope well

+        -- with CmmStaticsRaw being a mixure of CmmStaticLit and CmmString.

+        ipe_header :: BS.ByteString

+        ipe_header = BSL.toStrict . BSB.toLazyByteString $

+                       case platformByteOrder platform of

+                         LittleEndian -> BSB.word64LE ipe_header_word

+                         BigEndian -> BSB.word64BE ipe_header_word

+

+

+            -- 'node_id' field

+          , zeroCLit platform

+

+      (Section IPE strings_lbl)

+      (Section IPE entries_lbl)

+    The metadata for ``-finfo-table-map`` is stored in the ``.ipe`` section on

+    ELF platforms. The ``.ipe`` section can be removed from the binary after compilation::

+

+      objcopy --remove-section .ipe <binary>

+      upx <binary>

+

+    You can first compile your application with ``-finfo-table-map``, extract

+    the contents of the map (by using the eventlog), strip the ``.ipe`` section

+    and then use the extracted data to interpret a ``-hi`` profile from the stripped

+    binary.

+

+Note [Stable identifiers for IPE entries]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+Each IPE entry is given a stable identifier which remains the same across

+different runs of the executable (unlike the address of the info table).

+

+The identifier is a 64-bit word which consists of two parts.

+

+* The high 32-bits are a per-node identifier.

+* The low 32-bits are the index of the entry in the node.

+

+When a node is queued in the pending list by `registerInfoProvList` it is

+given a unique identifier from an incrementing global variable.

+

+The unique key can be computed by using the `IPE_ENTRY_KEY` macro.

+

+// See Note [Stable identifiers for IPE entries]

+#define IPE_ENTRY_KEY(entry) \

+    MAKE_IPE_KEY((entry).node->node_id, (entry).idx)

+

+#define MAKE_IPE_KEY(module_id, idx) \

+    ((((uint64_t)(module_id)) << 32) | ((uint64_t)(idx)))

+

+// A global counter which is used to give an IPE entry a unique value across runs.

+static StgWord next_module_id = 1; // Start at 1 to reserve 0 as "invalid"

+

+// Check whether the IpeBufferListNode has the relevant magic words.

+// See Note [IPE Stripping and magic words]

+static inline bool ipe_node_valid(const IpeBufferListNode *node) {

+    return node &&

+           node->entries_block &&

+           node->string_table_block &&

+           node->entries_block->magic == IPE_MAGIC_WORD &&

+           node->string_table_block->magic == IPE_MAGIC_WORD;

+}

+

+    const char *strings = node->string_table_block->string_table;

+    const IpeBufferEntry *ent = &node->entries_block->entries[idx];

+                .info_prov_id  = MAKE_IPE_KEY(node->node_id, idx),

+    if (ipe_node_valid(map_ent->node)){

+      const InfoProvEnt ipe = ipeBufferEntryToIpe(map_ent->node, map_ent->idx);

+      traceIPE(&ipe);

+    }

+        if (ipe_node_valid(node)){

+          decompressIPEBufferListNodeIfCompressed(node);

+          for (uint32_t i = 0; i < node->count; i++) {

+              const InfoProvEnt ent = ipeBufferEntryToIpe(node, i);

+              traceIPE(&ent);

+          }

+

+Note that IPEs are still regiestered even if the .ipe section is stripped. That's

+because you may still want to query what the unique identifier for an info table is

+so it can be reconciled with previously extracted metadata information. For example,

+when `-hi` profiling or using `whereFrom`.

+

+

+        // Grab a fresh module_id

+    uint32_t module_id;

+    StgWord temp_module_id;

+    while (true) {

+        temp_module_id = next_module_id;

+        if (cas(&next_module_id, temp_module_id, temp_module_id+1) == temp_module_id) {

+            module_id = (uint32_t) temp_module_id;

+            break;

+        }

+

+    }

+        node->node_id = module_id;

+    if (map_ent && ipe_node_valid(map_ent->node)) {

+// Returns 0 when the info table is not present in the info table map.

+// See Note [Stable identifiers for IPE entries]

+uint64_t lookupIPEId(const StgInfoTable *info) {

+    updateIpeMap();

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

+    if (map_ent){

+        return IPE_ENTRY_KEY(*map_ent);

+    } else {

+        return 0;

+    }

+}

+

+#include "IPE.h"

+    case HEAP_BY_INFO_TABLE:

+    {

+        return (void *) (p->header.info);

+    }

+static void

+recordIPEHeapSample(FILE *hp_file, uint64_t table_id, size_t count)

+{

+    // Print to heap profile file

+    fprintf(hp_file, "0x%" PRIx64, table_id);

+

+    // Create label string for tracing

+    char str[100];

+    sprintf(str, "0x%" PRIx64, table_id);

+

+    // Emit the profiling sample (convert count to bytes)

+    traceHeapProfSampleString(str, count * sizeof(W_));

+}

+

+    // Census entries which we need to group together.

+    // Used by IPE profiling to group together bands which don't have IPE information.

+    // Printing at the end in the 0 band

+    uint64_t uncategorised_count = 0;

+

+        {

+            uint64_t table_id = lookupIPEId(ctr->identity);

+            if (! table_id) {

+              uncategorised_count += count;

+              continue;

+            }

+            recordIPEHeapSample(hp_file, table_id, count);

+        }

+    // Print the unallocated data into the 0 band for info table profiling.

+    switch (RtsFlags.ProfFlags.doHeapProfile) {

+        case HEAP_BY_INFO_TABLE:

+            recordIPEHeapSample(hp_file, 0, uncategorised_count);

+            break;

+        default:

+            ASSERT(uncategorised_count == 0);

+            break;

+    }

+

+    postWord64(&eventBuf, (StgWord) (ipe->prov.info_prov_id));

+    uint64_t   info_prov_id;

+// The magic word is IPE\nIPE\n, which occupies the full 64 bit width of a word.

+// See Note [IPE Stripping and magic words]

+#define IPE_MAGIC_WORD 0x4950450049504500UL

+

+// Heap profiling currently requires a 32 bit pointer.. so for now just truncate

+// the key to fit. It should still be big enough.

+#if SIZEOF_VOID_P == 4

+// On 32-bit systems: keep lower 16 bits of module_id and idx

+#define IPE_PROF_KEY(key64) \

+    (uint32_t)((((key64) >> 16) & 0xFFFF0000) | ((key64) & 0x0000FFFF))

+#else

+// On 64-bit systems: use full key

+#define IPE_PROF_KEY(key64) (key64)

+#endif

+

+typedef struct {

+    StgWord64 magic;          // Must be IPE_MAGIC_WORD

+    IpeBufferEntry entries[]; // Flexible array member

+} IpeBufferEntryBlock;

+

+typedef struct {

+    StgWord64 magic;          // Must be IPE_MAGIC_WORD

+    char string_table[];    // Flexible array member for string table

+} IpeStringTableBlock;

+

+    // This field is filled in when the node is registered.

+    uint32_t node_id;

+

+    IpeBufferEntryBlock *entries_block;

+    const IpeStringTableBlock *string_table_block;

+uint64_t lookupIPEId(const StgInfoTable *info);

+

+    node->entries_block = malloc(sizeof(StgWord64) + sizeof(IpeBufferEntry));

+    node->entries_block->magic = IPE_MAGIC_WORD;

+    node->entries_block->entries[0] = makeAnyProvEntry(cap, &st, 42);

+

+    IpeStringTableBlock *string_table_block = malloc(sizeof(StgWord64) + st.size);

+    string_table_block->magic = IPE_MAGIC_WORD;

+    memcpy(string_table_block->string_table, st.buffer, st.size);

+    node->string_table_block = string_table_block;

+    node->entries_block = malloc(sizeof(StgWord64) + sizeof(IpeBufferEntry));

+    node->entries_block->magic = IPE_MAGIC_WORD;

+    node->entries_block->entries[0] = makeAnyProvEntry(cap, &st, 23);

+    IpeStringTableBlock *string_table_block = malloc(sizeof(StgWord64) + st.size);

+    string_table_block->magic = IPE_MAGIC_WORD;

+    memcpy(string_table_block->string_table, st.buffer, st.size);

+    node->string_table_block = string_table_block;

+    node->entries_block = malloc(sizeof(StgWord64) + sizeof(IpeBufferEntry) * 2);

+    node->entries_block->magic = IPE_MAGIC_WORD;

+    node->entries_block->entries[0] = makeAnyProvEntry(cap, &st, 1);

+    node->entries_block->entries[1] = makeAnyProvEntry(cap, &st, 2);

+    IpeStringTableBlock *string_table_block = malloc(sizeof(StgWord64) + st.size);

+    string_table_block->magic = IPE_MAGIC_WORD;

+    memcpy(string_table_block->string_table, st.buffer, st.size);

+    node->string_table_block = string_table_block;

+    IpeStringTableBlock *string_table_block = malloc(sizeof(StgWord64));

+    string_table_block->magic = IPE_MAGIC_WORD;

+

+    node->entries_block = malloc(sizeof(StgWord64));

+    node->entries_block->magic = IPE_MAGIC_WORD;

+    node->entries_block = malloc(sizeof(StgWord64) + sizeof(IpeBufferEntry) * n);

+    node->entries_block->magic = IPE_MAGIC_WORD;

+        node->entries_block->entries[i] = makeAnyProvEntry(cap, &st, i);

+

+    IpeStringTableBlock *string_table_block =

+      malloc(sizeof(StgWord64) + st.size);

+    string_table_block->magic = IPE_MAGIC_WORD;

+    memcpy(string_table_block->string_table, st.buffer, st.size);

+    node->string_table_block = string_table_block;