December 2013 - ghc-tickets

[GHC] #8127: iOS patch no 19: Linking
by GHC 05 Sep '15

05 Sep '15

#8127: iOS patch no 19: Linking -------------------------------------+------------------------------------- Reporter: StephenBlackheath | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Other Architecture: arm | Type of failure: GHC doesn't work Difficulty: Moderate (less | at all than a day) | Test Case: Blocked By: | Blocking: 7724 Related Tickets: | -------------------------------------+------------------------------------- Fix linking for cross compiler to iOS. This patch does these things: 1. use libtool to link to a static library in place of an executable (because on iOS the final link must be done in Xcode), 2. for packages, keep only the HS package libraries and throw out other options (because libtool doesn't accept them), 3. fail if you try to link a dynamic library on iOS because it isn't supported (not really needed but there for completeness). Note that there is a minor risk here, because in the normal case, the order of options passed to the linker is slightly different: The options relating to each dependent package are separated into three different kinds, but they're still in the same relative order per package. This should be perfectly OK. The name of "libtool" is hard-coded and can't be set by options. Is this OK? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8127> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 14

[GHC] #8096: Add fudge-factor for performance tests run on non-validate builds
by GHC 27 Aug '15

27 Aug '15

#8096: Add fudge-factor for performance tests run on non-validate builds ------------------------------------+------------------------------------- Reporter: ezyang | Owner: Type: task | 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: | ------------------------------------+------------------------------------- Since I'm not going to get around to this immediately, Trac'ifying for posterity: These tests have been doing better than expected in the nightlies for some while. {{{ Unexpected failures: perf/compiler T3064 [stat too good] (normal) perf/compiler T3294 [stat too good] (normal) perf/compiler T5642 [stat too good] (normal) perf/haddock haddock.Cabal [stat too good] (normal) perf/haddock haddock.base [stat too good] (normal) }}} Unfortunately, fixing them is not a simple matter of shifting the ranges up, since the tests only exceed expectations on a /perf/ build, so on a normal build such as 'quick', these tests all pass normally. I could bump up the upper bounds so that the builder stops bleating about them; perhaps we could do something more complicated where the expected performance depends on what level of optimization GHC was built with (but I don't know how to implement this.) ---- The problem with just widening the bounds to cover 2 different types of build is that it increases the chance that performance changes won't actually be noticed by thge person responsible. Having different bounds for different build configurations is a pain, because (a) the testsuite has to work out which set of bounds to use, and (b) you now have even more wobbly values to keep up-to-date. I think perhaps the best thing would be to add some sort of (per-test?) fudge factor for non-validate builds. That way validate will still find performance regressions, like it does today, but other builds are less likely to give false positives. (Igloo) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8096> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #8330: Remove ExtsCompat46 module once we bootstrap with GHC 7.8
by GHC 24 Aug '15

24 Aug '15

#8330: Remove ExtsCompat46 module once we bootstrap with GHC 7.8 -------------------------------------------+------------------------------- Reporter: jstolarek | Owner: Type: task | Status: new Priority: low | Milestone: 7.10.1 Component: Compiler | Version: 7.7 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Easy (less than 1 hour) | Type of failure: Blocked By: | None/Unknown Related Tickets: | Test Case: | Blocking: -------------------------------------------+------------------------------- Changing type signature of comparison primops from `Bool` to `Int#` in GHC 7.8 (see #6135) caused a problem: type signatures of functions might be different for the bootstrapping compiler (if it is older than 7.8) than they are for the stage1 compiler. In order to solve this problem I introduced a compatibility module [[GhcFile(compiler/utils/ExtsCompat46)]] that provides different definition of primops for older versions of GHC (`__GLASGOW_HASKELL__ <= 706`) and different for newer versions (`__GLASGOW_HASKELL__ > 706`). However, once we set minimal version of GHC required for bootstrapping to be 7.8, we can (and should!) remove that compatibility module and go back to using GHC.Exts. This ticket is a reminder that we should do this after we release GHC 7.10 or 7.12. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8330> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #8484: Compile-time panic
by GHC 20 Aug '15

20 Aug '15

#8484: Compile-time panic ----------------------------------+--------------------------------------- Reporter: Taymon | 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: Compile-time crash Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ----------------------------------+--------------------------------------- I attempted to build a program (using make) and got the following output: {{{ ghc -odir binaries -hidir binaries --make Main.hs -optl-w ghc: panic! (the 'impossible' happened) (GHC version 7.6.3 for x86_64-unknown-linux): While parsing "/home/taymonbeal/.ghc/x86_64-linux-7.6.3/package.conf.d/package.cache": too few bytes. Failed reading at byte position 8 Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug make: *** [build] Error 1 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8484> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #8178: Need TypeRep for Symbol and numeric type literals; and Typeable instances
by GHC 08 Aug '15

08 Aug '15

#8178: Need TypeRep for Symbol and numeric type literals; and Typeable instances ------------------------------------+------------------------------------- Reporter: simonpj | 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: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Nicolas Trangez points out that we don't have a `TypeRep` for types involving literal strings or numerics. E.g. what is `(typeRep (undefined :: Proxy "foo"))`? Here is Nicolas's example: {{{ {-# LANGUAGE DataKinds, KindSignatures, DeriveFunctor, DeriveDataTypeable #-} module Main where import Data.Typeable import GHC.TypeLits data NoSymbol n a b = NoSymbol a b deriving (Typeable) data WithSymbol (n :: Symbol) a b = WithSymbol a b deriving (Typeable) data Sym deriving (Typeable) main :: IO () main = do print $ typeOf (undefined :: NoSymbol Sym Int Int) let d = undefined :: WithSymbol "sym" Int Int {- print $ typeOf d No instance for (Typeable Symbol "sym") arising from a use of ‛typeOf’ -} return () }}} Just as types contain literal strings and natural numbers, so too must `TypeRep`, in some way. Once we have a suitable `TypeRep` we can make built-in instance for `Typeable` that return the appropriate representation. At the moment we have (in `Data.Typeable.Internals`): {{{ data TypeRep = TypeRep {-# UNPACK #-} !Fingerprint TyCon [TypeRep] data TyCon = TyCon { tyConHash :: {-# UNPACK #-} !Fingerprint, tyConPackage :: String, tyConModule :: String, tyConName :: String } }}} with instances for Eq and Ord. Perhaps we need {{{ data TypeRep = TcApp {-# UNPACK #-} !Fingerprint TyCon [TypeRep] | TcSym String | TcNat Integer }}} or something like that? I'm not certain. I think Iavor is going to think about it. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8178> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #8488: Annotations should not distinguish type and value
by GHC 01 Aug '15

01 Aug '15

#8488: Annotations should not distinguish type and value ------------------------------------+------------------------------------- Reporter: simonpj | 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: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- In `HsDecls` we have {{{ data AnnDecl name = HsAnnotation (AnnProvenance name) (Located (HsExpr name)) data AnnProvenance name = ValueAnnProvenance name | TypeAnnProvenance name | ModuleAnnProvenance }}} And there's now a similar 3-way distinction in Template Haskell `Syntax`: {{{ data AnnTarget = ModuleAnnotation | TypeAnnotation Name | ValueAnnotation Name }}} But there's really no need to distinguish between `TypeAnnProvenance` and `ValueAnnProvenance` (and similarly in the TH vesrion) because the namespace on the `Name` makes that distinction. So the current story is redundant, and hence has silly case where you have a `ValueAnnProvenance` on a type constructor. Better to collapse the two. I'm making this a ticket so that people can comment. I hope that Gergely may be able to do it as part of his TH/annotation work. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8488> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #8387: View patterns + pattern bindings: finnicky about scoping
by GHC 31 Jul '15

31 Jul '15

#8387: View patterns + pattern bindings: finnicky about scoping ----------------------------+---------------------------------------------- Reporter: | Owner: tinctorius | Status: new Type: bug | Milestone: Priority: normal | Version: 7.6.3 Component: Compiler | Operating System: Unknown/Multiple Keywords: | Type of failure: GHC rejects valid program Architecture: | Test Case: Unknown/Multiple | Blocking: Difficulty: Unknown | Blocked By: | Related Tickets: | ----------------------------+---------------------------------------------- Assume `{-# LANGUAGE ViewPatterns #-}`. This works: {{{ (id -> ()) = () }}} This also works: {{{ di :: a -> a di = \x -> x where (di -> ()) = () }}} But none of the following work: {{{ (di -> ()) = () -- Not in scope: di di :: a -> a di = \x -> x }}} {{{ di :: a -> a di = \x -> x (di -> ()) = () -- Not in scope: di }}} {{{ (di -> ()) = () -- Not in scope: di where di :: a -> a di = \x -> x }}} This looks like a bug to me. Is it? And is this in any way related to #4061? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8387> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #8253: example "Core syntax" is ancient
by GHC 31 Jul '15

31 Jul '15

#8253: example "Core syntax" is ancient -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Documentation | Version: 7.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Documentation Difficulty: Easy (less than 1 | bug hour) | Test Case: Blocked By: | Blocking: Related Tickets: | -------------------------------------+------------------------------------- [http://www.haskell.org/ghc/docs/7.6.3/html/users_guide/options- debugging.html#idp39365504 User's guide section 4.19.5] has some funky "Core syntax" that (according to git blame) dates back to at least 2000, and probably longer ago than that. It could use an update. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8253> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #8151: ghc-7.4.2 on OpenIndiana (Solaris) createSubprocess fails
by GHC 31 Jul '15

31 Jul '15

#8151: ghc-7.4.2 on OpenIndiana (Solaris) createSubprocess fails ----------------------------+-------------------------------------------- Reporter: troydm | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.4.2 Keywords: | Operating System: Solaris Architecture: x86 | Type of failure: Runtime performance bug Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ----------------------------+-------------------------------------------- when i'm compiling this test.hs with ghc -thread ./test.hs and then execute it i get Starting Subprocess Exit code: ExitFailure 127 This error code indicates that command isn't found (i have ghc in /usr/local/bin) and it's specified in PATH variable, however it acts as if it's not even there however if i remove -threaded flag and recompile code again, it works Starting Subprocess ghc: no input files Usage: For basic information, try the `--help' option. Exit code: ExitFailure 1 -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8151> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #8538: confusing specialization CORE warning, also can't mark type class instances INLINEABLE unless class defn is marked INLINEABLE
by GHC 28 Jul '15

28 Jul '15

#8538: confusing specialization CORE warning, also can't mark type class instances INLINEABLE unless class defn is marked INLINEABLE ------------------------------------+------------------------------------- Reporter: carter | 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: None/Unknown Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- As part of writing an array library for numerical purposes, I have a static sized strict list type for representing the Indexing tuple. One implementation strategy makes it a tad generic, and then I'm writing a bunch of manipulation utilities using Functor, Applicative and Foldable. I wrote it with all the functions marked INLINABLE so i could ensure that I could have the index arith calculations SPECIALIZE in the common cases. Unfortunately, it seems like type class instances can only marked INLINABLE if the type class definition is itself marked INLINE or INLINABLE. Considering i'm writing a numerical array library, I want to make sure that address arithmetic. This could could be argued to be by design (and thus a wont fix). That aside, I also get the following Warning for my "map2" function, which i found surprising. (and it perhaps is worth some investigation / cleanup ) {{{ src/Numerical/Types/Shape.hs:165:1: Warning: RULE left-hand side too complicated to desugar let { $dFunctor :: Functor (Shape ('S N0)) [LclId] $dFunctor = Numerical.Types.Shape.$fFunctorShape @ 'Z $dFunctor } in map2 @ a @ b @ c @ N2 (Numerical.Types.Shape.$fApplicativeShape @ ('S N0) (Numerical.Types.Shape.$fFunctorShape @ ('S N0) $dFunctor) (Numerical.Types.Shape.$fApplicativeShape @ 'Z $dFunctor Numerical.Types.Shape.$fApplicativeShape0)) }}} {{{ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE CPP #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE NoImplicitPrelude #-} module Numerical.Types.Shape where import GHC.Magic import Data.Monoid import Data.Functor import Data.Foldable import Control.Applicative -- import Numerical.Types.Nat import Prelude (seq, ($!),($),Show(..),Eq(),Int) data Nat = S !Nat | Z type N0 = Z type N1= S N0 type N2 = S N1 type N3 = S N2 type N4 = S N3 {- not doing the HLIST style shape because I don't want to have any pattern matchings going on. Also would play hell with locality quality in the address translation hackery, because there'd be an extra load to get those ints! -} infixr 3 :* {- the concern basically boils down to "will it specialize / inline well" -} data Shape (rank :: Nat) a where Nil :: Shape Z a (:*) :: !(a) -> !(Shape r a ) -> Shape (S r) a --deriving instance (Show (Shape rank a)) -- deriving instance Eq (Shape rank a) -- #if defined( __GLASGOW_HASKELL__ ) && ( __GLASGOW_HASKELL__ >= 707) --deriving instance Typeable (Shape rank a) -- #endif instance Functor (Shape Z) where fmap = \ f Nil -> Nil {-# INLINABLE fmap #-} {-# SPECIALIZE fmap :: (a ->b )-> (Shape Z a)-> (Shape Z b) #-} instance (Functor (Shape r)) => Functor (Shape (S r)) where fmap = \ f (a :* rest) -> f a :* fmap f rest {-# INLINABLE fmap #-} {-# SPECIALIZE fmap :: (a ->b )-> (Shape N1 a)-> (Shape N1 b) #-} {-# SPECIALIZE fmap :: (a ->b )-> (Shape N2 a)-> (Shape N2 b) #-} instance Applicative (Shape Z) where pure = \ _ -> Nil {-# INLINE pure #-} (<*>) = \ _ _ -> Nil {-# INLINE (<*>) #-} {-# SPECIALIZE pure :: a -> Shape Z a #-} {-# SPECIALIZE (<*>) :: Shape Z (a -> b) -> Shape Z a -> Shape Z b #-} instance Applicative (Shape r)=> Applicative (Shape (S r)) where pure = \ a -> a :* (pure a) {-# INLINE pure #-} (<*>) = \ (f:* fs) (a :* as) -> f a :* (inline (<*>)) fs as {-# INLINE (<*>) #-} {-# SPECIALIZE pure :: a -> (Shape Z a) #-} {-# SPECIALIZE pure :: a -> (Shape N1 a) #-} {-# SPECIALIZE pure :: a -> (Shape N2 a )#-} instance Foldable (Shape Z) where foldMap = \ _ _ -> mempty {-# INLINE foldMap #-} foldl = \ _ init _ -> init {-# INLINE foldl #-} foldr = \ _ init _ -> init {-# INLINE foldr #-} foldr' = \_ !init _ -> init {-# INLINE foldr' #-} foldl' = \_ !init _ -> init {-# INLINE foldl' #-} -- {-# SPECIALIZE foldMap :: Monoid m => (a -> m)-> Shape Z a -> m #-} -- {-# SPECIALIZE foldl :: (a ->b -> a) -> a -> Shape Z b -> a #-} -- {-# SPECIALIZE foldr :: (b ->a -> a) -> a -> Shape Z b -> a #-} -- {-# SPECIALIZE foldl' :: (a ->b -> a) -> a -> Shape Z b -> a #-} -- {-# SPECIALIZE foldr' :: (b ->a -> a) -> a -> Shape Z b -> a #-} instance (Foldable (Shape r)) => Foldable (Shape (S r)) where foldMap = \f (a:* as) -> f a <> foldMap f as {-# INLINE foldMap #-} foldl' = \f !init (a :* as) -> let next = f init a in next `seq` (inline foldl) f next as {-# INLINE foldl' #-} foldr' = \f !init (a :* as ) -> f a $! (inline foldr) f init as {-# INLINABLE foldr' #-} foldl = \f init (a :* as) -> let next = f init a in (inline foldl) f next as {-# INLINE foldl #-} foldr = \f init (a :* as ) -> f a $ (inline foldr) f init as {-# INLINE foldr #-} {-# SPECIALIZE foldMap::Monoid m => (a -> m)-> Shape N1 a -> m #-} {-# SPECIALIZE foldl :: (a ->b -> a) ->a -> Shape N1 b -> a #-} {-# SPECIALIZE foldr :: (b ->a -> a) -> a -> Shape N1 b -> a #-} {-# SPECIALIZE foldl' :: (a ->b -> a) -> a -> Shape N1 b -> a #-} {-# SPECIALIZE foldr' :: (b ->a -> a) -> a -> Shape N1 b -> a #-} {-# SPECIALIZE foldMap :: Monoid m => (a -> m)-> Shape N2 a -> m #-} {-# SPECIALIZE foldl :: (a ->b-> a) ->a -> Shape N2 b -> a #-} {-# SPECIALIZE foldr :: (b ->a -> a) -> a -> Shape N2 b -> a #-} {-# SPECIALIZE foldl' :: (a ->b -> a) -> a -> Shape N2 b -> a #-} {-# SPECIALIZE foldr' :: (b ->a -> a) -> a -> Shape N2 b -> a #-} -- map2 :: (Applicative (Shape r))=> (a->b ->c) -> (Shape r a) -> (Shape r b) -> (Shape r c ) map2 = \f l r -> pure f <*> l <*> r {-# INLINABLE map2 #-} {-# SPECIALIZE map2 :: (a -> b -> c ) -> (Shape Z a) -> (Shape Z b) -> (Shape Z c )#-} {-# SPECIALIZE map2 :: (a -> b -> c ) -> (Shape N1 a) -> (Shape N1 b) -> (Shape N1 c )#-} {-# SPECIALIZE map2 :: (a -> b -> c ) -> (Shape N2 a) -> (Shape N2 b) -> (Shape N2 c )#-} }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8538> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2