GitLab

Simon Jakobi pushed to branch wip/sjakobi/T27368-ppr at Glasgow Haskell Compiler / GHC

Commits:

7496cace

by Simon Jakobi at 2026-07-28T23:59:34+02:00

Cmm: print unreachable blocks under -dppr-debug (#27368)

Unreachable blocks linger in a CmmGraph's block map for most of the Cmm
pipeline, but pprCmmGraph only ever printed the blocks reachable from the
entry, so dumps looked consistent while the graph was not. Bugs like
 #27368 were hard to debug due to this.

pprCmmGraph now appends the stored-but-unreachable blocks under a
"// unreachable blocks:" heading when -dppr-debug is on. Existing dumps are
unchanged. See Note [unreachable blocks] in GHC.Cmm.Pipeline.

Assisted-by: Claude Opus 5

7 changed files:

+ changelog.d/T27368-ppr-unreachable-cmm-blocks.md
compiler/GHC/Cmm.hs
compiler/GHC/Cmm/Pipeline.hs
docs/users_guide/debugging.rst
+ testsuite/tests/cmm/should_compile/T27368-ppr-debug.cmm
+ testsuite/tests/cmm/should_compile/T27368-ppr-debug.stderr
testsuite/tests/cmm/should_compile/all.T

Changes:

changelog.d/T27368-ppr-unreachable-cmm-blocks.md

 +section: cmm
 +issues: #27368
 +mrs: !16417
 +synopsis:
 +  Cmm dumps now show unreachable blocks under ``-dppr-debug``
 +description:
 +  Unreachable blocks stay in a Cmm graph's block map for most of the Cmm
 +  pipeline, but ``-ddump-cmm-*`` only ever printed the blocks reachable from
 +  the graph's entry. Adding ``-dppr-debug`` now appends the stored but
 +  unreachable blocks, which makes bugs like #27368 visible in the dumps.

compiler/GHC/Cmm.hs

@@ -151,15 +151,24 @@ instance OutputableP Platform CmmGraph where
  toBlockMap :: CmmGraph -> LabelMap CmmBlock
  toBlockMap (CmmGraph {g_graph=GMany NothingO body NothingO}) = body
 +-- | Print the blocks reachable from the entry, in reverse postorder.  Under
 +-- @-dppr-debug@ the blocks that are stored in the graph but unreachable are
 +-- appended too; see Note [unreachable blocks] in "GHC.Cmm.Pipeline".
  pprCmmGraph :: Platform -> CmmGraph -> SDoc
  pprCmmGraph platform g
     = text "{" <> text "offset"
 -  $$ nest 2 (vcat $ map (pdoc platform) blocks)
 +  $$ nest 2 (vcat (map (pdoc platform) blocks) $$ unreachable)
    $$ text "}"
 -  where blocks = revPostorder g
 -    -- revPostorder has the side-effect of discarding unreachable code,
 -    -- so pretty-printed Cmm will omit any unreachable blocks.  This can
 -    -- sometimes be confusing.
 +  where
 +    blocks = revPostorder g
++
 +    unreachable = getPprDebug $ \debug ->
 +      if not debug || mapNull dead_blocks
 +        then empty
 +        else text "// unreachable blocks:"
 +          $$ nest 2 (vcat $ map (pdoc platform) (mapElems dead_blocks))
++
 +    dead_blocks = foldl' (\bs b -> mapDelete (entryLabel b) bs) (toBlockMap g) blocks
  revPostorder :: CmmGraph -> [CmmBlock]
  revPostorder g = {-# SCC "revPostorder" #-}

compiler/GHC/Cmm/Pipeline.hs

@@ -357,6 +357,7 @@ 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.
 +To make unreachable blocks visible in -ddump-cmm-* output, add -dppr-debug.
  -}
  dumpGraph :: Logger -> Platform -> Bool -> DumpFlag -> String -> CmmGraph -> IO ()

docs/users_guide/debugging.rst

@@ -564,6 +564,11 @@ C-\- representation
  These flags dump various phases of GHC's C-\- pipeline.
 +Dumps of Cmm graphs print the blocks reachable from the entry, in reverse
 +post-order. To also show unreachable blocks, which can linger in the graph,
 +add :ghc-flag:`-dppr-debug`. These blocks are then listed under a
 +``// unreachable blocks:`` heading.
++
  .. ghc-flag:: -ddump-cmm-verbose-by-proc
      :shortdesc: Show output from main C-\- pipeline passes (grouped by proc)
      :type: dynamic
@@ -574,9 +579,6 @@ These flags dump various phases of GHC's C-\- pipeline.
      the chosen backend. Currently only the NCG backends runs
      additional passes ( :ghc-flag:`-ddump-opt-cmm` ).
 -    Cmm dumps don't include unreachable blocks since we print
 -    blocks in reverse post-order.
+-
  .. ghc-flag:: -ddump-cmm-verbose
      :shortdesc: Write output from main C-\- pipeline passes to files
      :type: dynamic

testsuite/tests/cmm/should_compile/T27368-ppr-debug.cmm

 +#include "Cmm.h"
++
 +// The block "dead" is stored in the graph but no block branches to it, so it
 +// only shows up in Cmm dumps under -dppr-debug.
 +testUnreachable (W_ x)
 +{
 +  if (x > 0) {
 +    goto live;
 +  }
 +  return (x);
++
 +dead:
 +  x = x + 42;
 +  return (x);
++
 +live:
 +  x = x - 1;
 +  return (x);
 +}

testsuite/tests/cmm/should_compile/T27368-ppr-debug.stderr

+// unreachable blocks:

testsuite/tests/cmm/should_compile/all.T

@@ -13,6 +13,9 @@ test('T20725', normal, compile, ['-package ghc'])
  test('T23610', normal, makefile_test, ['T23610'])
  test('T24224', [cmm_src, grep_errmsg(r'(F64.*);', [1]), only_ways(['normal'])], compile, ['-no-hs-main -ddump-cmm -dsuppress-all -dsuppress-uniques'])
  test('T24474', cmm_src, compile, ['-optc-g3'])
 +# -dppr-debug makes stored-but-unreachable blocks visible in Cmm dumps (#27368)
 +test('T27368-ppr-debug', [cmm_src, grep_errmsg(r'(// unreachable blocks:)', [1]), only_ways(['normal'])],
 +     compile, ['-no-hs-main -ddump-cmm-verbose-by-proc -dppr-debug -dsuppress-uniques'])
  test('T24474-cmm-gets-c-opts', cmm_src, compile, ['-optc-DFOO'])
  test('T24474-cmm-opt-order', cmm_src, compile, ['-optc-DFOO '
                                                  '-optCmmP-UFOO '