February 2014 - ghc-tickets

[GHC] #8727: HLearn test on ubuntu Precise x64 within vagrant Box
by GHC 23 Mar '15

23 Mar '15

#8727: HLearn test on ubuntu Precise x64 within vagrant Box ----------------------------------+-------------------------- Reporter: teuffy | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Linux Architecture: x86_64 (amd64) | Type of failure: Other Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ----------------------------------+-------------------------- ghc: panic! (the 'impossible' happened) (GHC version 7.6.3 for x86_64-unknown-linux): loadArchive "/home/vagrant/.cabal/lib/x86_64-linux- ghc-7.6.3/HLearn-2.0.0.0/libHSHLearn-2.0.0.0.a": failed {{{ import HLearn.Algebra import Control.DeepSeq import HLearn.Models.Distributions import Statistics.Distribution.Normal dataset = [1,2,3,4,5,6] --dist = train dataset :: Normal Double data Marble = Red | Green | Blue | White deriving (Read,Show,Eq,Ord) simonBag :: [Marble] simonBag = [Red, Red, Red, Green, Blue, Green, Red, Blue, Green, Green, Red, Red, Blue, Red, Red, Red, White] simonDist = train simonBag :: Categorical Double Marble }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8727> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 18

[GHC] #8078: Core lint failure for profiled code
by GHC 23 Mar '15

23 Mar '15

#8078: Core lint failure for profiled code -----------------------------------+--------------------------------------- Reporter: ezyang | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time crash Unknown/Multiple | Test Case: T4492 Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | -----------------------------------+--------------------------------------- Probably related to the cardinality changes. Here is the dump: =====> T4492(profasm) 3361 of 3686 [2, 51, 0] cd ./indexed-types/should_compile && '/srv/code/ghc-build- sandbox/inplace/bin/ghc-stage2' -fforce-recomp -dcore-lint -dcmm-lint -dno-debug-output -no-user-package-db -rtsopts -fno-ghci-history -c T4492.hs -O -prof -static -auto-all >T4492.comp.stderr 2>&1 Compile failed (status 256) errors were: *** Core Lint errors : in result of CorePrep *** {-# LINE 12 "T4492.hs #-}: Warning: [RHS of T4492.$fCMaybe_$cgo :: forall a_aex. T4492.C a_aex => forall b_ae0. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_ae0 -> a1_ae1) -> Data.Maybe.Maybe a_aex -> T4492.F (Data.Maybe.Maybe a_aex) b_ae0] Demand type has 4 arguments, rhs has 3 arguments, T4492.$fCMaybe_$cgo Binder's strictness signature: DmdType <C(C(S)),1*C1(C1(U))><L,U><L,U><L,U> *** Offending Program *** T4492.go [InlPrag=INLINE] :: forall a_adZ. T4492.C a_adZ => forall b_ae0. (forall a_ae1. Data.Maybe.Maybe a_ae1 -> b_ae0 -> a_ae1) -> a_adZ -> T4492.F a_adZ b_ae0 [GblId[ClassOp], Arity=1, Caf=NoCafRefs, Str=DmdType <S,U>, Unf=OtherCon []] T4492.go = \ (@ a_adZ) (tpl_sgH [Occ=Once] :: T4492.C a_adZ) -> tpl_sgH `cast` (T4492.NTCo:C[0] <a_adZ> :: T4492.C a_adZ ~# (forall b_ae0. (forall a_ae1. Data.Maybe.Maybe a_ae1 -> b_ae0 -> a_ae1) -> a_adZ -> T4492.F a_adZ b_ae0)) T4492.$fCMaybe1 :: forall a_aex. T4492.C a_aex => forall b_afH. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) -> Data.Maybe.Maybe a_aex -> b_afH -> T4492.F a_aex b_afH [GblId, Arity=4, Caf=NoCafRefs, Str=DmdType <C(C(S)),1*C1(C1(U))><L,U><L,U><L,U>, Unf=OtherCon []] T4492.$fCMaybe1 = \ (@ a_aex) ($dC_sgI [Occ=OnceL] :: T4492.C a_aex) (@ b_afH) (f_sgJ :: forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) (a1_sgK [Occ=OnceL] :: Data.Maybe.Maybe a_aex) (b1_sgL [Occ=OnceL] :: b_afH) -> scctick<go> let { sat_sgM [Occ=Once] :: a_aex [LclId, Str=DmdType] sat_sgM = f_sgJ @ a_aex a1_sgK b1_sgL } in ($dC_sgI `cast` (T4492.NTCo:C[0] <a_aex> :: T4492.C a_aex ~# (forall b_ae0. (forall a_ae1. Data.Maybe.Maybe a_ae1 -> b_ae0 -> a_ae1) -> a_aex -> T4492.F a_aex b_ae0))) @ b_afH f_sgJ sat_sgM T4492.$fCMaybe_$cgo :: forall a_aex. T4492.C a_aex => forall b_ae0. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_ae0 -> a1_ae1) -> Data.Maybe.Maybe a_aex -> T4492.F (Data.Maybe.Maybe a_aex) b_ae0 [GblId, Arity=3, Caf=NoCafRefs, Str=DmdType <C(C(S)),1*C1(C1(U))><L,U><L,U><L,U>, Unf=OtherCon []] T4492.$fCMaybe_$cgo = (\ (@ a_aex) (eta_B3 [Occ=Once] :: T4492.C a_aex) (@ b_afH) (eta_B2 [Occ=Once] :: forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) (eta_B1 [Occ=Once] :: Data.Maybe.Maybe a_aex) -> T4492.$fCMaybe1 @ a_aex eta_B3 @ b_afH eta_B2 eta_B1) `cast` (forall a_aex. <T4492.C a_aex> -> forall b_afH. <forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1> -> <Data.Maybe.Maybe a_aex> -> Sym (T4492.TFCo:R:FMaybeb[0] <a_aex> <b_afH>) :: (forall a_aex. T4492.C a_aex => forall b_afH. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) -> Data.Maybe.Maybe a_aex -> b_afH -> T4492.F a_aex b_afH) ~# (forall a_aex. T4492.C a_aex => forall b_afH. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) -> Data.Maybe.Maybe a_aex -> T4492.F (Data.Maybe.Maybe a_aex) b_afH)) T4492.$fCMaybe [InlPrag=INLINE (sat-args=0)] :: forall a_aex. T4492.C a_aex => T4492.C (Data.Maybe.Maybe a_aex) [GblId[DFunId(nt)], Arity=3, Caf=NoCafRefs, Str=DmdType <C(C(S)),1*C1(C1(U))><L,U><L,U><L,U>, Unf=OtherCon []] T4492.$fCMaybe = (\ (@ a_aex) (eta_B3 [Occ=Once] :: T4492.C a_aex) (@ b_afH) (eta_B2 [Occ=Once] :: forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) (eta_B1 [Occ=Once] :: Data.Maybe.Maybe a_aex) -> T4492.$fCMaybe1 @ a_aex eta_B3 @ b_afH eta_B2 eta_B1) `cast` (forall a_aex. <T4492.C a_aex> -> (forall b_afH. <forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1> -> <Data.Maybe.Maybe a_aex> -> Sym (T4492.TFCo:R:FMaybeb[0] <a_aex> <b_afH>)) ; Sym (T4492.NTCo:C[0] <Data.Maybe.Maybe a_aex>) :: (forall a_aex. T4492.C a_aex => forall b_afH. (forall a1_ae1. Data.Maybe.Maybe a1_ae1 -> b_afH -> a1_ae1) -> Data.Maybe.Maybe a_aex -> b_afH -> T4492.F a_aex b_afH) ~# (forall a_aex. T4492.C a_aex => T4492.C (Data.Maybe.Maybe a_aex))) *** End of Offense *** <no location info>: Compilation had errors *** unexpected failure for T4492(profasm) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8078> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #8379: sync-all broken when using the GitHub mirror
by GHC 21 Mar '15

21 Mar '15

#8379: sync-all broken when using the GitHub mirror ------------------------------------+------------------------------------- Reporter: tibbe | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Build System | 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: | ------------------------------------+------------------------------------- Making a fresh checkout using the GitHub mirror: {{{ $ git clone git@github.com:tibbe/ghc.git $ ./sync-all get == running git config core.ignorecase true == running git clone git@github.com:tibbe/ghc-tarballs.git ghc-tarballs Cloning into 'ghc-tarballs'... ERROR: Repository not found. fatal: The remote end hung up unexpectedly git failed: 32768 at ./sync-all line 178. == Checking for old haddock repo == Checking for old binary repo == Checking for old mtl repo == Checking for old Cabal repo == Checking for old time from tarball ============================ ATTENTION! You have an old time package in your GHC tree! Please remove it (e.g. "rm -r libraries/time"), and then run "./sync-all get" to get the new repository. ============================ }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8379> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13

[GHC] #8150: Foreign export requires redundant type signature
by GHC 19 Mar '15

19 Mar '15

#8150: Foreign export requires redundant type signature -------------------------+------------------------------------------------- Reporter: | Owner: evincarofautumn | Status: new Type: bug | Milestone: Priority: | Version: 7.6.3 normal | Operating System: Unknown/Multiple Component: | Type of failure: Incorrect warning at Compiler | compile-time Keywords: | Test Case: Architecture: | Blocking: Unknown/Multiple | Difficulty: | Unknown | Blocked By: | Related Tickets: | -------------------------+------------------------------------------------- With a source file such as: {{{ module FFITest where foreign export ccall "function" function :: IO () function :: IO () function = putStrLn "Hello, world!" }}} The second `function :: IO ()` signature is required to satisfy `-fwarn- missing-signatures`, even though a signature is already present in the `foreign export` declaration, and the types are required to be the same. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8150> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #8315: Improve specialized Hoopl module
by GHC 18 Mar '15

18 Mar '15

#8315: Improve specialized Hoopl module ------------------------------------+------------------------------------- Reporter: jstolarek | Owner: Type: task | Status: new Priority: low | 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: | ------------------------------------+------------------------------------- GHC uses Hoopl to perform some of the Cmm-to-Cmm optimization passes, but instead of relying directly on Hoopl library GHC uses its own specialized module (see [[GhcFile(compiler/cmm/Hoopl/Dataflow.hs)]]). Interface of that module, as well as its internal implementation can be improved. Right now interface places responsibility of maintaining some of the invariants on user. It also ignores differences between forward and backward analysis. [http://ghc.haskell.org/trac/ghc/wiki/Hoopl/Cleanup This wiki page] gives full detail about proposed design changes. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8315> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #8780: abs for IEEE floating point is slightly wrong.
by GHC 08 Mar '15

08 Mar '15

#8780: abs for IEEE floating point is slightly wrong. ------------------------------------+------------------------------------- Reporter: augustss | Owner: Type: bug | Status: new Priority: low | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Evaluating abs(-0) gives the answer -0. This unexpected since it breaks invariants like 1/(abs x) >= 0. So abs(-0) should be 0. This is also the norm for other languages. Together with this change, signum should also be changed so signum(-0) is -0. This maintains the invariant abs x * signum x == x. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8780> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #8274: Core pretty-printer doesn't print # on unboxed literals
by GHC 03 Mar '15

03 Mar '15

#8274: Core pretty-printer doesn't print # on unboxed literals ------------------------------------+------------------------------------- Reporter: jstolarek | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Other Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- I just noticed that Core pretty printer produces something like this (this is part of expected output for T3772 in testsuite): {{{ case GHC.Prim.<=# n# 0 of _ { __DEFAULT -> xs n#; 1 -> GHC.Tuple.() } }}} Both `0` (in scrutinee) and `1` (one of branch alternatives) are unboxed values, so they should be printed as `0#` and `1#` respectively. I haven't checked whether unboxed literals of other types (`Word`, `Double`, `Float`) are printed in that way, but I would guess that yes. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8274> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #8342: System.Directory.getPermissions does not work well on Windows 7
by GHC 02 Mar '15

02 Mar '15

#8342: System.Directory.getPermissions does not work well on Windows 7 ---------------------------------------+--------------------------------- Reporter: freizl | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: libraries/directory | Version: 7.4.1 Keywords: | Operating System: Windows Architecture: x86_64 (amd64) | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ---------------------------------------+--------------------------------- It works well for following code {{{ System.Directory.getPermissions "/path/to/somewhere" }}} However getting error with this: {{{ System.Directory.getPermissions "/path/to/somewhere/" *** Exception: getPermissions: does not exist (No such file or directory) }}} The only difference is the path name. It gets error when having extra trailing slash. It looks wired. Thanks your help. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8342> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #8189: Default to infinite stack size?
by GHC 24 Feb '15

24 Feb '15

#8189: Default to infinite stack size? ------------------------------------+------------------------------------- Reporter: nh2 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Runtime crash Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- http://www.haskell.org/pipermail/haskell-cafe/2013-August/108570.html It looks like any code of the form {{{ ... = do x1 <- m1 x2 <- m2 [do something with x1 and m2] }}} will stack overflow when used with a strict monad (like IO) and sufficiently large data to deal with (a 1m element list is enough to exceed the default 8MB stack size limit). Other examples include: {{{ sequence (m:ms) = do x <- m xs <- sequence ms return (x:xs) }}} and {{{ liftM2, liftM3, ... }}} By slightly modifying your program to do the same thing via heap allocation (e.g. using a difference list in sequence), a stack-overflow rejected program turns into a valid program. This means that valid and idiomatic code like {{{ xs <- replicateM n someIOAction xs <- mapM someIOAction [1..n] }}} will eventually crash, which has an impact on practically all Haskell software and libraries out there. For examples, see https://github.com/ndmitchell/shake/blob/e0e0a43/Development/Shake/Database… https://github.com/haskell-suite/haskell-src-exts/issues/27 as well as the mapM usages in cabal, haddock, any database binding that allows querying a lists of results, etc. While some argue that ''"you shouldn't use lists of that size"'', ''"allocating a 150 MB list is wrong"'' or that they ''"carefully avoid any use of sequence/mapM due to the problem"'' pointed out above, I think that collecting a million results of a strict monadic action into a linked list using standard functions like mapM is a common pattern and valid use case. The stack based evaluation that GHC performs is an optimization and should be transparent to the user; it should not re-define some data to live in a fixed-size memory region, and it should work just as well as it does in GHCi. It seems that a default infinite stack size would mitigate this. A drawback might be that the stack space overflows we get so far to quickly spot a "wrong" program would not indicate certain errors any more. I currently doubt the usefulness of this debugging method, since it does not work reliably in the presence of optimization, doing the same thing via heap allocation makes the programs "correct", and it rejects valid programs if the input data is large enough. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8189> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 35

[GHC] #8539: Data.Complex shouldn't use default implementation of (**)
by GHC 23 Feb '15

23 Feb '15

#8539: Data.Complex shouldn't use default implementation of (**) -------------------------------------+------------------------------------- Reporter: jjaredsimpson | Owner: Type: bug | Status: new Priority: low | Milestone: Component: Prelude | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Incorrect result Difficulty: Easy (less than 1 | at runtime hour) | Test Case: Blocked By: | Blocking: Related Tickets: | -------------------------------------+------------------------------------- {{{ Prelude Data.Complex> 0**2 0.0 Prelude Data.Complex> 0**2 :: Complex Double NaN :+ NaN Prelude Data.Complex> exp $ 2 * log 0 :: Complex Double NaN :+ NaN Prelude Data.Complex> log 0 :: Complex Double (-Infinity) :+ 0.0 Prelude Data.Complex> 2 * it :: Complex Double (-Infinity) :+ NaN Prelude Data.Complex> exp it :: Complex Double NaN :+ NaN }}} So Complex uses the default implementation of (!**). Then when 2*(-inf :+ 0) is evaluated. We do (2 * -inf - 0*0) :+ (2*0 + -inf*0). Which because of -inf*0 sets the imaginary part to NaN. Then exp (-inf :+ NaN) = exp x cos y :+ exp x sin y which becomes 0 * cos NaN :+ 0 * sin NaN. So we end up with NaN :+ NaN. Ross Paterson suggested: I would say the default implementation of (!**) is wrong: to match the Float/Double instances it should be x !** y = if x == 0 then 0 else exp (log x * y) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8539> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 44