February 2016 - ghc-tickets

[GHC] #10616: Panic in ghci debugger with PolyKinds and PhantomTypes
by GHC 02 Jan '18

02 Jan '18

#10616: Panic in ghci debugger with PolyKinds and PhantomTypes -----------------------------------------+------------------------------- Reporter: bjmprice | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | Version: 7.10.1 Keywords: | Operating System: Linux Architecture: x86_64 (amd64) | Type of failure: GHCi crash Test Case: | Blocked By: Blocking: | Related Tickets: Differential Revisions: | -----------------------------------------+------------------------------- The code {{{#!hs {-# LANGUAGE PolyKinds #-} data D a = A | B f d@A = const True d f B = False }}} when loaded in ghci, runs fine without breakpoints, but panics when breaking on {{{f A}}}, thus: {{{ *Main> f A True *Main> :break 5 Breakpoint 0 activated at DebuggerCrash.hs:5:9-20 *Main> f A ghc-stage2: panic! (the 'impossible' happened) (GHC version 7.10.1 for x86_64-unknown-linux): ASSERT failed! file compiler/typecheck/TcUnify.hs line 1138 k_amp }}} It is fine in 7.4.1 and 7.8.1. It panics in 7.10.1 and HEAD@d71b65f53a1daa2631d2c818c7ea6add77813532 Without one (or both) of PolyKinds or the phantom type it runs fine. {{{uname -a: Linux cam-05-unx 3.5.0-54-generic #81~precise1-Ubuntu SMP Tue Jul 15 04:02:22 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux}}} {{{ gcc -v: Using built-in specs. COLLECT_GCC=gcc COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.6/lto-wrapper Target: x86_64-linux-gnu Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.6.3-1ubuntu5' --with-bugurl=file:///usr/share/doc/gcc-4.6/README.Bugs --enable-languages=c,c++,fortran,objc,obj-c++ --prefix=/usr --program- suffix=-4.6 --enable-shared --enable-linker-build-id --with-system-zlib --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.6 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable- libstdcxx-time=yes --enable-gnu-unique-object --enable-plugin --enable- objc-gc --disable-werror --with-arch-32=i686 --with-tune=generic --enable- checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu Thread model: posix gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) }}} With {{{ghci-7.10.1 -v}}} {{{ ghci-7.10.1 -v ./DebuggerCrash.hs GHCi, version 7.10.1: http://www.haskell.org/ghc/ :? for help Glasgow Haskell Compiler, Version 7.10.1, stage 2 booted by GHC version 7.8.2 Using binary package database: /5playpen/t-bepric/ghc-7.10.1-build/inplace/lib/package.conf.d/package.cache wired-in package ghc-prim mapped to ghc-prim-0.4.0.0-inplace wired-in package integer-gmp mapped to integer-gmp-1.0.0.0-inplace wired-in package base mapped to base-4.8.0.0-inplace wired-in package rts mapped to builtin_rts wired-in package template-haskell mapped to template- haskell-2.10.0.0-inplace wired-in package ghc mapped to ghc-7.10.1-inplace wired-in package dph-seq not found. wired-in package dph-par not found. Hsc static flags: Loading package ghc-prim-0.4.0.0 ... linking ... done. *** gcc: /usr/bin/gcc -fno-stack-protector -DTABLES_NEXT_TO_CODE -L/5playpen/t-bepric/ghc-7.10.1-build/libraries/integer-gmp2/dist- install/build --print-file-name libgmp.so Loading package integer-gmp-1.0.0.0 ... linking ... done. Loading package base-4.8.0.0 ... linking ... done. wired-in package ghc-prim mapped to ghc-prim-0.4.0.0-inplace wired-in package integer-gmp mapped to integer-gmp-1.0.0.0-inplace wired-in package base mapped to base-4.8.0.0-inplace wired-in package rts mapped to builtin_rts wired-in package template-haskell mapped to template- haskell-2.10.0.0-inplace wired-in package ghc mapped to ghc-7.10.1-inplace wired-in package dph-seq not found. wired-in package dph-par not found. *** Chasing dependencies: Chasing modules from: Stable obj: [] Stable BCO: [] unload: retaining objs [] unload: retaining bcos [] Ready for upsweep [] Upsweep completely successful. *** Deleting temp files: Deleting: *** Chasing dependencies: Chasing modules from: *DebuggerCrash.hs Stable obj: [] Stable BCO: [] unload: retaining objs [] unload: retaining bcos [] Ready for upsweep [NONREC ModSummary { ms_hs_date = 2015-07-08 14:18:11 UTC ms_mod = Main, ms_textual_imps = [import (implicit) Prelude] ms_srcimps = [] }] *** Deleting temp files: Deleting: compile: input file DebuggerCrash.hs Created temporary directory: /tmp/ghc22370_0 *** Checking old interface for Main: [1 of 1] Compiling Main ( DebuggerCrash.hs, interpreted ) *** Parser: *** Renamer/typechecker: *** Desugar: Result size of Desugar (before optimization) = {terms: 16, types: 26, coercions: 0} Result size of Desugar (after optimization) = {terms: 12, types: 18, coercions: 0} *** Simplifier: Result size of Simplifier iteration=1 = {terms: 12, types: 20, coercions: 0} Result size of Simplifier = {terms: 12, types: 20, coercions: 0} *** Tidy Core: Result size of Tidy Core = {terms: 12, types: 20, coercions: 0} *** CorePrep: Result size of CorePrep = {terms: 16, types: 30, coercions: 0} *** ByteCodeGen: Upsweep completely successful. *** Deleting temp files: Deleting: /tmp/ghc22370_0/ghc22370_2.c /tmp/ghc22370_0/ghc22370_1.o Warning: deleting non-existent /tmp/ghc22370_0/ghc22370_2.c Warning: deleting non-existent /tmp/ghc22370_0/ghc22370_1.o Ok, modules loaded: Main. *Main> f A *** Parser: *** Desugar: *** Simplify: *** CorePrep: *** ByteCodeGen: True *Main> :break 5 Breakpoint 0 activated at DebuggerCrash.hs:5:9-20 *Main> f A *** Parser: *** Desugar: *** Simplify: *** CorePrep: *** ByteCodeGen: ghc-stage2: panic! (the 'impossible' happened) (GHC version 7.10.1 for x86_64-unknown-linux): ASSERT failed! file compiler/typecheck/TcUnify.hs line 1138 k_amp }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10616> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #8487: Debugger confuses variables
by GHC 02 Jan '18

02 Jan '18

#8487: Debugger confuses variables ------------------------------------+------------------------------------- Reporter: edsko | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Consider the following example: {{{ import Control.Exception f = do ma <- try $ evaluate a case ma of Right str -> return a Left err -> return $ show (err :: SomeException) where a :: String a = error "hi" }}} Load into ghci, set a breakpoint on the 5th line, then run f: {{{ :break 5 f }}} You will get {{{ Stopped at Ex.hs:(5,3)-(7,53) _result :: IO String = _ a :: Either SomeException String = Left _ }}} This doesn't make sense. `a` has type `String`; it is `ma` that has type `Either SomeException String`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8487> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #11113: Type family If is too strict
by GHC 01 Jan '18

01 Jan '18

#11113: Type family If is too strict -------------------------------------+------------------------------------- Reporter: olshanskydr | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This code {{{#!hs type family Div (k::Nat) (n::Nat) where Div k n = If (CmpNat k n == LT) 0 (1 + Div (k-n) n) }}} is not working. When I try {{{ ghci> :t (Proxy :: Proxy (Div 100 9)) }}} it hangs on. Probably ghci is trying to calculate both '''If''' branches. If I rewrite it this way {{{#!hs type family Div (k::Nat) (n::Nat) where Div k n = Div' k n (CmpNat k n) type family Div' (k::Nat) (n::Nat) (b::Ordering) where Div' k n LT = 0 Div' k n EQ = 1 Div' k n GT = 1 + Div (k-n) n }}} it works well -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11113> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #8642: Allow GHCi to print non-pretty forms of things.
by GHC 29 Dec '17

29 Dec '17

#8642: Allow GHCi to print non-pretty forms of things. ------------------------------------+------------------------------------- Reporter: Fuuzetsu | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: GHCi | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Currently when we ask GHCi for :info or :type of something, it will do things like splitting over multiple lines and all that eye candy that people like to see. This however makes it more difficult for people to write text editor plugins &c that rely on GHCi output. Currently one has to write parsers to stitch the GHCi output back together which is fairly error prone and not really future-proof. Is there any chance for a more machine-friendly output? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8642> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #9291: Don't reconstruct sum types if the type subtly changes
by GHC 28 Dec '17

28 Dec '17

#9291: Don't reconstruct sum types if the type subtly changes ----------------------------------------------+---------------------------- Reporter: schyler | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.2 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Moderate (less than a day) | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: ----------------------------------------------+---------------------------- Consider this test case: {{{ module Main (main) where fun :: Either Int String -> Either String String fun x = case x of Left int -> Left (show int) Right str -> Right str {-# NOINLINE fun #-} main :: IO () main = do l <- getLine print $ fun (Right l) }}} The core we get for fun looks like: {{{ Main.fun [InlPrag=NOINLINE] :: Data.Either.Either GHC.Types.Int GHC.Base.String -> Data.Either.Either GHC.Base.String GHC.Base.String [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U>] Main.fun = \ (x_aur :: Data.Either.Either GHC.Types.Int GHC.Base.String) -> case x_aur of _ [Occ=Dead] { Data.Either.Left int_aus -> Data.Either.Left @ GHC.Base.String @ GHC.Base.String (GHC.Show.$fShowInt_$cshow int_aus); Data.Either.Right str_aCG -> Data.Either.Right @ GHC.Base.String @ GHC.Base.String str_aCG } }}} There would be less allocations and probably perform better if we just coerced `x` into the new type. Because the coercion is common code, this also means that if hypothetically some other sum type which had 15 constructors, and only 3 had subtle type changes, 12 of the case branches could be CSE'd into the single coerce greatly reducing code generated and also hinting the inliner better. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9291> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 50

[GHC] #11380: `cabal repl` exhausts memory
by GHC 24 Dec '17

24 Dec '17

#11380: `cabal repl` exhausts memory -------------------------------------+------------------------------------- Reporter: kennethb | Owner: Type: bug | Status: new Priority: high | Milestone: Component: Compiler | Version: 7.10.2 Keywords: | Operating System: Unknown/Multiple Architecture: x86_64 | Type of failure: Compile-time (amd64) | crash Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- I have a project that depends on happy/alex to generate parsers. (https://github.com/TOSPIO/pyn) Running `cabal repl` on my laptop (Gentoo Linux amd64) with 16GiB memory ended up eating up all memory and eventually resulted in kernel panic. `cabal build` works fine. Problem arises when compiling the giant happy- generated dist/build/Language/Python/Parser/Parse.hs file also `cabal repl --ghc-options=-fobject-code` works fine. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11380> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #10012: Cheap-to-compute values aren't pushed into case branches inducing unnecessary register pressure
by GHC 22 Dec '17

22 Dec '17

#10012: Cheap-to-compute values aren't pushed into case branches inducing unnecessary register pressure -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.4 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Revisions: | -------------------------------------+------------------------------------- When characterizing bytestring's `Builder` interface[1] I noticed that some benchmarks involving repeated appends (e.g. `Host endian/1MB of Word8 in chunks of 16`) perform inexplicably much worse than others. A glance at the assembly revealed that a large number of `Word8`s are being evaluated and saved to registers, only to be later stored. E.g., ```#!asm # First we evaluate a number of Word8s, saving them in registers movzbl %bl,%ebx leaq 1(%r14),%rcx movzbl %cl,%ecx leaq 2(%r14),%rdx movzbl %dl,%edx leaq 3(%r14),%rsi movzbl %sil,%esi leaq 4(%r14),%r9 movzbl %r9b,%r9d leaq 5(%r14),%r10 movzbl %r10b,%r10d ... # Eventually we run out of registers and start spilling to the stack movq %rax,64(%rsp) leaq 7(%r14),%rax movzbl %al,%eax movq %rbx,72(%rsp) ... # Only after evaluating all of the needed words do we actually consume # them movq %rax,-152(%r12) movq 72(%rsp),%rax movq %rax,-144(%r12) movq 80(%rsp),%rax movq %rax,-136(%r12) movq 88(%rsp),%rax movq %rax,-128(%r12) ... movq %rsi,-56(%r12) movq %r9,-48(%r12) movq %r10,-40(%r12) movq %r11,-32(%r12) movq %r14,-24(%r12) ``` This is due to the fact that the `Word`s are bound outside of a case analysis and GHC is reluctant to push them inside of the branches. The float-in pass will only float a binding into a case if the value is "small" and at least one branch doesn't use the binding. Unfortunately the case expression in question has only two branches. This is demonstrated in the attached testcase. [1] https://github.com/kolmodin/binary/pull/65 [2] https://www.haskell.org/pipermail/ghc-devs/2015-January/007997.html -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10012> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 20

[GHC] #9244: Compiler could warn about type variable shadowing, and hint about ScopedTypeVariables
by GHC 18 Dec '17

18 Dec '17

#9244: Compiler could warn about type variable shadowing, and hint about ScopedTypeVariables -------------------------+------------------------------------------------- Reporter: | Owner: stusmith | Status: new Type: | Milestone: feature request | Version: 7.6.3 Priority: | Operating System: Unknown/Multiple normal | Type of failure: Incorrect warning at Component: | compile-time Compiler | Test Case: Keywords: | Blocking: Architecture: | Unknown/Multiple | Difficulty: | Unknown | Blocked By: | Related Tickets: | -------------------------+------------------------------------------------- GHC already warns about variable shadowing: {{{ timesTwoPlusOne x = timesTwo x + 1 where timesTwo x = x * 2 Warning: This binding for `x' shadows the existing binding bound at <location> }}} However the similar warning doesn't happen for type variables. {{{ tryMaybe :: IO a -> IO (Maybe a) tryMaybe action = do result <- (try action) :: IO (Either SomeException a) return $ case result of Left _ -> Nothing Right v -> Just v Couldn't match type `a' with `a1' `a' is a rigid type variable bound by the type signature for tryMaybe :: IO a -> IO (Maybe a) at types.hs:<line>:13 `a1' is a rigid type variable bound by an expression type signature: IO (Either SomeException a1) at types.hs:<line>:15 Expected type: IO a1 Actual type: IO a ... }}} Here, I thought that the 'a' in the function's type declaration was the same 'a' in the expression type declaration. However in Haskell 98, they are completely different variables. Suggestion: if a type variable is renamed by the compiler due to a clash with another type variable, issue a warning that the second shadows the first, and give a hint about using -XScopedTypeVariables and forall. Alternative suggestion: if an error is displayed, where the error contains a renamed type variable, issue a hint that the second shadows the first, and give a hint about using -XScopedTypeVariables and forall. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9244> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #8272: testing if SpLim=$rbp and Sp=$rsp changed performance at all
by GHC 16 Dec '17

16 Dec '17

#8272: testing if SpLim=$rbp and Sp=$rsp changed performance at all ----------------------------------------------+---------------------------- Reporter: carter | Owner: carter Type: task | Status: new Priority: normal | Milestone: 7.10.1 Component: Compiler | Version: 7.7 Keywords: callingConvention | Operating System: Architecture: x86_64 (amd64) | Unknown/Multiple Difficulty: Project (more than a week) | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: ----------------------------------------------+---------------------------- testing if SpLim=$rbp and Sp=$rsp changed performance at all would need a stack check but then push could be used to spill to the stack Idea via Nathan Howell. At the very least, the x86 PUSH instruction has a more succinct encoding than MOV. worth hacking out to see if this can measurable shift ghc perf on nofib or not. this would be part of a larger effort to explore ways to improve GHC's calling convention for modern hardware -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8272> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 16

[GHC] #11203: Kind inference with SigTvs is wrong
by GHC 15 Dec '17

15 Dec '17

#11203: Kind inference with SigTvs is wrong -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider {{{#!hs data SameKind :: k -> k -> * data Q (a :: k1) (b :: k2) c = MkQ (SameKind a b) }}} This code should be rejected. Yet it is accepted. The problem is that, when kind-checking a datatype declaration without a CUSK, GHC uses `SigTv`s for user-written kind variables. `SigTv`s are allowed to unify with other `SigTv`s, leading to incorrect behavior here. The motivating scenario is this: {{{#!hs data T (a :: k1) x = MkT (S a ()) data S (b :: k2) y = MkS (T b ()) }}} This program should be accepted. Neither type has a CUSK and therefore is not generalized before kind-checking the group. GHC must then unify `k1` and `k2`. If they were skolems, this unification would fail and this pair of definitions would be rejected. This ticket is identical in spirit to #9201, but that example has a CUSK and thus works. The bug can happen only when there is no CUSK. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11203> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12