- ghc-tickets - Haskell.org

[GHC] #16369: Implement testing of stage1 in ./validate --hadrian
by GHC 27 Feb '19

27 Feb '19

#16369: Implement testing of stage1 in ./validate --hadrian -------------------------------------+------------------------------------- Reporter: alpmestan | Owner: (none) Type: task | Status: new Priority: high | Milestone: Component: Build System | Version: 8.7 (Hadrian) | 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: -------------------------------------+------------------------------------- While `master` doesn't support `./validate --hadrian` yet, most of that patch is ready in [https://gitlab.haskell.org/ghc/ghc/merge_requests/326 !326] and will be split up in a few MRs to make review & landing easier. However, it doesn't yet implement testing of the stage 1 compiler, just stage 2. This ticket serves as a reminder to implement testing of stage 1 with hadrian in the validate script. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16369> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #16354: LLVM Backend generates invalid assembly.
by GHC 26 Feb '19

26 Feb '19

#16354: LLVM Backend generates invalid assembly. -------------------------------------+------------------------------------- Reporter: AndreasK | Owner: (none) Type: bug | Status: new Priority: high | Milestone: Component: Compiler | Version: 8.9 (LLVM) | Keywords: CodeGen | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{ #!haskell module Main where import System.Random import qualified Data.Vector as V g1 = mkStdGen 0 :: StdGen v2 = take 10000 $ randoms g1 :: [Int] main :: IO () main = do undefined }}} {{{ $ /e/ghc_regSpill/inplace/bin/ghc-stage2.exe Repro.hs -O2 -fllvm -O2 Loaded package environment from C:\ghc\msys64\home\Andi\tmp\minmax\unpred\.ghc.environment.x86_64-mingw32-8.7.20190215 [1 of 1] Compiling Main ( Repro.hs, Repro.o ) C:\\ghc\\msys64\\tmp\\ghc385768_0\\ghc_6.s: Assembler messages: C:\\ghc\\msys64\\tmp\\ghc385768_0\\ghc_6.s:354: Error: junk at end of line, first unrecognized character is `,' `gcc.exe' failed in phase `Assembler'. (Exit code: 1) }}} I've reproduced this with ghc 8.4/8.6 and HEAD using llvm 7.0.1 on windows. It only occurs with -O2. The issues arise from these directives: {{{ .section .rdata,"dr",discard,__xmm@000000000000004e0000000000000000 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16354> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12

[GHC] #15463: "Serious" validation failures on i686
by GHC 26 Feb '19

26 Feb '19

#15463: "Serious" validation failures on i686 -------------------------------------+------------------------------------- Reporter: alpmestan | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.5 Keywords: | Operating System: Linux Architecture: x86 | Type of failure: None/Unknown Test Case: T3171, | Blocked By: heapprof001 | Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- A very recent run of `./validate` on i686 revealed 6 failures, 4 of which I'm hopefully fixing with [https://phabricator.haskell.org/D5031 D5031], but the other two look more serious. The circle ci build logs are here: https://circleci.com/gh/ghc/ghc/7578 One of the remaining failures in particular seems somewhat critical: {{{ Wrong exit code for heapprof001(prof_hc_hb)(expected 0 , actual 139 ) Stdout ( heapprof001 ): a <= a <= a <= a <= a <= a <= a <= Stderr ( heapprof001 ): Segmentation fault *** unexpected failure for heapprof001(prof_hc_hb) }}} While the other one might be a lot simpler: {{{ Actual stdout output differs from expected: --- ./ghci/should_run/T3171.run/T3171.stdout.normalised 2018-07-31 05:27:01.821192706 +0000 +++ ./ghci/should_run/T3171.run/T3171.run.stdout.normalised 2018-07-31 05:27:01.821192706 +0000 @@ -1 +0,0 @@ -Interrupted. *** unexpected failure for T3171(normal) }}} I have not investigated any of those yet, but the first one does seem like a bug. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15463> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #16366: Strict version of `foldlM`.
by GHC 26 Feb '19

26 Feb '19

#16366: Strict version of `foldlM`. -------------------------------------+------------------------------------- Reporter: autotaker | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: | Version: 8.6.3 libraries/base | 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: -------------------------------------+------------------------------------- `Data.Foldable.foldlM` is lazy on the accumulation parameter. A user can define {{{foldlM (\acc x -> acc `seq` step acc x) z xs}}}, but actually this function is NOT strict! It is simplified to the following core: {{{#!hs foldlM (\acc x -> acc `seq` step acc x) z xs == go xs z where go [] acc = pure acc go (x:xs) acc = (acc `seq` step acc x) >>= go xs }}} DemandAnalysis infers that `go` is lazy on the second argument because `pure` is lazy in general (e.g. `IO` Monad). Thus `foldlM'` is needed. Its definition would be: {{{#!hs foldlM' :: (Monad m, Foldable t) => (b -> a -> m b) -> b -> t a -> m b foldlM' f z0 xs = foldr c (\x -> x `seq` pure x) xs z0 where c x k = \z -> z `seq` (f z x >>= k) {-# INLINE c #-} }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16366> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #16362: Deriving a class via an instance that has a TypeError constraint using standalone deriving fails during compilation.
by GHC 26 Feb '19

26 Feb '19

#16362: Deriving a class via an instance that has a TypeError constraint using standalone deriving fails during compilation. -------------------------------------+------------------------------------- Reporter: j9794 | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.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: -------------------------------------+------------------------------------- This bug occurs if I define an instance for a typeclass adding a TypeError constraint on the instance, and then I try to derive that instance using Deriving Via in combination with StandaloneDeriving. This is the shortest example I was able to come up with: {{{ {-# Language DataKinds, UndecidableInstances, StandaloneDeriving, DerivingVia #-} import GHC.TypeLits newtype NotNum a = NotNum a instance (TypeError (Text "Not a num")) => Num (NotNum a) where data Foo = Foo deriving via (NotNum Foo) instance Num Foo }}} In this case, it'll fail in compilation with 'Not a Num'. This only seems to happen when combining deriving via with standalone deriving, because if I derive the class like: {{{ data Foo = Foo deriving Num via (NotNum Foo) }}} It works as expected (doesn't fail with my custom error until I actually try to use a Foo where I should use a Num) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16362> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #16364: Derived Enum for small number of constructors seems suboptimal
by GHC 26 Feb '19

26 Feb '19

#16364: Derived Enum for small number of constructors seems suboptimal -------------------------------------+------------------------------------- Reporter: Fuuzetsu | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.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: -------------------------------------+------------------------------------- {{{#!hs {-# LANGUAGE MagicHash #-} module En (toEnum', toEnum'', toEnum''', toEnum'''') where import GHC.Int import GHC.Prim import GHC.Word data Q' = Foo' | Bar' deriving Enum toEnum' :: Int -> Q' toEnum' 0 = Foo' toEnum' 1 = Bar' toEnum' x = error $ "out of range " <> show x toEnum'' :: Int -> Q' toEnum'' x@(I# n) | x >= 0 && x <= 1 = tagToEnum# n toEnum'' x = error $ "out of range " <> show x toEnum''' :: Int -> Q' toEnum''' x@(I# n) | x == 0 || x == 1 = tagToEnum# n toEnum''' x = error $ "out of range " <> show x toEnum'''' :: Int -> Q' toEnum'''' x@(I# n) = case int2Word# n `leWord#` 1## of 0# -> error $ "out of range " <> show x _ -> tagToEnum# n }}} For the derived {{{toEnum}}}, we get something as {{{#!hs -- RHS size: {terms: 19, types: 4, coercions: 0, joins: 0/0} En.$w$ctoEnum [InlPrag=NOUSERINLINE[2]] :: Int# -> Q' [GblId, Arity=1, Str=<S,U>, Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 83 0}] En.$w$ctoEnum = \ (ww_s3Kl :: Int#) -> case >=# ww_s3Kl 0# of { __DEFAULT -> En.$wlvl ww_s3Kl; 1# -> case <=# ww_s3Kl 1# of { __DEFAULT -> En.$wlvl ww_s3Kl; 1# -> tagToEnum# @ Q' ww_s3Kl } } -- RHS size: {terms: 6, types: 3, coercions: 0, joins: 0/0} En.$fEnumQ'_$ctoEnum [InlPrag=NOUSERINLINE[2]] :: Int -> Q' [GblId, Arity=1, Str=<S(S),1*U(U)>, Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True, Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False) Tmpl= \ (w_s3Ki [Occ=Once!] :: Int) -> case w_s3Ki of { I# ww1_s3Kl [Occ=Once] -> En.$w$ctoEnum ww1_s3Kl }}] En.$fEnumQ'_$ctoEnum = \ (w_s3Ki :: Int) -> case w_s3Ki of { I# ww1_s3Kl -> En.$w$ctoEnum ww1_s3Kl } }}} Two comparisons to find out one thing! Contrast this with something like {{{toEnum'}}}: {{{#!hs toEnum' = \ (ds_d3dp :: Int) -> case ds_d3dp of { I# ds1_d3dr -> case ds1_d3dr of ds2_X3dR { __DEFAULT -> En.$wlvl1 ds2_X3dR; 0# -> En.Foo'; 1# -> En.Bar' } } }}} Surely this seems better? But we don't even have to write out the constructors by hand in this case. {{{toEnum'''}}} actually produces the same code as {{{toEnum'}}}. I also wrote {{{toEnum''''}}} which I had some hopes for but actually runs the slowest. I'm unsure why. Seems simple enough: {{{#!hs toEnum'''' = \ (x_a2Sd :: Int) -> case x_a2Sd of { I# n_a2Se -> case leWord# (int2Word# n_a2Se) 1## of { __DEFAULT -> tagToEnum# @ Q' n_a2Se; 0# -> En.$wlvl4 n_a2Se } } }}} The point of this ticket is to consider whether it's not better to simply expand small number of constructors in a derived enumeration into a pattern match. In microbenchmark, {{{toEnum'}}} seems faster. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16364> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #15936: Rethink Choice of Baseline Commit for Performance Tests
by GHC 25 Feb '19

25 Feb '19

#15936: Rethink Choice of Baseline Commit for Performance Tests -------------------------------------+------------------------------------- Reporter: davide | Owner: (none) Type: task | Status: new Priority: normal | Milestone: 8.6.3 Component: Test Suite | Version: 8.6.2 Keywords: performance | Operating System: Unknown/Multiple tests git notes | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- = Intro = Currently we always use the previous commit when running performance tests. This works well in CI where we fully test each commit in sequence (and hence always have test results for the previous commit). Remember, test results are stored in git notes and are not by default shared between repositories (i.e. your local repo will only have performance results run locally on your machine). This is by design: we want to avoid comparing results form different machines. Unfortunately This is not so effective when testing locally. The programmer may have only run a subset of performance tests on the previous commit, and often have not run the tests at all (this is notably true after performing a rebase: the previous commit has changed). We need to rethink how we pick a baseline commit. = Goals = * In all cases, do something sensible. * Giving a warning if conditions are not idea. Provide clear and simple instructions on how to get to the ideal case. * Give control over the baseline commit to the programmer via command line options. * In general, performance tests should just work! No extra knowledge needed by the programmer. * If tests pass without warning now, then they should pass without warning later. = Proposed Solution = * Choose baseline commit * Provide command line arguments to set the baseline commit * If not baseline commit is provided use the "Ideal baseline commit". * If local test results for the baseline are available use those results. * Else if results from CI are available (without fetching), then use those results. * Else Warn user that there are no results available (tests trivially pass), then suggest fetching CI results (quick and easy, give full command, mention you may have to wait for CI to finish if the commit is recent) or running locally (more accurate, mention exact commit to checkout), or manually select a baseline commit. == Ideal baseline commit == * If there are no new changes: 0 ahead and 0 or more behind master. * Ideal baseline commit is the previous commit. * Else 1 or more ahead and 0 or more behind master. * Ideal baseline commit is `merge-base master HEAD` * Assume that the intention is to create a patch where all new commits will ultimately be squashed and placed on top of master. We only want to consider performance changes caused by the new commits, so we use the merge base instead of master HEAD (though these may be the same commit). = Open issues = If commits between HEAD and the baseline commit [https://ghc.haskell.org/trac/ghc/wiki/Performance/Tests#ExpectedPerformance… allow changes] in performance numbers, what should the behaviour be? What happens if this is merged? The commits will be squashed: this could affect the commit message and hence the allowed changes which is parsed from the commit messages. = Use cases = TODO This section is a WIP We generally will assume that the master branch corresponds to ghc's master branch (though may be slightly out of date). ||= Case =||= Details =||= Baseline =|| || 0 commits ahead of master || May be on master or branched off master with no new commits || previous commit || || CI pre-merge || || CI post-merge -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15936> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #10170: Find versioned versions of LLVM tools
by GHC 25 Feb '19

25 Feb '19

#10170: Find versioned versions of LLVM tools -------------------------------------+------------------------------------- Reporter: erikd | Owner: erikd Type: bug | Status: new Priority: normal | Milestone: 7.12.1 Component: Compiler | Version: 7.11 (LLVM) | Operating System: Unknown/Multiple Keywords: | Type of failure: None/Unknown Architecture: | Blocked By: Unknown/Multiple | Related Tickets: Test Case: | Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Since it has become more widely know that the LLVM developers often make breaking changes to the IR language between releases, some Linu distributions (eg Debain and hence Ubuntu) have started doing multi- version LLVM installs. For instance on Debian, the llvm-3.6 programs are installed in `/usr/lib/llvm-3.6/bin` as `llc` and `opt`. I propose that the `configure.ac` and `aclocal.m4` configuration goop be modified to look for `llc` and `opt` in these versioned `/usr/lib/llvm-X.Y` locations. I'm also willing to do the hard yards on implementing this if people think its a good idea. This can be seen as a step along the way to more stringent LLVM versioning requirements. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10170> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 19

[GHC] #16329: Simplifier ticks exhausted when fusioning list literals
by GHC 25 Feb '19

25 Feb '19

#16329: Simplifier ticks exhausted when fusioning list literals -------------------------------------+------------------------------------- Reporter: autotaker | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.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: -------------------------------------+------------------------------------- GHC 8.6.3 cannot compile the following code with `-O`. {{{#!hs module Main10(func) where import Control.Monad import Data.IORef func :: Int -> IO Int func n = do ref <- newIORef False let xs = map (n+) [1,2,3,4,5,6,7,8,9,10] step acc x = do when (x `mod` 2 == 0) $ modifyIORef' ref not pure (acc + 1) foldM step 0 xs }}} {{{ $ stack ghc -- --version The Glorious Glasgow Haskell Compilation System, version 8.6.3 $ stack ghc -- -O Main10.hs [1 of 1] Compiling Main10 ( Main10.hs, Main10.o ) Simplifier ticks exhausted When trying RuleFired +# To increase the limit, use -fsimpl-tick-factor=N (default 100). If you need to increase the limit substantially, please file a bug report and indicate the factor you needed. If GHC was unable to complete compilation even with a very large factor (a thousand or more), please consult the "Known bugs or infelicities" section in the Users Guide before filing a report. There are a few situations unlikely to occur in practical programs for which simplifier non-termination has been judged acceptable. To see detailed counts use -ddump-simpl-stats Total ticks: 14321 }}} GHC 8.4.4 and 8.2.2 also fail to compile this but GHC 8.0.2 can. I tried `-fsimpl-tick-factor=10000`, then GHC could compile the program but quite slow (it took some minutes). I measured the total ticks in the dumps from `-ddump-simpl-stats`, while changing the length of the constant literal (`[1,2,...,10]`) in the program between 3 to 10. Here is the result. Simplifier ticks seems to be exponential in the length of the constant list. {{{ # length, Total ticks 3, 706 4, 1286 5, 2982 6, 8026 7, 23114 8, 68334 9, 203950 10,610754 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16329> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #16087: TH tests fail in ext-interp way when ghc-stage2 is built using LLVM
by GHC 25 Feb '19

25 Feb '19

#16087: TH tests fail in ext-interp way when ghc-stage2 is built using LLVM -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.8.1 Component: Compiler | Version: 8.6.3 (LLVM) | 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 is a continuation of #15274. Currently the testsuite fails with around 40 test failures, all in `th/` in the `ext-interp` way when building GHC with `BUILD_FLAVOUR=perf-llvm`: {{{ Unexpected results from: TEST="ClosedFam1TH T10620 T10828 T11721_TH T11797 T12478_1 T12646 T13642 T14060 T15502 T15738 T15792 T15845 T1835 T3920 T4135 T4188 T5037 T5362 T7477 T8761 T8884 T8953 T9262 T9692 T9738 TH_RichKinds TH_RichKinds2 TH_Roles3 TH_TyInstWhere2 TH_implicitParams TH_reifyDecl1 TH_reifyExplicitForAllFams TH_reifyInstances TH_reifyMkName TH_repE2 TH_repGuard TH_repPrim TH_repPrim2 TH_repUnboxedTuples" SUMMARY for test run started at Sun Dec 23 06:01:39 2018 UTC 0:10:09 spent to go through 6745 total tests, which gave rise to 26266 test cases, of which 19055 were skipped 42 had missing libraries 7040 expected passes 89 expected failures 0 caused framework failures 0 caused framework warnings 0 unexpected passes 40 unexpected failures 0 unexpected stat failures Unexpected failures: th/TH_repE2.run TH_repE2 [exit code non-0] (ext- interp) th/TH_repPrim.run TH_repPrim [exit code non-0] (ext- interp) th/TH_repPrim2.run TH_repPrim2 [exit code non-0] (ext- interp) th/TH_repUnboxedTuples.run TH_repUnboxedTuples [exit code non-0] (ext-interp) th/TH_repGuard.run TH_repGuard [exit code non-0] (ext- interp) th/TH_reifyDecl1.run TH_reifyDecl1 [exit code non-0] (ext-interp) th/TH_reifyMkName.run TH_reifyMkName [exit code non-0] (ext-interp) th/TH_reifyInstances.run TH_reifyInstances [exit code non-0] (ext-interp) th/TH_reifyExplicitForAllFams.run TH_reifyExplicitForAllFams [exit code non-0] (ext-interp) th/T3920.run T3920 [exit code non-0] (ext-interp) th/T4188.run T4188 [exit code non-0] (ext-interp) th/T1835.run T1835 [exit code non-0] (ext-interp) th/T5037.run T5037 [exit code non-0] (ext-interp) th/T5362.run T5362 [exit code non-0] (ext-interp) th/TH_RichKinds.run TH_RichKinds [exit code non-0] (ext- interp) th/TH_RichKinds2.run TH_RichKinds2 [exit code non-0] (ext-interp) th/T4135.run T4135 [exit code non-0] (ext-interp) th/TH_TyInstWhere2.run TH_TyInstWhere2 [exit code non-0] (ext-interp) th/ClosedFam1TH.run ClosedFam1TH [exit code non-0] (ext- interp) th/TH_Roles3.run TH_Roles3 [exit code non-0] (ext- interp) th/T7477.run T7477 [exit code non-0] (ext-interp) th/T8884.run T8884 [exit code non-0] (ext-interp) th/T9262.run T9262 [exit code non-0] (ext-interp) th/T9692.run T9692 [exit code non-0] (ext-interp) th/T8953.run T8953 [exit code non-0] (ext-interp) th/T9738.run T9738 [exit code non-0] (ext-interp) th/T10620.run T10620 [exit code non-0] (ext- interp) th/T10828.run T10828 [exit code non-0] (ext- interp) th/T11721_TH.run T11721_TH [exit code non-0] (ext- interp) th/T11797.run T11797 [exit code non-0] (ext- interp) th/T8761.run T8761 [exit code non-0] (ext-interp) th/T12478_1.run T12478_1 [exit code non-0] (ext- interp) th/T12646.run T12646 [exit code non-0] (ext- interp) th/T13642.run T13642 [exit code non-0] (ext- interp) th/T14060.run T14060 [exit code non-0] (ext- interp) th/T15502.run T15502 [exit code non-0] (ext- interp) th/TH_implicitParams.run TH_implicitParams [exit code non-0] (ext-interp) th/T15738.run T15738 [exit code non-0] (ext- interp) th/T15792.run T15792 [exit code non-0] (ext- interp) th/T15845.run T15845 [exit code non-0] (ext- interp) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16087> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6