+    have_gdb     <- expr $ liftIO (isJust <$> findExecutable "gdb")

+    have_ldd     <- expr $ liftIO (isJust <$> findExecutable "ldd")

+    have_readelf <- expr $ liftIO (isJust <$> findExecutable "readelf")

+

+            , arg "-e", arg $ asBool "config.have_gdb=" have_gdb

+            , arg "-e", arg $ asBool "config.have_ldd=" have_ldd

+            , arg "-e", arg $ asBool "config.have_readelf=" have_readelf

+    const RtsSymbolVal * rtsSyms = getRtsSymbols();

+    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");

+        }

+    }

+    stgFree((void*)rtsSyms);

+    IF_DEBUG(linker, debugBelch("done with built-in RTS symbols\n"));

+#include "RtsUtils.h"

+#include "RtsUtils.h"

+      SymI_HasProto(getRtsSymbols)                                          \

+                    (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE, NULL },

+                    (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_DATA, NULL },

+            (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE | SYM_TYPE_EXTERNAL, NULL },

+            (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_DATA | SYM_TYPE_EXTERNAL, NULL },

+      (void*)(&(xxx)), strength, ty, MAYBE_LEADING_UNDERSCORE_STR(#xxx) },

+// Allocate and return an array of rts symbols.

+// The final element marks the end of the array and has `.lbl=NULL`.

+// The caller must free the array.

+RtsSymbolVal const * getRtsSymbols(void) {

+      /* 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

+            RTS_MINGW_ONLY_SYMBOLS

+            RTS_DARWIN_ONLY_SYMBOLS

+            RTS_OPENBSD_ONLY_SYMBOLS

+            RTS_LIBGCC_SYMBOLS

+            RTS_ARCH_LIBGCC_SYMBOLS

+            RTS_FINI_ARRAY_SYMBOLS

+            RTS_LIBFFI_SYMBOLS

+            RTS_ARM_OUTLINE_ATOMIC_SYMBOLS

+            RTS_SYMBOLS_PRIM

+            SymI_HasDataProto(nonmoving_write_barrier_enabled)

+            { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE, NULL } /* sentinel */

+      };

+      RtsSymbolVal * rtsSyms = stgMallocBytes(sizeof(_rtsSyms), "getRtsSymbols");

+      uint32_t i = 0;

+      do {

+            rtsSyms[i] = _rtsSyms[i];

+            i++;

+      } while (_rtsSyms[i-1].lbl != NULL);

+      return rtsSyms;

+//          { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE, NULL } /* sentinel */

+      { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE, NULL } /* sentinel */

+#include "rts/RtsSymbols.h"

+#include "rts/RtsSymbols.h"

+/* -----------------------------------------------------------------------------

+ *

+ * (c) The GHC Team, 2000-2015

+ *

+ * RTS Symbols

+ *

+ * ---------------------------------------------------------------------------*/

+

+#pragma once

+

+#include <stdbool.h>

+typedef void SymbolAddr;

+typedef char SymbolName;

+

+/* What kind of thing a symbol identifies. We need to know this to determine how

+ * to process overflowing relocations. See Note [Processing overflowed relocations].

+ * This is bitfield however only the option SYM_TYPE_DUP_DISCARD can be combined

+ * with the other values. */

+typedef enum _SymType {

+    SYM_TYPE_CODE = 1 << 0, /* the symbol is a function and can be relocated via a jump island */

+    SYM_TYPE_DATA = 1 << 1, /* the symbol is data */

+    SYM_TYPE_INDIRECT_DATA = 1 << 2, /* see Note [_iob_func symbol] */

+    SYM_TYPE_DUP_DISCARD = 1 << 3, /* the symbol is a symbol in a BFD import library

+                                      however if a duplicate is found with a mismatching

+                                      SymType then discard this one.  */

+    SYM_TYPE_HIDDEN = 1 << 4, /* the symbol is hidden and should not be exported */

+    SYM_TYPE_EXTERNAL = 1 << 5, /* the symbol is defined externally to the RTS library. It might be linked

+                                   dynamically. This corresponds to SymE_* in RtsSymbols.c */

+} SymType;

+

+typedef enum _SymStrength {

+    STRENGTH_NORMAL,

+    STRENGTH_WEAK,

+    STRENGTH_STRONG,

+} SymStrength;

+

+typedef struct _RtsSymbolVal {

+    const SymbolName* lbl;

+    SymbolAddr* addr;

+    SymStrength strength;

+    SymType type;

+    // If this is a redirection, then this is the lable of the

+    // target symbol. Otherwise NULL.

+    const SymbolName* lbl_redirect_target;

+} RtsSymbolVal;

+

+RtsSymbolVal const * getRtsSymbols(void);

+                        rts/RtsSymbols.h

+    # Add mingw to PATH

+    topdir = config.libdir

+    mingw = os.path.abspath(os.path.join(topdir, '../mingw/bin'))

+    mingw = format_path(mingw)

+    ghc_env['PATH'] = os.pathsep.join([ghc_env.get("PATH", ""), mingw])

+

+    # Add ghc packages to PATH

+        pkgs = getStdout([config.ghc_pkg, '--simple-output', 'list'])

+        pkgs = ""

+

+    newPaths = set()

+    pkgs = pkgs.split(' ')

+    for pkg in pkgs:

+        for field in ['library-dirs', 'dynamic-library-dirs']:

+            path = getStdout([config.ghc_pkg, '--simple-output', 'field', pkg, field])

+            path = path.strip()

+            path = format_path(path)

+            newPaths.add(path)

+    for path in newPaths:

+        ghc_env['PATH'] = os.pathsep.join([path, ghc_env.get("PATH", "")])

+        # Is ldd available?

+        self.have_ldd = False

+

+def have_ldd( ) -> bool:

+    return config.have_ldd

+

+    way_flags = '"' + ' '.join(config.way_flags[way]).replace('"', '\\"') + '"'

+

+    cmd = '$MAKE -s --no-print-directory WAY_FLAGS={way_flags} {target}'.format(target=target, way_flags=way_flags)

+HAVE_LDD := $(shell if ldd --version > /dev/null 2> /dev/null; then echo YES; else echo NO; fi)

+ifeq "$(HAVE_LDD)" "YES"

+RUNTEST_OPTS += -e config.have_ldd=True

+else

+RUNTEST_OPTS += -e config.have_ldd=False

+endif

+

+                    (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE, NULL },

+import qualified Data.Map.Lazy as M

+import qualified Data.Set as S

+import Data.List (isSuffixOf, stripPrefix)

+import Data.Maybe (mapMaybe)

+import System.Environment (getArgs)

+

+-- Symbols to be ignored. These are symbols that are gated on CPP ant not correctly

+-- specified in RtsSymbols.c. This means the symbol will sometimes appear in the

+-- test output and sometimes not (depending on CPP defines). That means we can't

+-- simply put those symbols into the expected test output. It's already the

+-- job of RtsSymbols.c to declare symbols correctly in accordance with CPP. We

+-- want to avoid copying that logic again in the test. So we just ignore some

+-- symbols so that CI can pass and in the future we aim to fix RtsSymbols.c and

+-- reduce the size of ignoreSymbols.

+ignoreSymbols :: S.Set String

+ignoreSymbols = S.fromList [

+      -- These are defined in libgcc. RtsSymbols.c declare them with some

+      -- surrounding CPP but there seems to be differences between CI jobs.

+      -- See:

+      --   https://gitlab.haskell.org/ghc/ghc/-/jobs/2679828

+      --   https://gitlab.haskell.org/ghc/ghc/-/jobs/2679827

+      "__ashldi3",

+      "__ashrdi3",

+      "__divdi3",

+      "__fixunsdfdi",

+      "__lshrdi3",

+      "__moddi3",

+      "__muldi3",

+      "__udivdi3",

+      "__udivti3",

+      "__umoddi3",

+      "__umodti3",

+

+      -- These may be a CPP mismatch between rts/prim/vectorQuotRem.c and RtsSymbols.c

+      "hs_quotInt16X8",

+      "hs_quotInt32X4",

+      "hs_quotInt64X2",

+      "hs_quotInt8X16",

+      "hs_quotWord16X8",

+      "hs_quotWord32X4",

+      "hs_quotWord64X2",

+      "hs_quotWord8X16",

+      "hs_remInt16X8",

+      "hs_remInt32X4",

+      "hs_remInt64X2",

+      "hs_remInt8X16",

+      "hs_remWord16X8",

+      "hs_remWord32X4",

+      "hs_remWord64X2",

+      "hs_remWord8X16",

+

+      -- Appears in threaded RTS but not vanilla RTS (-Declared)

+      "atomic_dec",

+

+      -- Appears in threaded RTS but not vanilla RTS (+Observed)

+      "acquire_spin_lock_slow_path",

+      "busy_wait_nop",

+      "cas_seq_cst_relaxed",

+      "concurrent_coll_finished_cond",

+      "concurrent_coll_lock",

+      "concurrent_mark_roots",

+      "concurrent_worker_state",

+      "concurrent_worker_thread",

+      "gc_alloc_block_sync",

+      "globalStoreLock",

+      "linker_mutex",

+      "rts_pausing_task",

+      "start_concurrent_mark_cond",

+      "stats_mutex",

+      "stop_concurrent_worker",

+      "xchg",

+

+      -- Appears in debug RTS but not vanilla RTS (+Observed)

+      "RIGHT_ARITY_1",

+      "RIGHT_ARITY_2",

+      "SLOW_CALLS_1",

+      "SLOW_CALLS_2",

+      "TAGGED_PTR_1",

+      "TAGGED_PTR_2",

+      "TOTAL_CALLS",

+      "_bdescr",

+      "checkPtrInArena",

+      "findPtr",

+      "findSlop",

+      "ghci_enquire",

+      "insert_down_count",

+      "isHeapAlloced",

+      "leftify_up_shortcut_count",

+      "leftify_up_to_count",

+      "merge_down_count",

+      "nonmovingGcCafs",

+      "printAllTasks",

+      "printIPE",

+      "searched",

+      "whitehole_executeMessage_spin",

+      "whitehole_lockClosure_spin",

+      "whitehole_lockClosure_yield",

+      "whitehole_threadPaused_spin",

+

+      -- Uncategorized symbols

+      "_fini",

+      "_init",

+      "complex_ccall_adjustor_template",

+      "decodeAddendAarch64",

+      "encodeAddendAarch64",

+      "findStub",

+      "flushInstructionCache",

+      "flushInstructionCacheAarch64",

+      "freeStubs",

+      "instSizeAarch64",

+      "isAddSub",

+      "isAdrp",

+      "isBranch",

+      "isBranchLink",

+      "isLoadStore",

+      "isVectorOp",

+      "makeStub",

+      "makeStubAarch64",

+      "mblock_address_space",

+      "mblock_map",

+      "needStubForRelaAarch64",

+      "needStubForRelAarch64",

+      "numberOfStubsForSection",

+      "relocateObjectCode",

+      "relocateObjectCodeAarch64",

+      "simple_ccall_adjustor_template",

+      "StgReturn",

+      "stubSizeAarch64"

+   ]

+

+main :: IO ()

+main = do

+   args <- getArgs

+   case args of

+      ["dump"] -> dumpDeclaredSymbols

+      ["diff", declaredSymbolsFile, observedSymbolsFile] -> do

+

+         let symbolFilter :: String -> CodeOrData -> Bool

+             symbolFilter name cd =

+               -- Not in ingore list

+               not (S.member name ignoreSymbols)

+               -- Doesn't look like a entry/return code symbol

+               -- (These can appear in unregisterd builds wihere tables next to code is disabled)

+               && not ("_entry" `isSuffixOf` name && cd == Code)

+               && not ("_ret"   `isSuffixOf` name && cd == Code)

+

+         declaredSymbolsStr <- readFile declaredSymbolsFile

+         observedSymbolsStr <- readFile observedSymbolsFile

+

+         let declaredSymbols = M.filterWithKey symbolFilter $ readCodeOrData <$> linePairs declaredSymbolsStr

+         let observedSymbols = M.filterWithKey symbolFilter $ parseReadelf observedSymbolsStr

+

+         let diffStr = diff declaredSymbols observedSymbols

+         -- writeFile "<ghc root>/testsuite/tests/rts/symbols/rts-check-symbols.stdout"

+         putStrLn diffStr

+

+      _ -> fail ("Unexpected arguments: " ++ show args)

+

+foreign import ccall "dumpDeclaredSymbols"

+   dumpDeclaredSymbols :: IO ()

+

+data CodeOrData = Code | Data

+   deriving (Show, Eq)

+

+-- Compare observedSymbols (symbols observed in the DSO) to declaredSymbols

+-- (symbols declared in RtsSymbols.c)

+diff :: M.Map String CodeOrData -> M.Map String CodeOrData -> String

+diff declaredSymbols observedSymbols = unlines $

+      [ "Symbols declared in RtsSymbols.c but not observed in the DSO:" ]

+   ++ [ "Declared> " ++ k ++ " " ++ show v | (k, v) <- M.toList diffInDeclaredSymbols ]

+   ++ [ "" ]

+   ++ [ "Symbols observed in the DSO but not declared in RtsSymbols.c:" ]

+   ++ [ "Observed> " ++ k ++ " " ++ show v | (k, v) <- M.toList diffInObservedSymbols ]

+   ++ [ "" ]

+   ++ [ "Symbols observed in the DSO and declared in RtsSymbols.c but with conflicting type:" ]

+   ++ [ "WrongType> " ++ k ++ " (declared, observed): (" ++ show declared ++ ", " ++ show observed ++ ")"

+         | (k, (declared, observed)) <- M.toList diffOnType ]

+   where

+      -- Undeclared observed symbols

+      diffInObservedSymbols :: M.Map String CodeOrData

+      diffInObservedSymbols = observedSymbols M.\\ declaredSymbols

+

+      -- Declared unobserved symbols

+      diffInDeclaredSymbols :: M.Map String CodeOrData

+      diffInDeclaredSymbols = declaredSymbols M.\\ observedSymbols

+

+      -- Declared observed symbols with conflicting type

+      diffOnType :: M.Map String (CodeOrData, CodeOrData)

+      diffOnType = M.filter (\(a, b) -> a /= b) $ M.intersectionWith (,) declaredSymbols observedSymbols

+

+linePairs :: String -> M.Map String String

+linePairs = M.fromList . map (\str -> let [a,b] = words str in (a,b)) . filter (/= "") . lines

+

+readCodeOrData :: String -> CodeOrData

+readCodeOrData s = case s of

+   "code" -> Code

+   "data" -> Data

+   _ -> error ("Unknown symbol type: " ++ show s)

+

+-- | Parse the output of @readelf -W --dyn-syms@ of an ELF shared object.

+--

+-- Symbol lines look like:

+--

+-- >   Num:    Value          Size Type    Bind   Vis      Ndx Name

+-- >     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND tcsetattr@GLIBC_2.2.5 (2)

+-- >  1149: 000000000006d020   190 OBJECT  GLOBAL DEFAULT   12 stg_AP_info

+--

+-- Note that Vis may be followed by extra annotations on some platforms (e.g.

+-- @[<localentry>: 8]@ on ppc64le), so Ndx and Name are taken from the end of

+-- the line.

+parseReadelf :: String -> M.Map String CodeOrData

+parseReadelf = M.fromList . mapMaybe parseLine . lines

+   where

+      parseLine l = case words l of

+         (num : _value : _size : ty : bind : rest)

+            | ":" `isSuffixOf` num

+            , name : ndx : _ <- reverse (dropVersionIndex rest)

+            , bind == "GLOBAL"

+            , ndx /= "UND"  -- Imports

+            -> (,) name <$> typeToCodeOrData ty

+         _ -> Nothing

+

+      -- Drop the trailing version index e.g. "(2)"

+      dropVersionIndex ws = case reverse ws of

+         ('(' : _) : ws' -> reverse ws'

+         _ -> ws

+

+      -- Returns Nothing if the symbol should be ignored

+      typeToCodeOrData :: String -> Maybe CodeOrData

+      typeToCodeOrData ty = case ty of

+         "FILE"   -> Nothing

+         "NOTYPE" -> Nothing

+         "FUNC"   -> Just Code

+         "OBJECT" -> Just Data

+         _ -> error ("Unknown symbol type: " ++ show ty)

+TOP=../../..

+include $(TOP)/mk/boilerplate.mk

+include $(TOP)/mk/test.mk

+

+# This makefile rule only exists because TEST_HC is set in boilerplate.mk

+# and otherwise the TEST_HC variable wouldn't be set in the context of the bash script

+rts-check-symbols:

+	TOP="$(TOP)" \

+	TEST_HC_OPTS="$(TEST_HC_OPTS)" \

+	TEST_HC="$(TEST_HC)" \

+	WAY_FLAGS="$(WAY_FLAGS)" \

+	./rts-check-symbols.sh

+test('rts-check-symbols', [

+    unless(opsys('linux') and have_dynamic() and have_readelf() and have_ldd(), skip),

+    windows_skip,

+    # extra ways are important to test over different RTS DSOs

+    extra_ways([

+        'threaded1',    # threaded + debug

+        'threaded2',    # threaded

+        'sanity'        # debug

+    ]),

+    extra_files([

+        'dumpDeclaredSymbols.c',

+        'Main.hs',

+        'rts-check-symbols.sh'

+    ])],

+    makefile_test,

+    []

+)

+

+#include "Rts.h"

+

+#include <stdio.h>

+

+void dumpDeclaredSymbols(void);

+

+void dumpDeclaredSymbols(void) {

+    const RtsSymbolVal * declaredSyms = getRtsSymbols();

+    for (const RtsSymbolVal * sym = &declaredSyms[0]; sym->lbl; sym++) {

+        // Ignore hidden

+        if (sym->type & SYM_TYPE_HIDDEN) continue;

+

+        // Ignore external symbols

+        if (sym->type & SYM_TYPE_EXTERNAL) continue;

+

+        char * type = NULL;

+        if (sym->type & SYM_TYPE_CODE) {

+            type = "code";

+        } else if (sym->type & (SYM_TYPE_DATA | SYM_TYPE_INDIRECT_DATA)) {

+            type = "data";

+        }

+

+        const char * lbl = NULL;

+        if (sym->lbl_redirect_target) {

+            // In the case of redirects, the true symbol name is lbl_redirect_target

+            lbl = sym->lbl_redirect_target;

+        } else {

+            lbl = sym->lbl;

+        }

+

+        if (type) {

+            printf("%s %s\n", lbl, type);

+        }

+    }

+    free((void*)declaredSyms);

+}

+#!/usr/bin/env bash

+

+$TEST_HC $TEST_HC_OPTS      \

+    -package containers     \

+    -dynamic                \

+    dumpDeclaredSymbols.c   \

+    -I$TOP/../rts           \

+    -I$TOP/../rts/include   \

+    $WAY_FLAGS              \

+    Main.hs                 \

+    -o Main                 \

+    > /dev/null

+#

+# Check the diff between symbols exported from the RTS and those listed in RtsSymbols.c

+#

+

+DECLARED_SYMBOLS=declared_symbols.txt

+OBSERVED_SYMBOLS=observed_symbols.txt

+

+# Get rts Symbols listed in RtsSymbols.c

+./Main dump | sort > $DECLARED_SYMBOLS

+

+# Find the path of the RTS shared object that ./Main is linked against

+# Match e.g.:

+#    libHSrts-1.0.3-ghc9.15.20260710.so => /home/alice/s p a c e/myApp/lib/libHSrts-1.0.3-ghc9.15.20260710.so (0x7ffebc9a0000)

+RTS_DYLIB_PATH=$(ldd ./Main | awk '/^[[:space:]]*libHSrts-.* => .+$/ {

+    sub(/^[[:space:]]*libHSrts-.* => /, "")

+    sub(/ \([^(]*\)$/, "")

+    print

+}')

+

+# Dump the exported symbols. Main.hs is responsible for parsing the output.

+# The dynamic symbol table of the shared object. We use readelf rather

+# than nm as nm classifies symbols by section rather than by symbol

+# type, and with tables next to code info tables (objects) live in the

+# .text section.

+readelf -W --dyn-syms "$RTS_DYLIB_PATH" > $OBSERVED_SYMBOLS

+

+./Main diff $DECLARED_SYMBOLS $OBSERVED_SYMBOLS

+Symbols declared in RtsSymbols.c but not observed in the DSO:

+Declared> dirty_TVAR Code

+Declared> signal_handlers Code

+Declared> updateRemembSetPushThunk Code

+

+Symbols observed in the DSO but not declared in RtsSymbols.c:

+Observed> AP_STACK_sizeW Code

+Observed> AP_sizeW Code

+Observed> BLACKHOLE_sizeW Code

+Observed> Bdescr Code

+Observed> CHARLIKE_CLOSURE Code

+Observed> CONSTR_sizeW Code

+Observed> CONTINUATION_sizeW Code

+Observed> CON_INFO_PTR_TO_STRUCT Code

+Observed> FUN_INFO_PTR_TO_STRUCT Code

+Observed> FileEventLogWriter Data

+Observed> GET_CLOSURE_TAG Code

+Observed> GET_INFO Code

+Observed> GET_TAG Code

+Observed> INFO_PTR_TO_STRUCT Code

+Observed> INTLIKE_CLOSURE Code

+Observed> LOOKS_LIKE_CLOSURE_PTR Code

+Observed> LOOKS_LIKE_INFO_PTR Code

+Observed> LOOKS_LIKE_INFO_PTR_NOT_NULL Code

+Observed> LOOKS_LIKE_PTR Code

+Observed> NullEventLogWriter Data

+Observed> OS_TRY_ACQUIRE_LOCK Code

+Observed> PAP_sizeW Code

+Observed> RET_INFO_PTR_TO_STRUCT Code

+Observed> SET_INFO Code

+Observed> SET_INFO_RELAXED Code

+Observed> SET_INFO_RELEASE Code

+Observed> STATIC_LINK Code

+Observed> TAG_CLOSURE Code

+Observed> THUNK_INFO_PTR_TO_STRUCT Code

+Observed> THUNK_SELECTOR_sizeW Code

+Observed> UNTAG_CLOSURE Code

+Observed> UNTAG_CONST_CLOSURE Code

+Observed> UPD_BH_UPDATABLE_ctr Data

+Observed> __rts_fopen Code

+Observed> _warnFail Code

+Observed> addInitFini Code

+Observed> addProddableBlock Code

+Observed> allocAlignedGroupOnNode Code

+Observed> allocBlock Code

+Observed> allocBlockOnNode Code

+Observed> allocBlockOnNode_lock Code

+Observed> allocBlock_lock Code

+Observed> allocGroup Code

+Observed> allocGroupOnNode Code

+Observed> allocGroupOnNode_lock Code

+Observed> allocGroup_lock Code

+Observed> allocLimitKill Data

+Observed> allocLimitRunHook Data

+Observed> allocMBlockAlignedGroupOnNode Code

+Observed> allocateMightFail Code

+Observed> allocatePinned Code

+Observed> allocated_bytes_at_heapoverflow Data

+Observed> ap_sizeW Code

+Observed> ap_stack_sizeW Code

+Observed> arr_words_sizeW Code

+Observed> arr_words_words Code

+Observed> backtraceFree Code

+Observed> bco_sizeW Code

+Observed> broadcastCondition Code

+Observed> cas_word8 Code

+Observed> checkProddableBlock Code

+Observed> checkVectorSupport Code

+Observed> clearImportSymbol Code

+Observed> closeCondition Code

+Observed> closeMutex Code

+Observed> closure_sizeW Code

+Observed> collect_pointers Code

+Observed> compact_nfdata_full_sizeW Code

+Observed> containsSpan Code

+Observed> continuation_sizeW Code

+Observed> createAttachedOSThread Code

+Observed> createGenThread Code

+Observed> createIOThread Code

+Observed> createOSThread Code

+Observed> createStrictIOThread Code

+Observed> createThread Code

+Observed> currentWorkerCount Data

+Observed> debugMsgFn Data

+Observed> dequeElements Code

+Observed> dirty_STACK Code

+Observed> dirty_TSO Code

+Observed> discardElements Code

+Observed> era Data

+Observed> errorMsgFn Data

+Observed> eventLogStatus Code

+Observed> eventTypes Data

+Observed> exitFn Data

+Observed> exitHeapOverflow Code

+Observed> exitHpc Code

+Observed> fatalInternalErrorFn Data

+Observed> fillGot Code

+Observed> findSymbol Code

+Observed> findSymbolTable Code

+Observed> flushExec Code

+Observed> formatClosureDescIpe Code

+Observed> freeAllMBlocks Code

+Observed> freeChain Code

+Observed> freeChain_lock Code

+Observed> freeGot Code

+Observed> freeGroup Code

+Observed> freeGroup_lock Code

+Observed> freeInitFiniList Code

+Observed> freeMBlocks Code

+Observed> freeProddableBlocks Code

+Observed> freeThreadingResources Code

+Observed> freeWSDeque Code

+Observed> full_prog_argc Data

+Observed> full_prog_argv Data

+Observed> generations Data

+Observed> getFirstMBlock Code

+Observed> getMBlock Code

+Observed> getMBlockOnNode Code

+Observed> getMBlocks Code

+Observed> getMBlocksOnNode Code

+Observed> getNextMBlock Code

+Observed> getObjectLoadStatus Code