This project is mirrored from https://gitlab.haskell.org/ghc/ghc.git. Pull mirroring failed .
Repository mirroring has been paused due to too many failed attempts. It can be resumed by a project maintainer.
Last successful update .
  1. 24 Oct, 2015 1 commit
  2. 23 Oct, 2015 1 commit
  3. 19 Oct, 2015 1 commit
    • Facundo Domínguez's avatar
      base: Have the argument of mask restore the state. · 2b25a589
      Facundo Domínguez authored
      The implementation of `mask` and `uninterruptibleMask` assumed so far
      that the restore argument would be called in a context with the same
      masking state as that set by `mask` or `uninterruptibleMask`.
      
      This patch has the restore argument restore the masking, whatever the
      current masking state is.
      
      Test Plan: validate
      
      Reviewers: simonmar, hvr, austin, bgamari
      
      Reviewed By: bgamari
      
      Subscribers: thomie, qnikst
      
      Differential Revision: https://phabricator.haskell.org/D1327
      
      GHC Trac Issues: #10149
      2b25a589
  4. 17 Oct, 2015 1 commit
  5. 16 Oct, 2015 3 commits
  6. 15 Oct, 2015 1 commit
  7. 13 Oct, 2015 2 commits
  8. 12 Oct, 2015 1 commit
    • Herbert Valerio Riedel's avatar
      base: MRP-refactoring of AMP instances · e737a512
      Herbert Valerio Riedel authored
      This refactors `(>>)`/`(*>)`/`return`/`pure` methods into normal form.
      
      The redundant explicit `return` method definitions are dropped
      altogether.
      
      The explicit `(>>) = (*>)` definitions can't be removed yet, as
      the default implementation of `(>>)` is still in terms of `(*>)`
      (even though that should have been changed according to the AMP but
      wasn't -- see note in GHC.Base for details why this had to be postponed)
      
      A nofib comparision shows this refactoring to result in minor runtime
      improvements (unless those are within normal measurement fluctuations):
      
              Program           Size    Allocs   Runtime   Elapsed  TotalMem
        -------------------------------------------------------------------------
                  Min          -0.0%     -0.0%     -1.6%     -3.9%     -1.1%
                  Max          -0.0%     +0.0%     +0.5%     +0.5%      0.0%
        Geometric Mean         -0.0%     -0.0%     -0.4%     -0.5%     -0.0%
      
      Full `nofib` report at https://phabricator.haskell.org/P68
      
      Reviewers: quchen, alanz, austin, #core_libraries_committee, bgamari
      
      Reviewed By: bgamari
      
      Differential Revision: https://phabricator.haskell.org/D1316
      e737a512
  9. 10 Oct, 2015 1 commit
    • Ben Gamari's avatar
      Keep `shift{L,R}` on `Integer` from segfaulting · 182c44da
      Ben Gamari authored
      This can happen because the underlying primitive operations in
      `integer-gmp` don't support negative shift-amounts, and since
      `integer-gmp` can't throw proper exceptions and just provides a
      low-level API, it simply segfaults instead...
      
      This patch simply removes the `shift{L,R}` method definitions (and
      defines `unsafeShift{L,R}` instead) whose default-impls fallback on
      using `shift` which properly handles negative shift arguments.
      
      This addresses #10571
      
      Test Plan: harbormaster can do it
      
      Reviewers: hvr, austin, rwbarton
      
      Subscribers: rwbarton, thomie, bgamari
      
      Differential Revision: https://phabricator.haskell.org/D1018
      
      GHC Trac Issues: #10571
      182c44da
  10. 07 Oct, 2015 1 commit
  11. 03 Oct, 2015 1 commit
    • Ryan Scott's avatar
      Make GHC generics capable of handling unboxed types · 6cde981a
      Ryan Scott authored
      This adds a data family (`URec`) and six data family instances (`UAddr`,
      `UChar`, `UDouble`, `UFloat`, `UInt`, and `UWord`) which a `deriving
      Generic(1)` clause will generate if it sees `Addr#`, `Char#`, `Double#`,
      `Float#`, `Int#`, or `Word#`, respectively. The programmer can then
      provide instances for these data family instances to provide custom
      implementations for unboxed types, similar to how derived `Eq`, `Ord`,
      and `Show` instances currently special-case unboxed types.
      
      Fixes #10868.
      
      Test Plan: ./validate
      
      Reviewers: goldfire, dreixel, bgamari, austin, hvr, kosmikus
      
      Reviewed By: dreixel, kosmikus
      
      Subscribers: simonpj, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1239
      
      GHC Trac Issues: #10868
      6cde981a
  12. 02 Oct, 2015 3 commits
  13. 28 Sep, 2015 1 commit
    • Joachim Breitner's avatar
      Allow enumDeltaIntegerFB to be inlined · 78053f44
      Joachim Breitner authored
      The function is very small and the compiler should be at liberty to
      inline it. But it is recursive, so it did not do it before. By applying
      the usual transformation with a local recursive function, GHC can now
      inline it, producing the loop that one would expect.
      78053f44
  14. 25 Sep, 2015 1 commit
    • Ben Gamari's avatar
      Weak: Don't require wrapping/unwrapping of finalizers · fb409264
      Ben Gamari authored
      To quote Simon Marlow,
      
          We don't expect users to ever write code that uses mkWeak# or
          finalizeWeak#, we have safe interfaces to these. Let's document the type
          unsafety and fix the problem with () without introducing any overhead.
      
      Updates stm submodule.
      fb409264
  15. 24 Sep, 2015 1 commit
  16. 23 Sep, 2015 2 commits
  17. 22 Sep, 2015 1 commit
  18. 12 Sep, 2015 1 commit
  19. 08 Sep, 2015 1 commit
  20. 07 Sep, 2015 2 commits
    • Joachim Breitner's avatar
      Further simplify the story around minimum/maximum · c6b82e99
      Joachim Breitner authored
      After I have found out that I should look at -ddump-prep and not
      -ddump-core, I noticed that these days, GHC is perfectly capeable of
      turning (the equivalent) of foldl to (the equivalent) of foldl' if the
      operation in question is strict. So instead of using rewrite rules to
      rewrite maximum to a strictMaximum for certain types, we simply use
      SPECIALIZE.
      
      This also marks maximum/minimum as INLINEABLE, so that client code can
      get similar specializations, hopefully even automatically. And inded,
      minimum applied to [Double] produces good code (although due to
      inlineing, not due to specialization, it seems).
      
      I checked (by looking at the core) that this still fixes #10788.
      
      Differential revision: https://phabricator.haskell.org/D1229
      c6b82e99
    • Joachim Breitner's avatar
      SPECIALIZE strictMinimum for Int and Integer · dc671a1c
      Joachim Breitner authored
      This fixes a regression reported in #10788, where due to less inlining
      compared to earlier versions, we’d get worse code. With the SPECIALIZE,
      we get the good code, and moreover, the good code is in List.hs and
      _not_ inlined to the use site, so smaller code size and less compilation
      time.
      dc671a1c
  21. 04 Sep, 2015 1 commit
    • Joachim Breitner's avatar
      Make Data.List.foldr1 inline · 85915e9b
      Joachim Breitner authored
      Previously, foldr1 would be defiend recursively and thus not inline.
      This is bad, for example, when maximumBy has a strict comparison
      function: Before the BBP, it was implemented via foldl1, which inlined
      and yielded good code. With BBP, it goes via foldr1, so we better inline
      this as well. Fixes #10830.
      
      Differential Revision: https://phabricator.haskell.org/D1205
      85915e9b
  22. 02 Sep, 2015 2 commits
    • thomie's avatar
      Testsuite: mark 4 tests expect_broken_for(#10712, opt_ways) · 3b233793
      thomie authored
      Please revert when #10712 is fixed.
      3b233793
    • Eric Seidel's avatar
      Use IP based CallStack in error and undefined · 6740d70d
      Eric Seidel authored
      This patch modifies `error`, `undefined`, and `assertError` to use
      implicit call-stacks to provide better error messages to users.
      
      There are a few knock-on effects:
      
      - `GHC.Classes.IP` is now wired-in so it can be used in the wired-in
        types for `error` and `undefined`.
      
      - `TysPrim.tyVarList` has been replaced with a new function
        `TysPrim.mkTemplateTyVars`. `tyVarList` made it easy to introduce
        subtle bugs when you need tyvars of different kinds. The naive
      
        ```
        tv1 = head $ tyVarList kind1
        tv2 = head $ tyVarList kind2
        ```
      
        would result in `tv1` and `tv2` sharing a `Unique`, thus substitutions
        would be applied incorrectly, treating `tv1` and `tv2` as the same
        tyvar. `mkTemplateTyVars` avoids this pitfall by taking a list of kinds
        and producing a single tyvar of each kind.
      
      - The types `GHC.SrcLoc.SrcLoc` and `GHC.Stack.CallStack` now live in
        ghc-prim.
      
      - The type `GHC.Exception.ErrorCall` has a new constructor
        `ErrorCallWithLocation` that takes two `String`s instead of one, the
        2nd one being arbitrary metadata about the error (but usually the
        call-stack). A bi-directional pattern synonym `ErrorCall` continues to
        provide the old API.
      
      Updates Cabal, array, and haddock submodules.
      
      Reviewers: nh2, goldfire, simonpj, hvr, rwbarton, austin, bgamari
      
      Reviewed By: simonpj
      
      Subscribers: rwbarton, rodlogic, goldfire, maoe, simonmar, carter,
      liyang, bgamari, thomie
      
      Differential Revision: https://phabricator.haskell.org/D861
      
      GHC Trac Issues: #5273
      6740d70d
  23. 29 Aug, 2015 1 commit
    • Ryan Scott's avatar
      Make Generic (Proxy t) instance poly-kinded (fixes #10775) · a6826c5d
      Ryan Scott authored
      This amounts to enabling PolyKinds in GHC.Generics. However, explicit
      kind signatures must be applied to the datatypes and typeclasses in
      GHC.Generics to ensure that the Core which TcGenGenerics generates
      is properly kinded.
      
      Several of the typeclasses in GHC.Generics could be poly-kinded, but
      this differential does not attempt to address this, since D493 already
      addresses this.
      
      Test Plan: ./validate
      
      Reviewers: hvr, austin, dreixel, bgamari
      
      Reviewed By: austin, dreixel, bgamari
      
      Subscribers: goldfire, thomie
      
      Differential Revision: https://phabricator.haskell.org/D1166
      
      GHC Trac Issues: #10775
      a6826c5d
  24. 27 Aug, 2015 1 commit
  25. 15 Aug, 2015 2 commits
  26. 07 Aug, 2015 2 commits
  27. 06 Aug, 2015 1 commit
    • Fumiaki Kinoshita's avatar
      base: Add instances · 97843d0b
      Fumiaki Kinoshita authored
      This patch adds following instances:
      
      * Foldable ZipList
      * Traversable ZipList
      * Functor Complex
      * Applicative Complex
      * Monad Complex
      * Foldable Complex
      * Traversable Complex
      * Generic1 Complex
      * Monoid a => Monoid (Identity a)
      * Storable ()
      
      Reviewers: ekmett, fumieval, hvr, austin
      
      Subscribers: thomie, #core_libraries_committee
      
      Projects: #core_libraries_committee
      
      Differential Revision: https://phabricator.haskell.org/D1049
      
      GHC Trac Issues: #10609
      97843d0b
  28. 05 Aug, 2015 3 commits