GitLab

Simon Jakobi pushed to branch wip/sjakobi/clabel-monomorphic at Glasgow Haskell Compiler / GHC

WARNING: The push did not contain any new commits, but force pushed to delete the commits and changes below.

Deleted commits:

bf52c492

by Simon Jakobi at 2026-06-11T08:50:35+02:00

Only treat continuations of reachable calls as proc points

callProcPoints used to fold over the whole block map, which can
contain unreachable blocks: the control-flow optimiser and the common
block eliminator both leave them behind, and they are only removed at
the end of the Cmm pipeline (Note [unreachable blocks]).

In particular, when CBE merges duplicated call blocks it leaves the
losing copy in the block map, and the continuation of such a dead call
can itself be unreachable. callProcPoints would still collect that
continuation, attachContInfoTables would attach an info table to it,
but stack layout (which only walks reachable blocks) produced no stack
map for it, so setInfoTableStackMap panicked:

  ghc: panic! (the 'impossible' happened)
        setInfoTableStackMap

This was triggered by compiling GHC.CmmToAsm.Dwarf.Types with -O2
after the previous commit reshaped the CLabel printers, but the bug is
latent and independent of that change.

Fix: make callProcPoints fold over revPostorder, i.e. reachable blocks
only. Also correct the stale comment in elimCommonBlocks claiming that
ContFlowOpt has already removed unreachable blocks, and extend
Note [unreachable blocks] with the invariant and a warning that the
Cmm pretty-printer hides unreachable blocks in dumps.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

3 changed files:

compiler/GHC/Cmm/CommonBlockElim.hs
compiler/GHC/Cmm/Pipeline.hs
compiler/GHC/Cmm/ProcPoint.hs

Changes:

compiler/GHC/Cmm/CommonBlockElim.hs

@@ -63,10 +63,16 @@ elimCommonBlocks :: CmmGraph -> CmmGraph
  elimCommonBlocks g = replaceLabels env $ copyTicks env g
    where
       env = iterate mapEmpty blocks_with_key
 -     -- The order of blocks doesn't matter here. While we could use
 -     -- revPostorder which drops unreachable blocks this is done in
 -     -- ContFlowOpt already which runs before this pass. So we use
 -     -- toBlockList since it is faster.
 +     -- The order of blocks doesn't matter here. Note that toBlockList
 +     -- includes unreachable blocks (ContFlowOpt leaves them in the block
 +     -- map, see Note [unreachable blocks] in GHC.Cmm.Pipeline), so we may
 +     -- hash and merge dead blocks, and a live block may even be
 +     -- substituted by an unreachable duplicate (resurrecting it). That is
 +     -- semantically harmless since the blocks are identical, but it means
 +     -- this pass both consumes and produces unreachable blocks; passes
 +     -- between this one and the final removeUnreachableBlocksProc must
 +     -- not let blocks that are unreachable here influence the reachable
 +     -- part of the graph (see e.g. callProcPoints in GHC.Cmm.ProcPoint).
       groups = groupByInt hash_block (toBlockList g) :: [[CmmBlock]]
       blocks_with_key = [ [ (successors b, [b]) | b <- bs] | bs <- groups]

compiler/GHC/Cmm/Pipeline.hs

@@ -352,10 +352,22 @@ _GLOBAL_OFFSET_TABLE_, regardless of which entry point we arrived via.
  {- Note [unreachable blocks]
     ~~~~~~~~~~~~~~~~~~~~~~~~~
 -The control-flow optimiser sometimes leaves unreachable blocks behind
 -containing junk code.  These aren't necessarily a problem, but
 -removing them is good because it might save time in the native code
 -generator later.
 +The control-flow optimiser and the common block eliminator sometimes
 +leave unreachable blocks behind containing junk code; they are only
 +removed here, at the end of the pipeline.  Removing them earlier would
 +cost extra reachability passes, but deferring the removal means every
 +pass in between runs on a block map that may contain unreachable
 +blocks, and must take care that they don't influence the reachable
 +part of the graph.  In particular, the continuation of a call in an
 +unreachable block may itself be unreachable, so it must not be treated
 +as a proc point: stack layout only lays out reachable blocks, and an
 +info table attached (by attachContInfoTables) to a continuation
 +without a stack map makes setInfoTableStackMap panic.  See
 +callProcPoints in GHC.Cmm.ProcPoint.
++
 +Beware also that the Cmm pretty-printer omits unreachable blocks, so
 +they do not show up in -ddump-cmm-* output; a dump can therefore look
 +consistent while the underlying block map is not.
  -}

compiler/GHC/Cmm/ProcPoint.hs

@@ -173,8 +173,16 @@ procPointLattice = DataflowLattice unreached add_to
  -- introduced because they're reachable from multiple proc points.
  --
  -- Extract the set of Continuation BlockIds, see Note [Continuation BlockIds].
 +--
 +-- We must consider only *reachable* blocks: the common block eliminator
 +-- leaves duplicated (hence unreachable) call blocks in the block map
 +-- (see Note [unreachable blocks] in GHC.Cmm.Pipeline), and the
 +-- continuation of such a dead call may itself be unreachable. Stack
 +-- layout only lays out reachable blocks, so a continuation collected
 +-- from a dead call would get an info table (attachContInfoTables) but
 +-- no stack map, making setInfoTableStackMap panic.
  callProcPoints      :: CmmGraph -> ProcPointSet
 -callProcPoints g = foldlGraphBlocks add (setSingleton (g_entry g)) g
 +callProcPoints g = foldl' add (setSingleton (g_entry g)) (revPostorder g)
    where add :: LabelSet -> CmmBlock -> LabelSet
          add set b = case lastNode b of
                        CmmCall {cml_cont = Just k} -> setInsert k set