+    -- The entry/root dominates every block and is deliberately excluded, so its

+    -- children start from the empty dominator set.

+    mkDomMap (Node _root children) = foldl' (go setEmpty) mapEmpty children

+        -- `doms`: the dominators of `lbl`, i.e. its ancestors in the dominator

+        -- tree excluding the tree root.

+        go :: LabelSet -> LabelMap LabelSet -> Tree BlockId -> LabelMap LabelSet

+        go doms acc (Node lbl kids)

+          = foldl' (go (setInsert lbl doms)) (mapInsert lbl doms acc) kids

+                            setFreeRegsR $ foldl' (flip frAllocateReg) (frInitFreeRegs platform)

+      loop assig !free (RegReal rr : rs) = loop assig (frReleaseReg rr free) rs

+                (frReleaseReg real free) rs

+                (frReleaseReg real free) rs

+                freeRegs_thisClass = frGetFreeRegs regclass freeRegs

+                  setFreeRegsR (frAllocateReg my_reg freeRegs)

+            allFreeRegs = foldMap (\ rc -> frGetFreeRegs rc freeregs) allRegClasses

+        setFreeRegsR $! foldl' (flip frAllocateReg) freeregs extra_clobbered

+        -- setFreeRegsR $! foldl' (flip frAllocateReg) freeregs clobbered

+            freeRegs_thisClass = frGetFreeRegs regclass freeRegs :: [RealReg]

+                setFreeRegsR $  frAllocateReg final_reg freeRegs

+    frAllocateReg :: RealReg -> freeRegs -> freeRegs

+    frGetFreeRegs :: RegClass -> freeRegs -> [RealReg]

+    -- | The initial allocatable set is platform-dependent. See Note

+    -- [Aarch64 Register x18 at Darwin and Windows].

+    frReleaseReg :: RealReg -> freeRegs -> freeRegs

+    frAllocateReg  = X86.allocateReg

+    frReleaseReg   = X86.releaseReg

+    frAllocateReg  = X86_64.allocateReg

+    frReleaseReg   = X86_64.releaseReg

+    frAllocateReg  = PPC.allocateReg

+    frGetFreeRegs  = PPC.getFreeRegs

+    frReleaseReg   = PPC.releaseReg

+    frAllocateReg = AArch64.allocateReg

+    frGetFreeRegs = AArch64.getFreeRegs

+    frReleaseReg = AArch64.releaseReg

+    frAllocateReg = RV64.allocateReg

+    frGetFreeRegs = RV64.getFreeRegs

+    frReleaseReg = RV64.releaseReg

+    frAllocateReg = LA64.allocateReg

+    frGetFreeRegs = LA64.getFreeRegs

+    frReleaseReg = LA64.releaseReg

+allFreeRegs plat fr = foldMap (\rcls -> frGetFreeRegs rcls fr) allRegClasses

+ = do   -- free up the regs that are not live on entry to this block.

+        let freeregs' = foldl' (flip frReleaseReg) freeregs to_free

+getFreeRegs :: RegClass -> FreeRegs -> [RealReg] -- lazily

+getFreeRegs cls (FreeRegs f) =

+      | i <- intregnos PW4

+      | i <- xmmregnos PW4

+getFreeRegs :: RegClass -> FreeRegs -> [RealReg] -- lazily

+getFreeRegs cls (FreeRegs f) =

+      | i <- intregnos PW8

+      | i <- xmmregnos PW8

+    zip (map realRegSingle [0..lastint wordSize]) colors

+        ++ zip (map realRegSingle [firstxmm..lastxmm wordSize]) greys

+    wordSize = platformWordSize platform

+

+--  on 32bit platforms, only the first 8 XMM/YMM/ZMM registers are available

+lastxmm :: PlatformWordSize -> RegNo

+lastxmm PW4 = firstxmm + 7  -- xmm0 - xmm7

+lastxmm PW8 = firstxmm + 15 -- xmm0 - xmm15

+lastint :: PlatformWordSize -> RegNo

+lastint PW4 = 7 -- not %r8..%r15

+lastint PW8 = 15

+intregnos :: PlatformWordSize -> [RegNo]

+intregnos wordSize = [0 .. lastint wordSize]

+xmmregnos :: PlatformWordSize -> [RegNo]

+xmmregnos wordSize = [firstxmm .. lastxmm wordSize]

+floatregnos platform = xmmregnos (platformWordSize platform)

+allMachRegNos platform = intregnos (platformWordSize platform) ++ floatregnos platform

+            | i <= lastint wordSize -> RcInteger

+            | i <= lastxmm wordSize -> RcFloatOrVector

+  where

+    wordSize = platformWordSize platform

+                              skipped = str(len(t.fragile_failures)),

+    for kind, res_type, group in [('failure', 'stat failure', t.unexpected_stat_failures),

+                                  ('failure', 'unexpected failure', t.unexpected_failures),

+                                  ('failure', 'unexpected pass', t.unexpected_passes),

+                                  ('skipped', 'fragile failure', t.fragile_failures)]:

+            result = ET.SubElement(testcase, kind,

+# A single Cmm procedure with thousands of basic blocks (diamonds plus periodic

+# backedges), stressing the native code generator's CFG construction, edge-weight

+# estimation, register allocation and block layout. Works with all NCG backends

+# (X86, AArch64, WASM, etc.). See #27448.

+test('ManyBasicBlocks',

+     [ only_ways(['optasm']),

+       unless(have_ncg(), skip),

+       cmm_src,

+       collect_compiler_stats('bytes allocated', 2),

+       pre_cmd('./genManyBasicBlocks'),

+       extra_files(['genManyBasicBlocks']),

+     ],

+     compile,

+     ['-O -v0'])

+

+#!/usr/bin/env bash

+set -euo pipefail

+

+# Generate a Cmm source file that is intentionally heavy on control flow.

+#

+# The benchmark shape is one large procedure containing:

+#   - many split/left/right/join diamonds

+#   - periodic backedges that make each chunk a natural loop

+#

+# It produces thousands of actual basic blocks in a single Cmm graph (rather

+# than merely a very large source file), stressing the native code generator's

+# CFG construction, edge-weight estimation, register allocation and block

+# layout.

+#

+# Based on GitLab snippet #6044

+#

+# Tuning knobs:

+#   STAGES       Number of diamond stages to generate. Default: 2048

+#   LOOP_PERIOD  Number of stages per loop chunk. Default: 16

+#   LOOP_TRIPS   Runtime trip count for each chunk. Default: 2

+#   OUT          Output file. Default: ManyBasicBlocks.cmm

+

+: "${STAGES:=2048}"

+: "${LOOP_PERIOD:=16}"

+: "${LOOP_TRIPS:=2}"

+: "${OUT:=ManyBasicBlocks.cmm}"

+

+die() {

+  printf '%s\n' "$*" >&2

+  exit 1

+}

+

+check_nat() {

+  local value=$1

+  local name=$2

+

+  [[ $value =~ ^[0-9]+$ ]] || die "$name must be a non-negative integer"

+}

+

+check_nat "$STAGES" STAGES

+check_nat "$LOOP_PERIOD" LOOP_PERIOD

+check_nat "$LOOP_TRIPS" LOOP_TRIPS

+

+(( STAGES > 0 )) || die "STAGES must be greater than zero"

+(( LOOP_PERIOD > 0 )) || die "LOOP_PERIOD must be greater than zero"

+(( LOOP_TRIPS > 0 )) || die "LOOP_TRIPS must be greater than zero"

+

+chunk_count=$(( (STAGES + LOOP_PERIOD - 1) / LOOP_PERIOD ))

+block_count=$(( 1 + 4 * STAGES + chunk_count ))

+

+emit() {

+  printf '%s\n' "$*"

+}

+

+{

+  emit "// Generated by genManyBasicBlocks"

+  emit "//"

+  emit "// Parameters:"

+  emit "//   STAGES=${STAGES}"

+  emit "//   LOOP_PERIOD=${LOOP_PERIOD}"

+  emit "//   LOOP_TRIPS=${LOOP_TRIPS}"

+  emit "//"

+  emit "// Approximate block count: ${block_count}"

+  emit "#include \"Cmm.h\""

+  emit

+  emit "many_basic_blocks (W_ seed) {"

+  emit "  W_ acc;"

+  emit "  W_ mix;"

+  for ((chunk = 0; chunk < chunk_count; chunk++)); do

+    emit "  W_ trip${chunk};"

+  done

+  emit

+  emit "entry:"

+  emit "  acc = seed;"

+  emit "  mix = seed + (17 :: W_);"

+  for ((chunk = 0; chunk < chunk_count; chunk++)); do

+    emit "  trip${chunk} = 0;"

+  done

+  emit "  goto split0;"

+  emit

+

+  for ((stage = 0; stage < STAGES; stage++)); do

+    next_stage=$(( stage + 1 ))

+    chunk=$(( stage / LOOP_PERIOD ))

+    stage1=$(( 4 * stage + 1 ))

+    stage2=$(( 4 * stage + 2 ))

+    stage3=$(( 4 * stage + 3 ))

+    stage4=$(( 4 * stage + 4 ))

+

+    emit "split${stage}:"

+    emit "  mix = mix + (${stage1} :: W_);"

+    emit "  if (((mix + (${stage2} :: W_)) % (7 :: W_)) < (3 :: W_)) {"

+    emit "    goto left${stage};"

+    emit "  }"

+    emit "  goto right${stage};"

+    emit

+

+    emit "left${stage}:"

+    emit "  acc = acc + (${stage3} :: W_);"

+    emit "  mix = mix + (${stage4} :: W_);"

+    emit "  goto join${stage};"

+    emit

+

+    emit "right${stage}:"

+    emit "  acc = acc + (${stage4} :: W_);"

+    emit "  mix = mix + (${stage3} :: W_);"

+    emit "  goto join${stage};"

+    emit

+

+    emit "join${stage}:"

+    emit "  acc = acc + mix + (${stage1} :: W_);"

+    if (( next_stage == STAGES || next_stage % LOOP_PERIOD == 0 )); then

+      emit "  goto latch${chunk};"

+    else

+      emit "  goto split${next_stage};"

+    fi

+    emit

+  done

+

+  for ((chunk = 0; chunk < chunk_count; chunk++)); do

+    loop_start=$(( chunk * LOOP_PERIOD ))

+    next_stage=$(( (chunk + 1) * LOOP_PERIOD ))

+    latch_mix=$(( 1000000 + chunk ))

+    latch_acc=$(( 2000000 + chunk ))

+

+    emit "latch${chunk}:"

+    emit "  trip${chunk} = trip${chunk} + (1 :: W_);"

+    emit "  mix = mix + (${latch_mix} :: W_);"

+    emit "  acc = acc + (${latch_acc} :: W_);"

+    emit "  if (trip${chunk} < (${LOOP_TRIPS} :: W_)) {"

+    emit "    goto split${loop_start};"

+    emit "  }"

+    if (( next_stage < STAGES )); then

+      emit "  goto split${next_stage};"

+    else

+      emit "  return (acc);"

+    fi

+    emit

+  done

+

+  emit "}"

+} > "$OUT"