- ghc-devs - Haskell.org

Can't "make" ghc on master
by Alfredo Di Napoli 05 Aug '13

05 Aug '13

Hello guys, I'm trying a fresh compile from master. These are the steps I've taken: $ git clone http://darcs.haskell.org/ghc.git/ $ cd ghc $ ./sync-all --testsuite get followed by: cp mk/build.mk.sample mk/build.mk <uncommenting #BuildFlavour = quick> and finally: $ perl boot $ ./configure $ make But this is what I've got in the middle of make (just posting the relevant section): https://gist.github.com/adinapoli/6154219 As you can see I'm sandboxed inside hsenv, but I can't think of any reason this being the cause of the failure. Any ideas? Sorry for the naive question, A.

2 2

libffi
by Simon Peyton-Jones 05 Aug '13

05 Aug '13

I'm trying to build HEAD. I get a problem with libffi. Not surprising because in ghc-tarballs I see git log -3 commit f190b3ce329422e13cbe1b5dad030058ca4bdda7 Author: Ian Lynagh <ian(a)well-typed.com> Date: Tue Jul 30 15:56:23 2013 +0100 Remove libffi tarball It's now in its own repo But ./sync-all get doesn't get a libffi repo. Nor is it listed in ./packages. Does anyone have any idea where this new libffi repo is, and why it isn't listed? Thanks Simon

6 11

gdb values optimized out
by William Kenyon 04 Aug '13

04 Aug '13

Dear GHC devs, I am having problems using gdb to debug ghci. > ./inplace/bin/ghc-stage2 --interactive Segmentation fault (core dumped) > gdb ./inplace/lib/bin/ghc-stage2 core.1234 Which works fine, but many variables are <optimized out>. GhcDebugged=YES is set in my build.mk. > ./inplace/bin/ghc-stage2 +RTS --info ... Rts Way = rts_thr_debug ... > ./inplace/bin/ghc-stage1 +RTS --info ... Rts Way = rts_debug ... The debug way should make all C and C-- files be compiled with -O0. Which should mean that nothing appears <optimized out> in gdb. What am I missing? Thanks, Will

1 0

sync-all get failing
by Simon Peyton-Jones 03 Aug '13

03 Aug '13

./sync-all get is failing (see below). Any ideas? Simon bash-3.1$ ./sync-all get warning: ghc-tarballs already present; omitting == ghc-tarballs: running git config --local core.ignorecase true error: unknown option `local' usage: git config [options] Config file location --global use global config file --system use system config file -f, --file <FILE> use given config file Action --get get value: name [value-regex] --get-all get all values: key [value-regex] --get-regexp get values for regexp: name-regex [value-regex] --replace-all replace all matching variables: name value [value_regex] --add adds a new variable: name value --unset removes a variable: name [value-regex] --unset-all removes all matches: name [value-regex] --rename-section rename section: old-name new-name --remove-section remove a section: name -l, --list list all -e, --edit opens an editor --get-color <slot> find the color configured: [default] --get-colorbool <slot> find the color setting: [stdout-is-tty] Type --bool value is "true" or "false" --int value is decimal number --bool-or-int value is --bool or --int --path value is a path (file or directory name) Other -z, --null terminate values with NUL byte git failed: 33024 at ./sync-all line 116. == 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 bash-3.1$

2 2

Need to pull Cabal revs from upstream repos over to GHC ones?
by Ryan Newton 02 Aug '13

02 Aug '13

Hi Richard, I think your commit "Update to Cabal to allow RoleAnnotations" needs one more fix that goes along with it. It looks like revision 5fa5c41cd9d2c9b4b543312af6919fe3d8588654 (at depth 4297) is currently pointed to by GHC's Cabal submodule. But those newer commits need to be pushed over to the repo here: http://darcs.haskell.org/libraries/Cabal.git/ Otherwise fresh GHC checkouts have problems right now. -Ryan

2 1

Unit-testing of GHC code
by Jan Stolarek 02 Aug '13

02 Aug '13

I spent whole day looking for a bug that lurks somewhere in my code, but I know I could find it in 2-3 hours if I only could write unit tests for my code. So the question is: how can I write HUnit and QuickCheck (and maybe SmallCheck) tests for GHC and possibly make them a part of testsuite? Janek

3 5

Newtype wrappers
by Simon Peyton-Jones 02 Aug '13

02 Aug '13

Joachim I was talking to Stepanie about newtype wrappers, and realised that a) there are two very different ways to use type classes to implement the feature, one good and one bad b) the one I thought we were using is the Bad One c) the one on the wiki page is sketched in far too little detail but is the Good One http://ghc.haskell.org/trac/ghc/wiki/NewtypeWrappers Also, there's an interaction with "roles" which Richard is on the point of committing. Below are some detailed notes. Before too long, could you refresh the wiki page to: * demote rejected ideas * explain the accepted plan in more detail * discuss implementation aspects Thanks Simon Bad version ~~~~~~~~~~~ class NT a b rep :: NT a b => a -> b wrap :: NT a b => b -> a Then for each newtype newtype Age = Int we generate axiom axAge :: Age ~ Int instance NT Age Int and for data types data (a,b) = (a,b) we generate instance (NT a a', NT b b') => NT (a,b) (a',b') Internally (NT a b) is implemented as a simple boxing of a representational equality: data NT a b = MkNT (a ~#R b) There are many problems here - It's tiresome for the programmer to remember whether to use rep or wrap - Many levels of newtype would require repeated application of rep (or wrap). But if I say (rep (rep x)) I immediately get ambiguity, unless I also supply a type sig for each intermediate level. Good version (this may be what you are doing already) ~~~~~~~~~~~~ class NT a b ntCast :: NT a b => a -> b Notice only one ntCast, which will work both ways. Then for each newtype newtype Age = Int we generate axiom axAge :: Age ~ Int instance NT Int b => NT Age b instance NT a Int => NT b Age Notice *two* instances For data types, same as before data (a,b) = (a,b) we generate instance (NT a a', NT b b') => NT (a,b) (a',b') And we have instance NT a a. Now try this f :: (Age, Bool, Int) -> (Int, Bool, Age) f x = ntCast x >From the ntCast we get the wanted constraint NT (Age,Bool,Int) (Int,Bool,Age) Then we simplify as follows NT (Age,Bool,Int) (Int,Bool,Age) ---> by instance decl for (,,) NT Age Int, NT Bool Bool, NT Int Age ---> by instance NT a a, solves NT Bool Bool NT Age Int, NT Int Age ---> by instance NT Int a => NT Age a NT Int Int, NT Int Age ---> by instance NT a a, solves NT Int Int NT Int Age ...and so on... In effect, we normalise both arguments of the NT independently until they match (are equal, or have an outermost list). This will even do a good job of newtype Moo = MkMoo Age f :: Moo -> Age f x = ntCast x Try it.. it'll normalise the (NT Moo Age) to (NT Int Int), so the coercion we ultimately build wil take x down to Int, then back up to Age. But that's fine... the coercion optimiser will remove the intermediate steps. This has lots of advantages: - No need to remember directions; ntCast does the job in either direction or both - No need for multiple levels of unwrapping... and hence no ambiguity for the intermediate steps. A note about roles ~~~~~~~~~~~~~~~~~~ We are very keen that if we declare data Map key val = [(key,val)] where the keys are kept ordered, then we do NOT want to allow a cast from (Map Int val) to (Map Age val) We were thinking about exercising this control by saying, in a standalone deriving clause deriving NT v1 v2 => NT (Map k v1) (Map k v2) But another, and more robust, way to express the fact that we should not allow you to cast (Map Int val) to (Map Age val) is to give Map the rules p Map key@Nominal val@Representational in Richard's new system (about to be committed). This gives Map's first argument a more restrictive role than role inference would give it. And for good reason! If we had class C k where foo :: Map k Int -> Bool then we would NOT want to allow newtype Age = MkAge Int deriving( C ) And the thing that now prevents us doing that 'deriving( C )' is precisely the more restrictive role on Map. So, our proposal is: for every data T a = ... deriving( NT ) we get the lifting instance instance NT a b => NT (T a) (T b) whose shape is controlled by T's argument roles. We probably want to be able to say -XAutoDeriveNT, like -XAutoDeriveTypeable.

1 0

ghc primop correctness and compile time constants, maybe a type operator for enforced Constantness?
by Carter Schonwald 01 Aug '13

01 Aug '13

Hey all, a number of primops GHC has gained in the past year, prefetch and family, as well as further primops that people (such as myself) hope to add require certain arguments be known constant values at compile time for code gen to work correctly. I detail the problem a little bit further on this ghc trac ticket : http://ghc.haskell.org/trac/ghc/ticket/8107 but the punchline is, a number of valuable SIMD, memory, and concurrent memory model primops that are worth adding to GHC and making first class operations, really require certain arguments to be compile time constant to work correctly. Accordingly, from the perspective of making those operations *truly* first class, augmenting the haskell type system to have a way of expressing "this argument must be a known value at compile time" that doesn't require template haskell shenanigans might be really valuable. thoughts all? note that for some of these arguments that need to be compile time constants, llvm et al will generate different machine code depending on the argument! (llvm doesn't even have the ability to express this invariant in its current API / data model, it just checks it when it tries to compile the code) cheers -Carter

1 0

Mentoring for implementing #8004
by David Luposchainsky 01 Aug '13

01 Aug '13

Hey Devs, I haven't worked on GHC before, so I'm having trouble finding an entry point to implementing the AMP warnings (#8004). I only have a rough working knowledge of GHC's inner workings, but it would be a shame if the ticket wasn't resolved until the 7.8 deadline (which is somewhere in September if I remember it right). My last approach was grepping through the source for "DEPRECATED" and seeing whether there would be an appropriate place for these warnings there, but that wasn't very fruitful. Long story short: can anyone point me in the right direction? I assume the right place to look is somewhere in the typechecker where there's a type class environment, and that's as far as I've come. (It's hard to understand thousands of lines when you're not even sure you're in the right place ...) Greetings, David

3 2

RE: [commit: ghc] master: Add NegativeLiterals extension (ef73963)
by Simon Peyton-Jones 31 Jul '13

31 Jul '13

Ian, Thanks... but if you have added a new language extension, shouldn't you document it in the user manual? What exactly is the different behaviour seen by the user? Simon | -----Original Message----- | From: ghc-commits [mailto:ghc-commits-bounces@haskell.org] On Behalf Of Ian | Lynagh | Sent: 31 July 2013 20:12 | To: ghc-commits(a)haskell.org | Subject: [commit: ghc] master: Add NegativeLiterals extension (ef73963) | | Repository : http://darcs.haskell.org/ghc.git/ | | On branch : master | | http://hackage.haskell.org/trac/ghc/changeset/ef739635a8c2646112d2a1fa4c871 | 5704aff1f1f | | >--------------------------------------------------------------- | | commit ef739635a8c2646112d2a1fa4c8715704aff1f1f | Author: Ian Lynagh <ian(a)well-typed.com> | Date: Wed Jul 31 18:43:11 2013 +0100 | | Add NegativeLiterals extension | | I'd been meaning to do this for some time, but finally got around to it | due to the overflowing literals warning. With that enabled, we were | getting a warning for | -128 :: Int8 | as that is parsed as | negate (fromInteger 128) | which just happens to do the right thing, as | negate (fromInteger 128) = negate (-128) = -128 | | >--------------------------------------------------------------- | | compiler/main/DynFlags.hs | 2 ++ | compiler/parser/Lexer.x | 17 +++++++++++++---- | compiler/utils/Util.lhs | 2 +- | 3 files changed, 16 insertions(+), 5 deletions(-) | | diff --git a/compiler/main/DynFlags.hs b/compiler/main/DynFlags.hs | index eeb48ba..9a56b50 100644 | --- a/compiler/main/DynFlags.hs | +++ b/compiler/main/DynFlags.hs | @@ -558,6 +558,7 @@ data ExtensionFlag | | Opt_LambdaCase | | Opt_MultiWayIf | | Opt_TypeHoles | + | Opt_NegativeLiterals | | Opt_EmptyCase | deriving (Eq, Enum, Show) | | @@ -2726,6 +2727,7 @@ xFlags = [ | ( "IncoherentInstances", Opt_IncoherentInstances, nop ), | ( "PackageImports", Opt_PackageImports, nop ), | ( "TypeHoles", Opt_TypeHoles, nop ), | + ( "NegativeLiterals", Opt_NegativeLiterals, nop ), | ( "EmptyCase", Opt_EmptyCase, nop ) | ] | | diff --git a/compiler/parser/Lexer.x b/compiler/parser/Lexer.x | index 6871210..11d849a 100644 | --- a/compiler/parser/Lexer.x | +++ b/compiler/parser/Lexer.x | @@ -385,12 +385,16 @@ $tab+ { warn Opt_WarnTabs (text "Tab | character") } | -- when trying to be close to Haskell98 | <0> { | -- Normal integral literals (:: Num a => a, from Integer) | - @decimal { tok_num positive 0 0 decimal } | - 0[oO] @octal { tok_num positive 2 2 octal } | - 0[xX] @hexadecimal { tok_num positive 2 2 hexadecimal } | + @decimal { tok_num positive 0 0 | decimal } | + 0[oO] @octal { tok_num positive 2 2 | octal } | + 0[xX] @hexadecimal { tok_num positive 2 | 2 hexadecimal } | + @negative @decimal / { ifExtension negativeLiteralsEnabled } { | tok_num negative 1 1 decimal } | + @negative 0[oO] @octal / { ifExtension negativeLiteralsEnabled } { | tok_num negative 3 3 octal } | + @negative 0[xX] @hexadecimal / { ifExtension negativeLiteralsEnabled } { | tok_num negative 3 3 hexadecimal } | | -- Normal rational literals (:: Fractional a => a, from Rational) | - @floating_point { strtoken tok_float } | + @floating_point { strtoken tok_float } | + @negative @floating_point / { ifExtension negativeLiteralsEnabled } { | strtoken tok_float } | } | | <0> { | @@ -1870,6 +1874,8 @@ explicitNamespacesBit :: Int | explicitNamespacesBit = 29 | lambdaCaseBit :: Int | lambdaCaseBit = 30 | +negativeLiteralsBit :: Int | +negativeLiteralsBit = 31 | | | always :: Int -> Bool | @@ -1925,6 +1931,8 @@ explicitNamespacesEnabled :: Int -> Bool | explicitNamespacesEnabled flags = testBit flags explicitNamespacesBit | lambdaCaseEnabled :: Int -> Bool | lambdaCaseEnabled flags = testBit flags lambdaCaseBit | +negativeLiteralsEnabled :: Int -> Bool | +negativeLiteralsEnabled flags = testBit flags negativeLiteralsBit | | -- PState for parsing options pragmas | -- | @@ -1988,6 +1996,7 @@ mkPState flags buf loc = | .|. typeLiteralsBit `setBitIf` xopt Opt_DataKinds flags | .|. explicitNamespacesBit `setBitIf` xopt Opt_ExplicitNamespaces | flags | .|. lambdaCaseBit `setBitIf` xopt Opt_LambdaCase | flags | + .|. negativeLiteralsBit `setBitIf` xopt Opt_NegativeLiterals | flags | -- | setBitIf :: Int -> Bool -> Int | b `setBitIf` cond | cond = bit b | diff --git a/compiler/utils/Util.lhs b/compiler/utils/Util.lhs | index e2fd0aa..6d42ce7 100644 | --- a/compiler/utils/Util.lhs | +++ b/compiler/utils/Util.lhs | @@ -1095,7 +1095,7 @@ charToC w = | hashString :: String -> Int32 | hashString = foldl' f golden | where f m c = fromIntegral (ord c) * magic + hashInt32 m | - magic = 0xdeadbeef | + magic = fromIntegral (0xdeadbeef :: Word32) | | golden :: Int32 | golden = 1013904242 -- = round ((sqrt 5 - 1) * 2^32) :: Int32 | | | | _______________________________________________ | ghc-commits mailing list | ghc-commits(a)haskell.org | http://www.haskell.org/mailman/listinfo/ghc-commits

2 1