1. 13 Feb, 2014 1 commit
  2. 11 Feb, 2014 3 commits
  3. 26 Jan, 2014 1 commit
  4. 08 Oct, 2013 1 commit
  5. 01 Oct, 2013 1 commit
  6. 29 Aug, 2013 1 commit
  7. 02 Aug, 2013 1 commit
  8. 30 May, 2013 1 commit
    • Simon Peyton Jones's avatar
      Make 'SPECIALISE instance' work again · 1ed04090
      Simon Peyton Jones authored
      This is a long-standing regression (Trac #7797), which meant that in
      particular the Eq [Char] instance does not get specialised.
      (The *methods* do, but the dictionary itself doesn't.)  So when you
      call a function
           f :: Eq a => blah
      on a string type (ie a=[Char]), 7.6 passes a dictionary of un-specialised
      methods.
      
      This only matters when calling an overloaded function from a
      specialised context, but that does matter in some programs.  I
      remember (though I cannot find the details) that Nick Frisby discovered
      this to be the source of some pretty solid performanc regresisons.
      
      Anyway it works now. The key change is that a DFunUnfolding now takes
      a form that is both simpler than before (the DFunArg type is eliminated)
      and more general:
      
      data Unfolding
        = ...
        | DFunUnfolding {     -- The Unfolding of a DFunId
          			-- See Note [DFun unfoldings]
            		  	--     df = /\a1..am. \d1..dn. MkD t1 .. tk
                              --                                 (op1 a1..am d1..dn)
           		      	--     	    	      	       	   (op2 a1..am d1..dn)
              df_bndrs :: [Var],      -- The bound variables [a1..m],[d1..dn]
              df_con   :: DataCon,    -- The dictionary data constructor (never a newtype datacon)
              df_args  :: [CoreExpr]  -- Args of the data con: types, superclasses and methods,
          }                           -- in positional order
      
      That in turn allowed me to re-enable the DFunUnfolding specialisation in
      DsBinds.  Lots of details here in TcInstDcls:
      	  Note [SPECIALISE instance pragmas]
      
      I also did some refactoring, in particular to pass the InScopeSet to
      exprIsConApp_maybe (which in turn means it has to go to a RuleFun).
      
      NB: Interface file format has changed!
      1ed04090
  9. 10 May, 2013 1 commit
  10. 04 Feb, 2013 1 commit
    • chak@cse.unsw.edu.au.'s avatar
      Fix tidying of vectorised code · 82a30378
      chak@cse.unsw.edu.au. authored
      * We need to keep the vectorised version of a variable alive while the original is alive.
      * This implies that the vectorised version needs to get into the iface if the original appears in an unfolding.
      82a30378
  11. 30 Jan, 2013 1 commit
  12. 02 Jan, 2013 1 commit
    • Simon Peyton Jones's avatar
      Define ListSetOps.getNth, and use it · b0c0cae7
      Simon Peyton Jones authored
      I was tracking down an error looking like
        Prelude.(!!): index too large
      which is very unhelpful.  This patch replaces at least some uses
      of (!!) in GHC with getNth, which has a more helpful error
      message (with DEBUG anyway)
      b0c0cae7
  13. 01 Jan, 2013 1 commit
    • Simon Peyton Jones's avatar
      Refactor the invariants for ClsInsts · 5efe9b11
      Simon Peyton Jones authored
      We now have the invariant for a ClsInst that the is_tvs field
      is always completely fresh type variables. See
      Note [Template tyvars are fresh] in InstEnv.
      
      (Previously we frehened them when extending the instance environment,
      but that seems messier because it was an invariant only when the
      ClsInst was in an InstEnv.  Moreover, there was an invariant that
      thet tyvars of the DFunid in the ClsInst had to match, and I have
      removed that invariant altogether; there is no need for it.)
      
      Other changes I made at the same time:
      
       * Make is_tvs into a *list*, in the right order for the dfun type
         arguments.  This removes the wierd need for the dfun to have the
         same tyvars as the ClsInst template, an invariant I have always
         hated. The cost is that we need to make it a VarSet when matching.
         We could cache an is_tv_set instead.
      
       * Add a cached is_cls field to the ClsInst, to save fishing
         the Class out of the DFun.  (Renamed is_cls to is_cls_nm.)
      
       * Make tcSplitDFunTy return the dfun args, not just the *number*
         of dfun args
      
       * Make InstEnv.instanceHead return just the *head* of the
         instance declaration.  Add instanceSig to return the whole
         thing.
      5efe9b11
  14. 05 Dec, 2012 1 commit
  15. 18 Oct, 2012 1 commit
    • ian@well-typed.com's avatar
      Refactor the way dump flags are handled · d4a19643
      ian@well-typed.com authored
      We were being inconsistent about how we tested whether dump flags
      were enabled; in particular, sometimes we also checked the verbosity,
      and sometimes we didn't.
      
      This lead to oddities such as "ghc -v4" printing an "Asm code" section
      which didn't contain any code, and "-v4" enabled some parts of
      "-ddump-deriv" but not others.
      
      Now all the tests use dopt, which also takes the verbosity into account
      as appropriate.
      d4a19643
  16. 16 Oct, 2012 1 commit
  17. 27 Jun, 2012 1 commit
    • Simon Peyton Jones's avatar
      Add silent superclass parameters (again) · aa1e0976
      Simon Peyton Jones authored and chak@cse.unsw.edu.au.'s avatar chak@cse.unsw.edu.au. committed
      Silent superclass parameters solve the problem that
      the superclasses of a dicionary construction can easily
      turn out to be (wrongly) bottom.  The problem and solution
      are described in
         Note [Silent superclass arguments] in TcInstDcls
      
      I first implemented this fix (with Dimitrios) in Dec 2010, but removed
      it again in Jun 2011 becuase we thought it wasn't necessary any
      more. (The reason we thought it wasn't necessary is that we'd stopped
      generating derived superclass constraints for *wanteds*.  But we were
      wrong; that didn't solve the superclass-loop problem.)
      
      So we have to re-implement it.  It's not hard.  Main features:
      
        * The IdDetails for a DFunId says how many silent arguments it has
      
        * A DFunUnfolding describes which dictionary args are
          just parameters (DFunLamArg) and which are a function to apply
          to the parameters (DFunPolyArg).  This adds the DFunArg type
          to CoreSyn
      
        * Consequential changes to IfaceSyn.  (Binary hi file format changes
          slightly.)
      
        * TcInstDcls changes to generate the right dfuns
      
        * CoreSubst.exprIsConApp_maybe handles the new DFunUnfolding
      
      The thing taht is *not* done yet is to alter the vectoriser to
      pass the relevant extra argument when building a PA dictionary.
      aa1e0976
  18. 29 Nov, 2011 1 commit
  19. 27 Nov, 2011 1 commit
    • Simon Peyton Jones's avatar
      Be a bit less gung-ho in exprIsConApp_maybe · f7cf3dcd
      Simon Peyton Jones authored
      In particular, don't second-guess callSiteInline by
      effectively inlining function call.  This eliminates
      the "Interesting!" debug messages we've been getting.
      I concluded they weren't interesting enough to account
      for the extra complexity!
      f7cf3dcd
  20. 25 Nov, 2011 1 commit
  21. 16 Nov, 2011 1 commit
  22. 04 Nov, 2011 1 commit
  23. 02 Nov, 2011 1 commit
    • Simon Marlow's avatar
      Overhaul of infrastructure for profiling, coverage (HPC) and breakpoints · 7bb0447d
      Simon Marlow authored
      User visible changes
      ====================
      
      Profilng
      --------
      
      Flags renamed (the old ones are still accepted for now):
      
        OLD            NEW
        ---------      ------------
        -auto-all      -fprof-auto
        -auto          -fprof-exported
        -caf-all       -fprof-cafs
      
      New flags:
      
        -fprof-auto              Annotates all bindings (not just top-level
                                 ones) with SCCs
      
        -fprof-top               Annotates just top-level bindings with SCCs
      
        -fprof-exported          Annotates just exported bindings with SCCs
      
        -fprof-no-count-entries  Do not maintain entry counts when profiling
                                 (can make profiled code go faster; useful with
                                 heap profiling where entry counts are not used)
      
      Cost-centre stacks have a new semantics, which should in most cases
      result in more useful and intuitive profiles.  If you find this not to
      be the case, please let me know.  This is the area where I have been
      experimenting most, and the current solution is probably not the
      final version, however it does address all the outstanding bugs and
      seems to be better than GHC 7.2.
      
      Stack traces
      ------------
      
      +RTS -xc now gives more information.  If the exception originates from
      a CAF (as is common, because GHC tends to lift exceptions out to the
      top-level), then the RTS walks up the stack and reports the stack in
      the enclosing update frame(s).
      
      Result: +RTS -xc is much more useful now - but you still have to
      compile for profiling to get it.  I've played around a little with
      adding 'head []' to GHC itself, and +RTS -xc does pinpoint the problem
      quite accurately.
      
      I plan to add more facilities for stack tracing (e.g. in GHCi) in the
      future.
      
      Coverage (HPC)
      --------------
      
       * derived instances are now coloured yellow if they weren't used
       * likewise record field names
       * entry counts are more accurate (hpc --fun-entry-count)
       * tab width is now correct (markup was previously off in source with
         tabs)
      
      Internal changes
      ================
      
      In Core, the Note constructor has been replaced by
      
              Tick (Tickish b) (Expr b)
      
      which is used to represent all the kinds of source annotation we
      support: profiling SCCs, HPC ticks, and GHCi breakpoints.
      
      Depending on the properties of the Tickish, different transformations
      apply to Tick.  See CoreUtils.mkTick for details.
      
      Tickets
      =======
      
      This commit closes the following tickets, test cases to follow:
      
        - Close #2552: not a bug, but the behaviour is now more intuitive
          (test is T2552)
      
        - Close #680 (test is T680)
      
        - Close #1531 (test is result001)
      
        - Close #949 (test is T949)
      
        - Close #2466: test case has bitrotted (doesn't compile against current
          version of vector-space package)
      7bb0447d
  24. 31 Oct, 2011 1 commit
  25. 24 Oct, 2011 1 commit
  26. 23 Oct, 2011 1 commit
  27. 10 Oct, 2011 1 commit
  28. 23 Sep, 2011 1 commit
    • Simon Peyton Jones's avatar
      Make a new type synonym CoreProgram = [CoreBind] · 488e21c8
      Simon Peyton Jones authored
      and comment its invariants in Note [CoreProgram] in CoreSyn
      
      I'm not totally convinced that CoreProgram is the right name
      (perhaps CoreTopBinds might better), but it is useful to have
      a clue that you are looking at the top-level bindings.
      
      This is only a matter of a type synonym change; no deep
      refactoring here.
      488e21c8
  29. 09 Sep, 2011 2 commits
  30. 06 Sep, 2011 2 commits
    • batterseapower's avatar
      Implement -XConstraintKind · 9729fe7c
      batterseapower authored
      Basically as documented in http://hackage.haskell.org/trac/ghc/wiki/KindFact,
      this patch adds a new kind Constraint such that:
      
        Show :: * -> Constraint
        (?x::Int) :: Constraint
        (Int ~ a) :: Constraint
      
      And you can write *any* type with kind Constraint to the left of (=>):
      even if that type is a type synonym, type variable, indexed type or so on.
      
      The following (somewhat related) changes are also made:
       1. We now box equality evidence. This is required because we want
          to give (Int ~ a) the *lifted* kind Constraint
       2. For similar reasons, implicit parameters can now only be of
          a lifted kind. (?x::Int#) => ty is now ruled out
       3. Implicit parameter constraints are now allowed in superclasses
          and instance contexts (this just falls out as OK with the new
          constraint solver)
      
      Internally the following major changes were made:
       1. There is now no PredTy in the Type data type. Instead
          GHC checks the kind of a type to figure out if it is a predicate
       2. There is now no AClass TyThing: we represent classes as TyThings
          just as a ATyCon (classes had TyCons anyway)
       3. What used to be (~) is now pretty-printed as (~#). The box
          constructor EqBox :: (a ~# b) -> (a ~ b)
       4. The type LCoercion is used internally in the constraint solver
          and type checker to represent coercions with free variables
          of type (a ~ b) rather than (a ~# b)
      9729fe7c
    • batterseapower's avatar
      Fix handing of CoVars in SetLevels: it wasn't renaming occurrences of case-bound coercion variabes · 902d4606
      batterseapower authored
      Conflicts:
      
      	compiler/simplCore/SetLevels.lhs
      902d4606
  31. 18 Aug, 2011 1 commit
  32. 27 Jul, 2011 1 commit
  33. 23 Jul, 2011 1 commit
    • Simon Peyton Jones's avatar
      A nice tidy-up for CvSubst and liftCoSubst · 525aca2c
      Simon Peyton Jones authored
      A "lifting substitition" takes a *type* to a *coercion*, using a
      substitution that takes a *type variable* to a *coercion*.  We were
      using a CvSubst for this purpose, which was an awkward exception: in
      every other use of CvSubst, type variables map only to types.
      
      Turned out that Coercion.liftCoSubst is quite a small function, so I
      rewrote it with a special substitution type Coercion.LiftCoSubst, just
      for that purpose.  In doing so I found that the function itself was
      bizarrely over-complicated ... a direct result of mis-using CvSubst.
      
      So this patch makes it all simpler, faster, and easier to understand.
      No bugs fixed though!
      525aca2c
  34. 21 Jul, 2011 1 commit
    • Simon Peyton Jones's avatar
      Simplify the treatment of RULES in OccurAnal · f88b20f4
      Simon Peyton Jones authored
      I realised that my recently-added cunning stuff about
      RULES for imported Ids was simply wrong, so this patch
      removes it.   See Note [Rules for imported functions],
      which explains it all.
      
      This patch also does quite a bit of refactoring in
      the treatment of loop breakers.
      f88b20f4
  35. 30 Jun, 2011 2 commits