September 2014 - ghc-tickets

[GHC] #8896: ghci fails on Arm - "Illegal instruction"
by GHC 01 Mar '15

01 Mar '15

#8896: ghci fails on Arm - "Illegal instruction" ----------------------------+------------------------------- Reporter: Ansible | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.1-rc2 Keywords: arm ghci | Operating System: Linux Architecture: arm | Type of failure: GHCi crash Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ----------------------------+------------------------------- With the help of qemu compiled ghc 7.8.1-rc2 for raspberry pi. Ghc is successful, and ghci compiles, but ghci gets an 'Illegal instruction' error. A sample session: ccrma@satellite:~$ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.8.0.20140228 ccrma@satellite:~$ ghci --version The Glorious Glasgow Haskell Compilation System, version 7.8.0.20140228 ccrma@satellite:~$ ghci GHCi, version 7.8.0.20140228: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... Illegal instruction ccrma@satellite:~$ -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8896> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 10

[GHC] #9586: Implement Traversable/Foldable-Burning-Bridges Proposal
by GHC 27 Feb '15

27 Feb '15

#9586: Implement Traversable/Foldable-Burning-Bridges Proposal -------------------------------------+------------------------------------- Reporter: hvr | Owner: hvr Type: task | Status: new Priority: normal | Milestone: 7.10.1 Component: libraries/base | Version: Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Difficult (2-5 | Type of failure: days) | None/Unknown Blocked By: | Test Case: Related Tickets: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- More details to follow. I've created this ticket to be able to refer to from related preparatory commits. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9586> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 45

[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] #9103: hackage's type-level-0.2.4 fails to compile
by GHC 23 Feb '15

23 Feb '15

#9103: hackage's type-level-0.2.4 fails to compile -------------------------------------+------------------------------------- Reporter: slyfox | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: 7.8.2 checker) | Operating System: Unknown/Multiple Keywords: | Type of failure: GHC rejects Architecture: Unknown/Multiple | valid program Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | -------------------------------------+------------------------------------- Attached trimmed-down dependencyless archive. Steps to reproduce: {{{ $ tar -xzf type-level-0.2.4.tar.gz $ ghci -hide-all-packages -package=base -package=template-haskell Data/TypeLevel.hs }}} The error on 7.8.2 and in -HEAD is: {{{ [6 of 8] Compiling Data.TypeLevel.Num.Ops ( Data/TypeLevel/Num/Ops.hs, interpreted ) Data/TypeLevel/Num/Ops.hs:90:10: Illegal instance declaration for ‘Succ' (x, x) (x, x) D0 D0 True’ The liberal coverage condition fails in class ‘Succ'’ for functional dependency: ‘yh yl yz -> xh xl’ Reason: lhs types ‘D0’, ‘D0’, ‘True’ do not jointly determine rhs types ‘(x, x)’, ‘(x, x)’ In the instance declaration for ‘Succ' (x, x) (x, x) D0 D0 True’ ... }}} Typechecked fine on ghc-7.6.3 {{{ [1 of 8] Compiling Data.TypeLevel.Num.Reps ( Data/TypeLevel/Num/Reps.hs, interpreted ) [2 of 8] Compiling Data.TypeLevel.Num.Sets ( Data/TypeLevel/Num/Sets.hs, interpreted ) [3 of 8] Compiling Data.TypeLevel.Num.Aliases.TH ( Data/TypeLevel/Num/Aliases/TH.hs, interpreted ) [4 of 8] Compiling Data.TypeLevel.Num.Aliases ( Data/TypeLevel/Num/Aliases.hs, interpreted ) Generating and compiling a zillion numerical type aliases, this might take a while [5 of 8] Compiling Data.TypeLevel.Bool ( Data/TypeLevel/Bool.hs, interpreted ) [6 of 8] Compiling Data.TypeLevel.Num.Ops ( Data/TypeLevel/Num/Ops.hs, interpreted ) [7 of 8] Compiling Data.TypeLevel.Num ( Data/TypeLevel/Num.hs, interpreted ) [8 of 8] Compiling Data.TypeLevel ( Data/TypeLevel.hs, interpreted ) Ok, modules loaded: Data.TypeLevel, Data.TypeLevel.Num, Data.TypeLevel.Bool, Data.TypeLevel.Num.Reps, Data.TypeLevel.Num.Aliases, Data.TypeLevel.Num.Sets, Data.TypeLevel.Num.Ops, Data.TypeLevel.Num.Aliases.TH. *Data.TypeLevel> }}} I have failed to decipher an error message, but looks like it tries to instantiate a thing it should not. My apologies if it's not-a-bug. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9103> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 18

[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

[GHC] #8309: traceEvent truncates to 512 bytes
by GHC 23 Feb '15

23 Feb '15

#8309: traceEvent truncates to 512 bytes ------------------------------------+------------------------------------- Reporter: duncan | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Runtime System | Version: 7.6.3 Keywords: eventlog tracing | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- The `Debug.Trace.traceEvent` (& `traceEventIO`) use a code path that unnecessarily uses printf format strings and uses a fixed size 512-byte buffer, hence truncating all user trace messages at that size. Here is the call path: * `Debug.Trace.traceEvent` (& `traceEventIO`) call `traceEvent#` primop * cmm impl of the primop `stg_traceEventzh` calls C RTS function `traceUserMsg` * `traceUserMsg` calls `traceFormatUserMsg(cap, "%s", msg);`, using the printf format string * `traceFormatUserMsg` uses `postUserMsg` which eventually calls `postLogMsg` * `postLogMsg` does the printf stuff Here's what `postLogMsg` does: {{{ #define BUF 512 void postLogMsg(EventsBuf *eb, EventTypeNum type, char *msg, va_list ap) { char buf[BUF]; nat size; size = vsnprintf(buf,BUF,msg,ap); if (size > BUF) { buf[BUF-1] = '\0'; size = BUF; } .... }}} This is obviously designed for RTS-internal users, not the user path. So the problem starts with this bit: {{{ void traceUserMsg(Capability *cap, char *msg) { traceFormatUserMsg(cap, "%s", msg); } }}} It just should not use that code path. It should call something that directly posts the message, without any silly printf strings. In fact, the code path from the primop down should really be changed to use an explicit given length, rather than using a null-terminated string and having to call strlen. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8309> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #8546: Panic during cabal build with profiling enabled.
by GHC 23 Feb '15

23 Feb '15

#8546: Panic during cabal build with profiling enabled. ---------------------------------+--------------------------------------- Reporter: Mokosha | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: cabal sandbox | Operating System: Windows Architecture: x86 | Type of failure: Compile-time crash Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ---------------------------------+--------------------------------------- I had been recently using cabal-dev for my development work. Someone suggested I switch over to the new cabal 1.18 on #haskell. After doing so, some projects do not seem to build anymore. I'm not an experienced Haskell developer, so I'm not sure how to go about debugging such a problem. I've included the output of the install command. {{{ Pavel@ZOMBIE-POWER ~/Projects/Lambency/src $ cabal install -p Resolving dependencies... Configuring bindings-GLFW-3.0.3.1... Building bindings-GLFW-3.0.3.1... Preprocessing library bindings-GLFW-3.0.3.1... [1 of 1] Compiling Bindings.GLFW ( dist\dist-sandbox- 2b66993e\build\Bindings\GLFW.hs, dist\dist-sandbox- 2b66993e\build\Bindings\GLFW.o ) [1 of 1] Compiling Bindings.GLFW ( dist\dist-sandbox- 2b66993e\build\Bindings\GLFW.hs, dist\dist-sandbox- 2b66993e\build\Bindings\GLFW.p_o ) In-place registering bindings-GLFW-3.0.3.1... Installing library in D:\MinGW\msys\1.0\home\Pavel\Projects\Lambency\build\i386-windows- ghc-7.6.3\bindings-GLFW-3.0.3.1 Registering bindings-GLFW-3.0.3.1... Installed bindings-GLFW-3.0.3.1 Configuring GLFW-b-1.4.1... Building GLFW-b-1.4.1... Preprocessing library GLFW-b-1.4.1... [1 of 3] Compiling Graphics.UI.GLFW.Types ( Graphics\UI\GLFW\Types.hs, dist\dist-sandbox-2b66993e\build\Graphics\UI\GLFW\Types.o ) Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Loading package bindings-DSL-1.0.20 ... linking ... done. Loading package bindings-GLFW-3.0.3.1 ... ghc.exe: Unknown PEi386 section name `.drectve' (while processing: D:\MinGW\msys\1.0\home\Pavel\Projects\Lambency\build\i386-windows- ghc-7.6.3\bindings-GLFW-3 .0.3.1\libHSbindings-GLFW-3.0.3.1.a) ghc.exe: panic! (the 'impossible' happened) (GHC version 7.6.3 for i386-unknown-mingw32): loadArchive "D:\\MinGW\\msys\\1.0\\home\\Pavel\\Projects\\Lambency\\build\\i386 -windows-ghc-7.6.3\\bindings-GLFW-3.0.3.1\\libHSbindings-GLFW-3.0.3.1.a": failed Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Failed to install GLFW-b-1.4.1 cabal.exe: Error: some packages failed to install: GLFW-b-1.4.1 failed during the building phase. The exception was: ExitFailure 1 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8546> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #9631: Comment in GHC.Base about GHC.Prim does not appear to be correct
by GHC 22 Feb '15

22 Feb '15

#9631: Comment in GHC.Base about GHC.Prim does not appear to be correct -------------------------------------+------------------------------------- Reporter: dfeuer | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: libraries/base | Version: 7.8.3 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | Documentation bug Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- The comment reads {{{ GHC.Prim Has no implementation. It defines built-in things, and by importing it you bring them into scope. The source file is GHC.Prim.hi-boot, which is just copied to make GHC.Prim.hi }}} It does not appear that any files by these names exist. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9631> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #8362: Filesystem related tests failed on solaris (SmartOS)
by GHC 22 Feb '15

22 Feb '15

#8362: Filesystem related tests failed on solaris (SmartOS) --------------------------+------------------------------------------------ Reporter: leroux | Owner: Type: bug | Status: new Priority: high | Milestone: 7.8.1 Component: | Version: 7.6.3 libraries (other) | Operating System: Solaris Keywords: | Type of failure: Incorrect result at runtime Architecture: | Test Case: Unknown/Multiple | Blocking: Difficulty: | Unknown | Blocked By: | Related Tickets: | --------------------------+------------------------------------------------ Getting filesystem (files/permissions) related test faiures on SmartOS (32bit). {{{ $ uname -a SunOS pkgx86 5.11 joyent_20130919T215407Z i86pc i386 i86pc Solaris }}} Unexpected failures: `TEST="openFile003 getPermissions001 processGroup002 user001 posix005"` The testsuite output is attached. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8362> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #9388: Narrow the scope of the notorious "state hack"
by GHC 22 Feb '15

22 Feb '15

#9388: Narrow the scope of the notorious "state hack" -------------------------------------+------------------------------------- Reporter: simonpj | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.2 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- The "state hack" has caused any number of bug reports (just search for that string), the most recent of which is #9349. Here's an idea to make it less pervasive: (roughly) use the state hack only for top-level functions definitions. The idea is that for nested lambdas the context should give the one-shot- ness, now that we are equipped with cardinality analysis. For example, consider the call {{{ replicatM_ 1000 (\(s :: RealWorld#) -> blah) }}} The lambda is 1000-shot, not one-shot, notwithstanding the type of the binder. Moreover `replicateM_`'s strictness/cardinality signature will say just that, and GHC already knows how to propagate that information onto the `\s`. But for top level functions like {{{ pr :: String -> IO () pr x = putStrLn (reverse x) }}} we get Core {{{ pr = \x. let y = reverse x in \ (s :: State# RealWorld). putStrLn y s }}} and, since we can't see all the callers of `pr`, we don't know if work is lost by pushing the `reverse` call inside, to get {{{ pr = \x. (s :: State# RealWorld). putStrLn (reverse x) s }}} which is much more efficient. Indeed, this might not be so good if the calls looked like {{{ ... replicateM_ 1000 (pr "foo")... }}} because then "foo" will be reversed 1000 times. But arguably that's what the programmer expects anyway, looking at the code; and the efficiency hit from not eta-expanding all functions like `pr` (which are very very common) is significant. The point is the that the only ones that need hacking are the top-level guys, and maybe even the top-level ''exported'' guys. I have not fully thought this through, let alone tried it out, but I wanted to capture the thought. It would need some careful performance testing. Simon -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9388> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6