November 2017 - ghc-tickets

[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] #13001: EnumFromThenTo is is not a good producer
by GHC 22 Dec '17

22 Dec '17

#13001: EnumFromThenTo is is not a good producer -------------------------------------+------------------------------------- Reporter: George | Owner: Type: bug | Status: new Priority: low | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: MacOS X Architecture: x86_64 | Type of failure: Runtime (amd64) | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{#!hs {-# OPTIONS_GHC -Wall #-} module Foo where testFromTo :: Int -> Int testFromTo n = length ([0..(10^n)] :: [Int]) testFromThenTo :: Int -> Int testFromThenTo n = length ([0,2..(10^n)] :: [Int]) }}} {{{ $ ghci -fobject-code -O GHCi, version 8.0.1: http://www.haskell.org/ghc/ :? for help Prelude> :load Foo :load Foo [1 of 1] Compiling Foo ( Foo.hs, Foo.o ) Ok, modules loaded: Foo (Foo.o). Prelude Foo> :set +s :set +s Prelude Foo> testFromTo 5 testFromTo 5 100001 (0.02 secs, 97,992 bytes) Prelude Foo> testFromThenTo 5 testFromThenTo 5 50001 (0.00 secs, 5,694,424 bytes) Prelude Foo> testFromThenTo 6 testFromThenTo 6 500001 (0.02 secs, 56,095,288 bytes) Prelude Foo> }}} I set the Type to bug rather than feature request as the source code in http://hackage.haskell.org/package/base-4.9.0.0/docs/src/GHC.Enum.html#enum… seems to be trying to do list fusion: {{{#!hs -- efdInt and efdtInt deal with [a,b..] and [a,b..c]. -- The code is more complicated because of worries about Int overflow. -- See Note [How the Enum rules work] {-# RULES "efdtInt" [~1] forall x1 x2 y. efdtInt x1 x2 y = build (\ c n -> efdtIntFB c n x1 x2 y) "efdtIntUpList" [1] efdtIntFB (:) [] = efdtInt #-} }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13001> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13

[GHC] #12905: Core lint with pattern synonym
by GHC 22 Dec '17

22 Dec '17

#12905: Core lint with pattern synonym -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: typeable | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | crash or panic Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Yet another program from the type-indexed `Typeable` effort which breaks GHC (`master` branch as of 3bd1dd4d75fde3b922d4de08c16f29bdeb8e05d7) with a core lint error, {{{#!hs {-# LANGUAGE GADTs, TypeOperators, PatternSynonyms, TypeInType, PolyKinds, RankNTypes #-} module T where import GHC.Exts import Data.Kind import Data.Type.Equality data TypeRep (a :: k) where TrTyCon :: TypeRep (a :: k) TrApp :: forall k1 k2 (a :: k1 -> k2) (b :: k1). TypeRep (a :: k1 -> k2) -> TypeRep (b :: k1) -> TypeRep (a b) TrFun :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) (a :: TYPE r1) (b :: TYPE r2). TypeRep a -> TypeRep b -> TypeRep (a -> b) pattern TRFun :: forall k (fun :: k). () => forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) (arg :: TYPE r1) (res :: TYPE r2). (k ~ Type, fun ~~ (arg -> res)) => TypeRep arg -> TypeRep res -> TypeRep fun pattern TRFun arg res <- TrFun arg res where TRFun arg res = TrFun arg res }}} This program produces many core lint errors, although all of them fall into only a few classes. Here's one, {{{ *** Core Lint errors : in result of Desugar (before optimization) *** <no location info>: warning: In the coercion ‘Sym (Sym cobox_a3fT |> Sym cobox_a3fU)’ Kind application error in type ‘((->) |> <*>_N ->_N <*>_N ->_N Sym cobox) a’ Function kind = * -> * -> k Arg kinds = [(a, TYPE r1)] }}} {{{ <no location info>: warning: [RHS of $d~~_a3fO :: (fun :: k) ~~ ((a -> b) :: *)] Kind application error in coercion ‘Sym (Sym (<(->)>_N |> ((<*>_N -> <*>_N -> Sym cobox_a3fU) ; Sym (<*>_N -> <*>_N -> Sym cobox_a3fH))) |> (<*>_N -> <*>_N -> Sym cobox_a3fU)) <a>_N’ Function kind = * -> * -> * Arg kinds = [(a, TYPE r1)] }}} It appears that this is yet another case of the kind of `(->)` being too restrictive (#11714) since `a -> b` appears to be lifted to the coercion `TyConAppCo role (->) [a, b]`. Adding a `FunCo` constructor to `Coercion` would likely be an easy way to resolve this. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12905> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #12670: Representation polymorphism validity check is too strict
by GHC 22 Dec '17

22 Dec '17

#12670: Representation polymorphism validity check is too strict -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: typeable | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- As of 465c6c5d15f8fb54afb78408f3a79e75e74d2cd4 GHC rejects this program, {{{#!hs {-# LANGUAGE GADTs #-} {-# LANGUAGE TypeInType #-} {-# LANGUAGE RankNTypes #-} module Hi where import GHC.Exts data TypeRep (a :: k) where TrFun :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) (a :: TYPE r1) (b :: TYPE r2). TypeRep a -> TypeRep b -> TypeRep (a -> b) }}} Claiming that it has inappropriate polymorphism over `RuntimeRep`, {{{ $ ghc hi2.hs [1 of 1] Compiling Hi ( hi2.hs, hi2.o ) hi2.hs:7:5: error: • A representation-polymorphic type is not allowed here: Type: a Kind: TYPE r1 • In the definition of data constructor ‘TrFun’ In the data type declaration for ‘TypeRep’ }}} I suspect this check is unnecessarily strict since we never need to store a value of type `a` to represent `TypeRep a` at runtime. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12670> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 21

[GHC] #14479: Partial type signatures and generalisation
by GHC 21 Dec '17

21 Dec '17

#14479: Partial type signatures and generalisation -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 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 should be rejected {{{ foo :: Num a => a -> a foo x = g x x where g :: Num b => _ -> b -> b g _ y = x + y }}} But it isn't. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14479> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #14288: ScopedTypeVariables with nexted foralls broken since 8.0.2
by GHC 21 Dec '17

21 Dec '17

#14288: ScopedTypeVariables with nexted foralls broken since 8.0.2 -------------------------------------+------------------------------------- Reporter: | Owner: (none) MikolajKonarski | Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 (Type checker) | Keywords: | Operating System: Linux Architecture: x86_64 | Type of failure: GHC rejects (amd64) | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The following example fails in 8.2.1 and 8.0.2. Works fine in 7.10.3. If that's intended (that only the first forall has extended scope), I didn't find any mention of that in GHC manual. The two commented out variants work fine in all. {{{#!hs {-# LANGUAGE ScopedTypeVariables #-} main :: IO () main = do -- let f :: forall a ref. ref () -> () -- let f :: forall ref. forall a. ref () -> () let f :: forall a. forall ref. ref () -> () f x = let r :: ref () r = x in () return $ f (Just ()) }}} The error (the same in 8.2.1 and 8.0.2) is: {{{#!hs $ ghc --make forall.hs [1 of 1] Compiling Main ( forall.hs, forall.o ) forall.hs:8:21: error: • Couldn't match type ‘ref’ with ‘ref1’ ‘ref’ is a rigid type variable bound by the type signature for: f :: forall a (ref :: * -> *). ref () -> () at forall.hs:6:29 ‘ref1’ is a rigid type variable bound by the type signature for: r :: forall (ref1 :: * -> *). ref1 () at forall.hs:7:22 Expected type: ref1 () Actual type: ref () • In the expression: x In an equation for ‘r’: r = x In the expression: let r :: ref () r = x in () • Relevant bindings include r :: ref1 () (bound at forall.hs:8:17) x :: ref () (bound at forall.hs:7:9) f :: ref () -> () (bound at forall.hs:7:7) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14288> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 25

[GHC] #12512: UnboxedTupleRep-related panic involving typeclasses
by GHC 21 Dec '17

21 Dec '17

#12512: UnboxedTupleRep-related panic involving typeclasses -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | crash Test Case: | Blocked By: Blocking: | Related Tickets: #11723 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- You can trigger a GHC panic by abusing `UnboxedTupleRep` in just the right way: {{{#!hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE UnboxedTuples #-} import GHC.Exts class Wat (a :: TYPE 'UnboxedTupleRep) deriving instance Wat (# a, b #) }}} {{{ $ /opt/ghc/8.0.1/bin/ghc Bug.hs [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) ghc: panic! (the 'impossible' happened) (GHC version 8.0.1 for x86_64-unknown-linux): newTyConEtadArity (#,#) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} This is probably a leak that #11723 didn't plug, as it only considered datatypes, not typeclasses. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12512> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #14537: Do not link to msvcrt.dll
by GHC 19 Dec '17

19 Dec '17

#14537: Do not link to msvcrt.dll ------------------------------------------+---------------------------- Reporter: johndoe | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler (Linking) | Version: 8.2.1 Keywords: | Operating System: Windows Architecture: Unknown/Multiple | Type of failure: Other Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: ------------------------------------------+---------------------------- msvcrt is a system component and you can't depend on it, it should be either msvcrVERSION.dll if you're using dynamic linkage or nothing if you're using static. https://social.msdn.microsoft.com/Forums/vstudio/en-us/2203f72c- 5f09-4565-97b3-21337672b191/msvcrtdll?forum=vcgeneral More against msvcrt: https://sourceforge.net/p/mingw-w64/wiki2/The%20case%20against%20msvcrt.dll/ GCC solution: http://www.mingw.org/node/25#comment-106 (not sure if it is relevant here) P.S. I am not user of GHC, I am just using one application written in Haskell. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14537> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 18