- ghc-devs - Haskell.org

Unexpected duplicate join points in "Core" output?
by Viktor Dukhovni 24 Nov '21

24 Nov '21

The below "Core" output from "ghc -O2" (9.2/8.10) for the attached program shows seemingly rendundant join points: join { exit :: State# RealWorld -> (# State# RealWorld, () #) exit (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit1 :: State# RealWorld -> (# State# RealWorld, () #) exit1 (ipv :: State# RealWorld) = jump $s$j ipv } in that are identical in all but name. These correspond to fallthrough to the "otherwise" case in: ... | acc < q || (acc == q && d <= 5) -> loop (ptr `plusPtr` 1) (acc * 10 + d) | otherwise -> return Nothing but it seems that the generated X86_64 code (also below) ultimately consolidates these into a single target... Is that why it is harmless to leave these duplicated in the generated "Core"? [ Separately, in the generated machine code, it'd also be nice to avoid comparing the same "q" with the accumulator twice. A single load and compare should I think be enough, as I'd expect the status flags to persist across the jump the second test. This happens to not be performance critical in my case, because most calls should satisfy the first test, but generally I think that 3-way "a < b", "a == b", "a > b" branches ideally avoid comparing twice... ] ======== Associated Core output -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} main2 :: Addr# main2 = "12345678901234567890 junk"# -- RHS size: {terms: 129, types: 114, coercions: 0, joins: 6/8} main1 :: State# RealWorld -> (# State# RealWorld, () #) main1 = \ (eta :: State# RealWorld) -> let { end :: Addr# end = plusAddr# main2 25# } in join { $s$j :: State# RealWorld -> (# State# RealWorld, () #) $s$j _ = hPutStr2 stdout $fShowMaybe4 True eta } in join { exit :: State# RealWorld -> (# State# RealWorld, () #) exit (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit1 :: State# RealWorld -> (# State# RealWorld, () #) exit1 (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit2 :: Addr# -> Word# -> State# RealWorld -> (# State# RealWorld, () #) exit2 (ww :: Addr#) (ww1 :: Word#) (ipv :: State# RealWorld) = case eqAddr# ww main2 of { __DEFAULT -> hPutStr2 stdout (++ $fShowMaybe1 (case $w$cshowsPrec3 11# (integerFromWord# ww1) [] of { (# ww3, ww4 #) -> : ww3 ww4 })) True eta; 1# -> jump $s$j ipv } } in joinrec { $wloop :: Addr# -> Word# -> State# RealWorld -> (# State# RealWorld, () #) $wloop (ww :: Addr#) (ww1 :: Word#) (w :: State# RealWorld) = join { getDigit :: State# RealWorld -> (# State# RealWorld, () #) getDigit (eta1 :: State# RealWorld) = case eqAddr# ww end of { __DEFAULT -> case readWord8OffAddr# ww 0# eta1 of { (# ipv, ipv1 #) -> let { ipv2 :: Word# ipv2 = minusWord# (word8ToWord# ipv1) 48## } in case gtWord# ipv2 9## of { __DEFAULT -> case ltWord# ww1 1844674407370955161## of { __DEFAULT -> case ww1 of { __DEFAULT -> jump exit ipv; 1844674407370955161## -> case leWord# ipv2 5## of { __DEFAULT -> jump exit1 ipv; 1# -> jump $wloop (plusAddr# ww 1#) (plusWord# 18446744073709551610## ipv2) ipv } }; 1# -> jump $wloop (plusAddr# ww 1#) (plusWord# (timesWord# ww1 10##) ipv2) ipv }; 1# -> jump exit2 ww ww1 ipv } }; 1# -> jump exit2 ww ww1 eta1 } } in jump getDigit w; } in jump $wloop main2 0## realWorld# ======== Executable disassembly The jumps at "-1->" and "-2->" that correspond that "otherwise" have the same target. The duplicate "load+cmp" with "q" is at "-3->" and "-4->": 0000000000408de8 <Main_main1_info>: 408de8: 48 8d 45 e8 lea -0x18(%rbp),%rax 408dec: 4c 39 f8 cmp %r15,%rax 408def: 0f 82 c8 00 00 00 jb 408ebd <Main_main1_info+0xd5> 408df5: b8 79 dd 77 00 mov $0x77dd79,%eax 408dfa: 31 db xor %ebx,%ebx 408dfc: b9 60 dd 77 00 mov $0x77dd60,%ecx 408e01: 48 39 c1 cmp %rax,%rcx 408e04: 74 66 je 408e6c <Main_main1_info+0x84> 408e06: 0f b6 11 movzbl (%rcx),%edx 408e09: 48 83 c2 d0 add $0xffffffffffffffd0,%rdx 408e0d: 48 83 fa 09 cmp $0x9,%rdx 408e11: 77 59 ja 408e6c <Main_main1_info+0x84> -3-> 408e13: 48 be 99 99 99 99 99 mov $0x1999999999999999,%rsi 408e1a: 99 99 19 408e1d: 48 39 f3 cmp %rsi,%rbx 408e20: 73 0c jae 408e2e <Main_main1_info+0x46> 408e22: 48 6b db 0a imul $0xa,%rbx,%rbx 408e26: 48 01 d3 add %rdx,%rbx 408e29: 48 ff c1 inc %rcx 408e2c: eb d3 jmp 408e01 <Main_main1_info+0x19> -4-> 408e2e: 48 be 99 99 99 99 99 mov $0x1999999999999999,%rsi 408e35: 99 99 19 408e38: 48 39 f3 cmp %rsi,%rbx -1-> 408e3b: 75 49 jne 408e86 <Main_main1_info+0x9e> 408e3d: 48 83 fa 05 cmp $0x5,%rdx -2-> 408e41: 77 43 ja 408e86 <Main_main1_info+0x9e> 408e43: 48 8d 5a fa lea -0x6(%rdx),%rbx 408e47: 48 ff c1 inc %rcx 408e4a: eb b5 jmp 408e01 <Main_main1_info+0x19> 408e4c: 0f 1f 40 00 nopl 0x0(%rax) 408e50: c2 00 00 retq $0x0 -- Viktor.

3 7

LINE pragma behaviour
by Alan & Kim Zimmerman 23 Nov '21

23 Nov '21

I am working through some ghc-exactprint test cases with GHC 9.2.1 and came across an oddity. If I parse some source with {-# LINE 93 "Foo.chs" #-} on line five, it shows up in the ParseSource as (L (Anchor { LINE:5:1-25 } (UnchangedAnchor)) (EpaComment (EpaLineComment "{-# LINE 93 \"Foo.chs\" #-}") { LINE:5:1-25 })) and the following item locations are unchanged. The effect seems to be to change the name of the file in the RealSrcSpan to "LINE", but just for that line, and no other effect. Is this expected? Alan

2 1

can GHC generate an irreducible control-flow graph? If so, how?
by Norman Ramsey 22 Nov '21

22 Nov '21

I'm trying to figure out how to persuade GHC to generate an irreducible control-flow graph (so I can test an algorithm to convert it to structured control flow). The attached image shows (on the left) the classic simple irreducible CFG: there is a loop between nodes A and B, but neither one dominates the other, so there is no loop header. I tried to get GHC to generate this CFG using the following source code: length'' :: Bool -> List a -> Int length'' trigger xs = if trigger then countA 0 xs else countB 0 xs where countA n Nil = case n of m -> m countA n (Cons _ as) = case n + 1 of m -> countB m as countB n Nil = case n of m -> m countB n (Cons _ as) = case n + 2 of m -> countA m as Unfortunately (for my purposes), GHC generates a perfectly lovely reducible flow graph with a single header node. It is even possible for GHC to generate an irreducible control-flow graph? If so, how can it be done? Norman

3 2

asking for an extra set of eyes on Cmm.Dataflow (Hoopl) change proposal
by Norman Ramsey 22 Nov '21

22 Nov '21

At present, Cmm dataflow analysis works only on Cmm code. I'd like to do a dataflow analysis on native code. Details at https://gitlab.haskell.org/ghc/ghc/-/issues/20725 where I'd love an extra set of eyes from the Cmm/Dataflow/Hoopl crowd. Norman

1 0

SOLVED: how to map CLabel to Label for procedure entry point?
by Norman Ramsey 22 Nov '21

22 Nov '21

> I'm struggling to figure out how to get from a CLabel found in a > CmmProc to a Label used to key the blocks in the control-flow graph > (CmmGraph) for the CmmProc. I figured it out---this is the wrong problem. I need to take the `g_entry` BlockId straight out of the CmmGraph. Norman

1 0

how to map CLabel to Label for procedure entry point?
by Norman Ramsey 22 Nov '21

22 Nov '21

I'm struggling to figure out how to get from a CLabel found in a CmmProc to a Label used to key the blocks in the control-flow graph (CmmGraph) for the CmmProc. The code generator needs such a function, so it must be around somewhere, but I have not yet found it. I've poked around the respective modules for CLabel and for Label, and also modules like CmmToAsm. Can anyone help me out? Norman

1 0

[Take 2] Unexpected duplicate join points in "Core" output?
by Viktor Dukhovni 20 Nov '21

20 Nov '21

[ Sorry wrong version of attachment in previous message. ] The below "Core" output from "ghc -O2" (9.2/8.10) for the attached program shows seemingly rendundant join points: join { exit :: State# RealWorld -> (# State# RealWorld, () #) exit (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit1 :: State# RealWorld -> (# State# RealWorld, () #) exit1 (ipv :: State# RealWorld) = jump $s$j ipv } in that are identical in all but name. These correspond to fallthrough to the "otherwise" case in: ... | acc < q || (acc == q && d <= 5) -> loop (ptr `plusPtr` 1) (acc * 10 + d) | otherwise -> return Nothing but it seems that the generated X86_64 code (also below) ultimately consolidates these into a single target... Is that why it is harmless to leave these duplicated in the generated "Core"? [ Separately, in the generated machine code, it'd also be nice to avoid comparing the same "q" with the accumulator twice. A single load and compare should I think be enough, as I'd expect the status flags to persist across the jump the second test. This happens to not be performance critical in my case, because most calls should satisfy the first test, but generally I think that 3-way "a < b", "a == b", "a > b" branches ideally avoid comparing twice... ] ======== Associated Core output -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} main2 :: Addr# main2 = "12345678901234567890 junk"# -- RHS size: {terms: 129, types: 114, coercions: 0, joins: 6/8} main1 :: State# RealWorld -> (# State# RealWorld, () #) main1 = \ (eta :: State# RealWorld) -> let { end :: Addr# end = plusAddr# main2 25# } in join { $s$j :: State# RealWorld -> (# State# RealWorld, () #) $s$j _ = hPutStr2 stdout $fShowMaybe4 True eta } in join { exit :: State# RealWorld -> (# State# RealWorld, () #) exit (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit1 :: State# RealWorld -> (# State# RealWorld, () #) exit1 (ipv :: State# RealWorld) = jump $s$j ipv } in join { exit2 :: Addr# -> Word# -> State# RealWorld -> (# State# RealWorld, () #) exit2 (ww :: Addr#) (ww1 :: Word#) (ipv :: State# RealWorld) = case eqAddr# ww main2 of { __DEFAULT -> hPutStr2 stdout (++ $fShowMaybe1 (case $w$cshowsPrec3 11# (integerFromWord# ww1) [] of { (# ww3, ww4 #) -> : ww3 ww4 })) True eta; 1# -> jump $s$j ipv } } in joinrec { $wloop :: Addr# -> Word# -> State# RealWorld -> (# State# RealWorld, () #) $wloop (ww :: Addr#) (ww1 :: Word#) (w :: State# RealWorld) = join { getDigit :: State# RealWorld -> (# State# RealWorld, () #) getDigit (eta1 :: State# RealWorld) = case eqAddr# ww end of { __DEFAULT -> case readWord8OffAddr# ww 0# eta1 of { (# ipv, ipv1 #) -> let { ipv2 :: Word# ipv2 = minusWord# (word8ToWord# ipv1) 48## } in case gtWord# ipv2 9## of { __DEFAULT -> case ltWord# ww1 1844674407370955161## of { __DEFAULT -> case ww1 of { __DEFAULT -> jump exit ipv; 1844674407370955161## -> case leWord# ipv2 5## of { __DEFAULT -> jump exit1 ipv; 1# -> jump $wloop (plusAddr# ww 1#) (plusWord# 18446744073709551610## ipv2) ipv } }; 1# -> jump $wloop (plusAddr# ww 1#) (plusWord# (timesWord# ww1 10##) ipv2) ipv }; 1# -> jump exit2 ww ww1 ipv } }; 1# -> jump exit2 ww ww1 eta1 } } in jump getDigit w; } in jump $wloop main2 0## realWorld# ======== Executable disassembly The jumps at "-1->" and "-2->" that correspond that "otherwise" have the same target. The duplicate "load+cmp" with "q" is at "-3->" and "-4->": 0000000000408de8 <Main_main1_info>: 408de8: 48 8d 45 e8 lea -0x18(%rbp),%rax 408dec: 4c 39 f8 cmp %r15,%rax 408def: 0f 82 c8 00 00 00 jb 408ebd <Main_main1_info+0xd5> 408df5: b8 79 dd 77 00 mov $0x77dd79,%eax 408dfa: 31 db xor %ebx,%ebx 408dfc: b9 60 dd 77 00 mov $0x77dd60,%ecx 408e01: 48 39 c1 cmp %rax,%rcx 408e04: 74 66 je 408e6c <Main_main1_info+0x84> 408e06: 0f b6 11 movzbl (%rcx),%edx 408e09: 48 83 c2 d0 add $0xffffffffffffffd0,%rdx 408e0d: 48 83 fa 09 cmp $0x9,%rdx 408e11: 77 59 ja 408e6c <Main_main1_info+0x84> -3-> 408e13: 48 be 99 99 99 99 99 mov $0x1999999999999999,%rsi 408e1a: 99 99 19 408e1d: 48 39 f3 cmp %rsi,%rbx 408e20: 73 0c jae 408e2e <Main_main1_info+0x46> 408e22: 48 6b db 0a imul $0xa,%rbx,%rbx 408e26: 48 01 d3 add %rdx,%rbx 408e29: 48 ff c1 inc %rcx 408e2c: eb d3 jmp 408e01 <Main_main1_info+0x19> -4-> 408e2e: 48 be 99 99 99 99 99 mov $0x1999999999999999,%rsi 408e35: 99 99 19 408e38: 48 39 f3 cmp %rsi,%rbx -1-> 408e3b: 75 49 jne 408e86 <Main_main1_info+0x9e> 408e3d: 48 83 fa 05 cmp $0x5,%rdx -2-> 408e41: 77 43 ja 408e86 <Main_main1_info+0x9e> 408e43: 48 8d 5a fa lea -0x6(%rdx),%rbx 408e47: 48 ff c1 inc %rcx 408e4a: eb b5 jmp 408e01 <Main_main1_info+0x19> 408e4c: 0f 1f 40 00 nopl 0x0(%rax) 408e50: c2 00 00 retq $0x0 -- Viktor.

2 4

Re: How to build Haddock documentation quickly?
by Andrey Mokhov 20 Nov '21

20 Nov '21

Hi Norman, > I'm more than willing to dive into Hadrian and figure out how it works. > I could even add a new target to build just what I'm interested in. > But I would need help. I've spent some time poking around the `doc` directory, and I've read > the Shake papers (and some of Andrei's work) but I've never used these tools myself. I would be delighted to help you (or anyone else!) navigate Hadrian source code. Please feel free to get in touch directly. (Alas, in the last couple of years I couldn't contribute to improving Hadrian but that's not for the lack of desire - just due to some life changes. Hopefully I can at least help by helping others!) Cheers, Andrey

1 0

How to build Haddock documentation quickly?
by Norman Ramsey 19 Nov '21

19 Nov '21

In service of #20528, I'm trying to clean up some Haddock documentation in the GHC sources. The only command I know is ./hadrian/build -j _build/docs/html/index.html It turns out that if I change Haddock comments in one file (GHC/Tc/Gen/Foreign.hs), rebuilding the HTML takes a minute and a quarter. That's a little long. (And I had one build take over four minutes, which is even longer.) What tricks can I use to speed up this process? Might there be a way to run Haddock directly until things are to my liking? Norman

2 2

DWARF support
by Richard Eisenberg 19 Nov '21

19 Nov '21

Hi devs, I was intrigued by Bodigrim's comment about HasCallStack in base (https://github.com/haskell/core-libraries-committee/issues/5#issuecomment-9…) that there are other alternatives, such as DWARF. Over the years, I had tuned out every time I saw the word DWARF: it was (and is!) an unknown acronym and seems like a low-level detail. But Bodigrim's comment made me want to re-think this stance. I found Ben's series of blog posts on DWARF, starting with https://www.haskell.org/ghc/blog/20200403-dwarf-1.html. These are very helpful! In particular, they taught me that DWARF = platform-native debugging metadata. Is that translation accurate? If so, perhaps we should use both names: if I see that GHC x.y.z has DWARF support, I quickly scroll to the next bullet. If I see that GHC x.y.z has support for platform-native debugging metadata and is now compatible with e.g. gdb, I'm interested. Going further, I have a key question for my use case: is this support available on Mac? The first post in the series describes support for "Linux and several BSDs" and the last post says that "Windows PDB support" is future work. (Is "PDB" platform-native debugging metadata for Windows? I don't know.) But I don't see any mention of Mac. What's the status here? It would be very cool if this conversation ends with me making a video on how a few simple GHC flags can allow us to, say, get a stack trace on a pattern-match failure in a Haskell program. Thanks! Richard

8 13