- ghc-tickets - Haskell.org

[GHC] Trac email verification for user: irongremlin
by GHC 24 Feb '17

24 Feb '17

Please visit the following URL to confirm your email address. Verification URL: <http://ghc.haskell.org/trac/ghc/verify_email?verify=1&token=UJY8QV1U> Username: irongremlin Verification Token: UJY8QV1U -- GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #13301: GHC base directory assumptions
by GHC 24 Feb '17

24 Feb '17

#13301: GHC base directory assumptions ----------------------------------------+--------------------------------- Reporter: Phyx- | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler | Version: 8.0.2 Keywords: | Operating System: Windows Architecture: Unknown/Multiple | Type of failure: None/Unknown Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: ----------------------------------------+--------------------------------- GHC and ghc-pkg make some pretty hard assumptions about where they're running on Windows. They assume that they are always running from `foo/bin/ghc.exe` and that to find the `lib` folder they can drop `bin/ghc.exe` from the base path and append `lib`. This is already false for the testsuite, which when testing the bindist has one test which puts the binaries in `inplace/test spaces`. For some reason before this was either being skipped or mysteriously passing. But as of `2017.02.11` our luck ran out. the testsuite triggers a failure such as: {{{ [04:16:21][Step 3/6] ghc-pkg.exe: Can't find package database in C:/TeamCity/buildAgent/work/28754042a1be6052/inplace/test sp\lib [04:16:22][Step 3/6] ghc-pkg.exe: Can't find package database in C:/TeamCity/buildAgent/work/28754042a1be6052/inplace/test sp\lib [04:16:23][Step 3/6] Traceback (most recent call last): [04:16:23][Step 3/6] File "../../driver/runtests.py", line 215, in <module> [04:16:23][Step 3/6] pkginfo = str(getStdout([config.ghc_pkg, 'dump'])) [04:16:23][Step 3/6] File "/c/TeamCity/buildAgent/work/28754042a1be6052/testsuite/driver/testutil.py", line 23, in getStdout [04:16:23][Step 3/6] raise Exception("Command failed: " + str(cmd_and_args)) [04:16:23][Step 3/6] Exception: Command failed: ['"/c/TeamCity/buildAgent/work/28754042a1be6052/inplace/test spaces/ghc- pkg.exe"', 'dump'] [04:16:23][Step 3/6] make: *** [../../mk/test.mk:299: test] Error 1 [04:16:23][Step 3/6] [04:16:23][Step 3/6] ==== STAGE 1 TESTS ==== [04:16:23][Step 3/6] cat: testsuite_summary_stage1.txt: No such file or directory [04:16:23][Step 3/6] Process exited with code 1 }}} Let's soften the assumption and just check that `../lib` exists instead. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13301> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #13287: The runtime parses arguments past -- under windows but passes them on as arguments on linux
by GHC 24 Feb '17

24 Feb '17

#13287: The runtime parses arguments past -- under windows but passes them on as arguments on linux -------------------------------------+------------------------------------- Reporter: AndreasK | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Runtime | Version: 8.0.2 System | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Other Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Starting a executable like this: app -- arg1 +RTS -s -RTS arg2 Windows and Linux pass different arguments on to the application: * Windows: `["--","arg1","arg2"]` * Linux: `["--","arg1","+RTS","-s","-RTS","arg2"]` If we want uniform behavior we need to change one of these. Given the existence of the --RTS flag I'm not sure if the Linux behavior was intended however it matches the behavior you would expect in the *nix world nicely. Therefore changing the behavior on Windows would make more sense. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13287> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #13321: Importing a bundled pattern "infects" all other imports of that pattern
by GHC 24 Feb '17

24 Feb '17

#13321: Importing a bundled pattern "infects" all other imports of that pattern -------------------------------------+------------------------------------- Reporter: ezyang | Owner: (none) Type: bug | Status: new Priority: low | Milestone: Component: Compiler | Version: 8.0.1 (Type checker) | 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: {{{ {-# LANGUAGE PatternSynonyms #-} unit p where module A0 where data G = G Int module A1 where import A0 pattern X x = G x module A(G(X)) where import A0 import A1 module B(G) where import A module C(pattern X) where import A module D(N.G, pattern N.X) where import B import C import qualified A0 as N import qualified A1 as N }}} When we look at the interface for D, we see that N is bundled with D. This is a little surprising because I explicitly exported the G and X from A0 and A1, where no bundling took place. I suppose the current semantics might also be alright, but we should explicitly say so. The spec in the wiki is silent in this respect: https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms/AssociatingSynonyms -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13321> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #12413: Compact regions support needs some discussion in the release notes
by GHC 24 Feb '17

24 Feb '17

#12413: Compact regions support needs some discussion in the release notes -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: task | Status: new Priority: highest | Milestone: 8.2.1 Component: Documentation | Version: 8.0.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: -------------------------------------+------------------------------------- And perhaps elsewhere in the users guide. It was merged as cf989ffe490c146be4ed0fd7e0c00d3ff8fe1453. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12413> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #13307: Record pattern synonym fields have to be manually exported
by GHC 24 Feb '17

24 Feb '17

#13307: Record pattern synonym fields have to be manually exported -------------------------------------+------------------------------------- Reporter: ocharles | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- The following currently fails to compile: {{{#!hs {-# LANGUAGE PatternSynonyms #-} module A ( T(T) ) where data Impl = Impl Int newtype T = MkT Impl pattern T {x} = MkT (Impl x) {-# LANGUAGE RecordWildCards #-} module B where import A foo :: T -> Int foo T{x} = x }}} As far as GHC can see, in module `B`, `T` does not have a field `x`. The fix is to manually export `x` from `A`: {{{#!hs module A (T(T, x)) where }}} But this is tedious for records with a large amount of fields -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13307> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] Trac email verification for user: coopercm
by GHC 24 Feb '17

24 Feb '17

Please visit the following URL to confirm your email address. Verification URL: <http://ghc.haskell.org/trac/ghc/verify_email?verify=1&token=Qtp3pZ4U> Username: coopercm Verification Token: Qtp3pZ4U -- GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #12798: LLVM seeming to over optimize, producing inefficient assembly code...
by GHC 24 Feb '17

24 Feb '17

#12798: LLVM seeming to over optimize, producing inefficient assembly code... -------------------------------------+------------------------------------- Reporter: GordonBGood | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1 (LLVM) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Since in many cases, the use of the LLVM backend is the only way to avoid the NCG's poor register allocation (ticket #8971), this is a concern that using "-fllvm" is producing overly complex code through a (seeming) failed attempt to optimize. The following code uses a very simple "odds-only" implementation of the Sieve of Eratosthenes with a very tight inner culling loop limited to using a 16 Kilobyte buffer (<= the size of most modern CPU L1 data cache size) to reproduce the problem; it uses a "twos" Look Up Table (LUT) for better speed than using a variable shift left operation for setting the composite bits in the buffer array as it (should) take the same number of registers and the array look-up instruction is easier for the CPU to fuse than a variable shift left: {{{#!hs -- GHC_EfficiencyBug.hs {-# LANGUAGE FlexibleContexts #-} {-# OPTIONS_GHC -O3 -fllvm -rtsopts -keep-s-files #-} -- or -O2 import Data.Word import Data.Bits import Data.Array.ST (runSTUArray) import Data.Array.Base numLOOPS = 10000 :: Int twos :: UArray Int Word32 twos = listArray (0, 31) [1 `shiftL` i | i <- [0 .. 31]] soe :: () -> [Word32] soe() = 2 : [fromIntegral i * 2 + 3 | (i, False) <- assocs bufb] where bufb = runSTUArray $ do let bfLmt = (256 * 1024) `div` 2 - 1 -- to 2^18 + 2 is 128 KBits - 1 = 16 KBytes cmpstsb <- newArray (0, bfLmt) False :: ST s (STUArray s Int Bool) cmpstsw <- (castSTUArray :: STUArray s Int Bool -> ST s (STUArray s Int Word32)) cmpstsb let loop n = -- cull a number of times to test timing if n <= 0 then return cmpstsb else let cullp i = let p = i + i + 3 in let s = (p * p - 3) `div` 2 in if s > bfLmt then loop (n - 1) else do isCmpst <- unsafeRead cmpstsb i if isCmpst then cullp (i + 1) else -- is Prime let cull j = -- very tight inner loop where all the time is spent if j > bfLmt then cullp (i + 1) else do let sh = unsafeAt twos (j .&. 31) -- (1 `shiftL` (j .&. 31))) let w = j `shiftR` 5 ov <- unsafeRead cmpstsw w unsafeWrite cmpstsw w (ov .|. sh) cull (j + p) in cull s in cullp 0 loop numLOOPS main = print $ length $ soe() }}} The main culling is repeated "numLOOPS" times to get a reasonable execution time for accurate timing and to make the time required to use the List comprehension to determine the number of found primes (the answer) a negligible part of the execution time. Timing results can be produced by running "./GHC_EfficiencyBug +RTS -s". The desired assembly code result for the tight inner loop is as for the Rust/LLVM compiler, in this case for x86_64 64-bit code: {{{ .p2align 4, 0x90 .LBB10_27: movq %rcx, %rdx shrq $5, %rdx movl %ecx, %esi andl $31, %esi movl (%rbp,%rsi,4), %esi orl %esi, (%r14,%rdx,4) addq %rax, %rcx .LBB10_26: cmpq %r13, %rcx jb .LBB10_27 }}} The above code is extremely efficient on a CPU that is not cache bottle necked (such as the AMD Bulldozer series are) and takes just about three clock cycles per inner composite culling loop on Intel Sky Lake; it is just as efficient for x86 code since there are only seven registers used in this inner loop. Due to this attempt at "over-optimization", the GHC/LLVM backend produces the following x86_64 64-bit code: {{{ .align 16, 0x90 .LBB34_2: # %c8T2 # =>This Inner Loop Header: Depth=1 movq %rcx, %rsi sarq $5, %rsi movl %r8d, %edi andl $124, %edi movl 16(%rax,%rdi), %edi orl %edi, 16(%r11,%rsi,4) addq %r14, %rcx addq %rdx, %r8 cmpq %r10, %rcx jle .LBB34_2 }}} As can be seen, instead of just masking the "twos" index register by 31 (0x1F), the code is using two extra separate registers to contain "(j * 4)" increment and the accumulated index, which increment is added to the "twos" index register per loop and masked by 124 (0x7C or 0x1F times 4), requiring an extra two registers and an extra instruction for the extra addition. This isn't a problem as to the number of registers for x86_64 code which has more than enough, but it adds the extra instruction execution time of one third of a CPU clock cycle (I know, only one ninth extra time). However, for 32-bit x86 code with barely enough registers previously, the use of the extra registers triggers a chain of three register reloads as can be seen in the following assembly code: {{{ .align 16, 0x90 LBB33_2: # %c8Wb # =>This Inner Loop Header: Depth=1 movl %ebx, %ebp sarl $5, %ebp movl %edi, %ecx andl $124, %ecx movl %esi, %edx movl %eax, %esi movl 36(%esp), %eax # 4-byte Reload movl 8(%eax,%ecx), %ecx movl %esi, %eax movl %edx, %esi orl %ecx, 8(%esi,%ebp,4) addl 32(%esp), %ebx # 4-byte Folded Reload addl 28(%esp), %edi # 4-byte Folded Reload cmpl %eax, %ebx jle LBB33_2 }}} '''The above code runs about 25% slower than it should on Intel Sky Lake for this 32-bit code.''' This was tested for GHC version 8.0.1 under both Windows and Linux for both 32-bit and 64-bit code with identical results for each native code width. The code was also tested for 32 and 64 bit code produced by the NCG; for this specific problem, NCG takes the simple approach and does not waste the extra register. However, due to the inefficient allocation of registers as per ticket #8971, not moving the loop completion check to the end of the loop and thus requiring an extra jump instruction, and not combining the read/modify/write into a single instruction, it is still slower (much slower for 32-bit code) than the LLVM produced code. As its problems are known, I have not documented the NCG code. Conclusion: This may seem like a nit picky type of bug as in some use cases the execution time cost is very small, but it may be an indication of problems in other use cases that cause more serious effects on execution speed. It is my feeling that for such low level somewhat imperative types of code, GHC should really produce code that is as fast as C/C++/Rust. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12798> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #13318: ghc-7.10.1 panics when compiling singletons-1.1.2.1
by GHC 23 Feb '17

23 Feb '17

#13318: ghc-7.10.1 panics when compiling singletons-1.1.2.1 -------------------------------------+------------------------------------- Reporter: WrenThornton | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.1 Keywords: | 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: -------------------------------------+------------------------------------- Not sure if this has been fixed in newer versions or not, but: {{{ [39 of 45] Compiling Data.Singletons.Prelude.List ( src/Data/Singletons/Prelude/List.hs, dist/build/Data/Singletons/Prelude/List.o ) ghc: panic! (the 'impossible' happened) (GHC version 7.10.1 for x86_64-apple-darwin): Template variable unbound in rewrite rule n_X2iZh [a_a2gBn, t_a2gBo, n_a2iB7, ipv_s2szc, ipv_s2szd, sc_s2tXD, sc_s2tXF, sc_s2tXG, sg_s2tXH] [a_X2gZv, t_X2gZx, n_X2iZh, ipv_X2sXn, ipv_X2sXp, sc_X2ulQ, sc_X2ulT, sc_X2ulV, sg_X2ulX] [TYPE a_a2gBn, TYPE t_a2gBo, TYPE Let1627878522XsSym4 t_a2gBo n_a2iB7 ipv_s2szc ipv_s2szd, sc_s2tXD, (SCons @ a_a2gBn @ (ipv_s2szc : ipv_s2szd) @ ipv_s2szc @ ipv_s2szd @~ <ipv_s2szc : ipv_s2szd>_N sc_s2tXF sc_s2tXG) `cast` (sg_s2tXH :: R:Sing[]z (ipv_s2szc : ipv_s2szd) ~R# Sing (Apply (Apply (:$) ipv_s2szc) ipv_s2szd))] [TYPE a_a2gBn, TYPE t_a2gBo, TYPE Let1627878522XsSym4 t_a2gBo ipv_s2szc ipv_X2sQZ ipv_X2sR1, sc_s2tXD, (SCons @ a_a2gBn @ (ipv_X2sQZ : ipv_X2sR1) @ ipv_X2sQZ @ ipv_X2sR1 @~ <ipv_X2sQZ : ipv_X2sR1>_N ipv_s2szf ipv_s2szg) `cast` (Sub (Sym (TFCo:R:Sing[]z[0] <a_a2gBn>_N)) (Sym (TFCo:R:Apply[][]:$$l0[0] <a_a2gBn>_N <ipv_X2sR1>_N <ipv_X2sQZ>_N) ; (Apply (Sym (TFCo:R:Apply(->)k:$l0[0] <a_a2gBn>_N <ipv_X2sQZ>_N)) <ipv_X2sR1>_N)_N) :: R:Sing[]z (ipv_X2sQZ :$$$ ipv_X2sR1) ~R# Sing (Apply (Apply (:$) ipv_X2sQZ) ipv_X2sR1))] Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13318> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #13319: Generate makefile dependencies suitable for ghc --make!
by GHC 23 Feb '17

23 Feb '17

#13319: Generate makefile dependencies suitable for ghc --make! -------------------------------------+------------------------------------- Reporter: 1chb | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 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: -------------------------------------+------------------------------------- When using `ghc --make` to generate a binary, I'm interested to know what source files was used. I want that information to tell when to regenerate the binary. Yes, I use a `gmake` files to build my binaries even for `ghc` generated binaries. `gmake` is very convenient and useful as is `ghc --make`, but it is difficult to combine these two. For now, I can always call `ghc --make` but it takes extra build times. Especially when there are many binaries to build. I have considered the `-M` flag but it seems to be usable for separate compilation only. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13319> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0