1. 07 Jul, 2015 1 commit
  2. 15 May, 2014 1 commit
    • Herbert Valerio Riedel's avatar
      Add LANGUAGE pragmas to compiler/ source files · 23892440
      Herbert Valerio Riedel authored
      In some cases, the layout of the LANGUAGE/OPTIONS_GHC lines has been
      reorganized, while following the convention, to
      
      - place `{-# LANGUAGE #-}` pragmas at the top of the source file, before
        any `{-# OPTIONS_GHC #-}`-lines.
      
      - Moreover, if the list of language extensions fit into a single
        `{-# LANGUAGE ... -#}`-line (shorter than 80 characters), keep it on one
        line. Otherwise split into `{-# LANGUAGE ... -#}`-lines for each
        individual language extension. In both cases, try to keep the
        enumeration alphabetically ordered.
        (The latter layout is preferable as it's more diff-friendly)
      
      While at it, this also replaces obsolete `{-# OPTIONS ... #-}` pragma
      occurences by `{-# OPTIONS_GHC ... #-}` pragmas.
      23892440
  3. 27 Feb, 2014 1 commit
    • Simon Marlow's avatar
      Fix a bug in codegen for non-updatable selector thunks (#8817) · b1ddec1e
      Simon Marlow authored
      To evaluate most non-updatable thunks, we can jump directly to the
      entry code if we know what it is.  But not for a selector thunk: these
      might be updated by the garbage collector, so we have to enter the
      closure with an indirect jump through its info pointer.
      b1ddec1e
  4. 05 Dec, 2013 1 commit
  5. 22 Nov, 2013 1 commit
  6. 18 Sep, 2013 1 commit
  7. 29 Aug, 2013 2 commits
    • Jan Stolarek's avatar
      Optimize self-recursive tail calls · d61c3ac1
      Jan Stolarek authored
      This patch implements loopification optimization. It was described
      in "Low-level code optimisations in the Glasgow Haskell Compiler" by
      Krzysztof Woś, but we use a different approach here. Krzysztof's
      approach was to perform optimization as a Cmm-to-Cmm pass. Our
      approach is to generate properly optimized tail calls in the code
      generator, which saves us the trouble of processing Cmm. This idea
      was proposed by Simon Marlow. Implementation details are explained
      in Note [Self-recursive tail calls].
      
      Performance of most nofib benchmarks is not affected. There are
      some benchmarks that show 5-7% improvement, with an average improvement
      of 2.6%. It would require some further investigation to check if this
      is related to benchamrking noise or does this optimization really
      help make some class of programs faster.
      
      As a minor cleanup, this patch renames forkProc to forkLneBody.
      It also moves some data declarations from StgCmmMonad to
      StgCmmClosure, because they are needed there and it seems that
      StgCmmClosure is on top of the whole StgCmm* hierarchy.
      d61c3ac1
    • Jan Stolarek's avatar
      Whitespaces and comment formatting · 1d1ab12d
      Jan Stolarek authored
      1d1ab12d
  8. 20 Aug, 2013 1 commit
  9. 25 Jun, 2013 2 commits
  10. 19 Jun, 2013 1 commit
  11. 29 Mar, 2013 1 commit
    • nfrisby's avatar
      ticky enhancements · 460abd75
      nfrisby authored
        * the new StgCmmArgRep module breaks a dependency cycle; I also
          untabified it, but made no real changes
      
        * updated the documentation in the wiki and change the user guide to
          point there
      
        * moved the allocation enters for ticky and CCS to after the heap check
      
          * I left LDV where it was, which was before the heap check at least
            once, since I have no idea what it is
      
        * standardized all (active?) ticky alloc totals to bytes
      
        * in order to avoid double counting StgCmmLayout.adjustHpBackwards
          no longer bumps ALLOC_HEAP_ctr
      
        * I resurrected the SLOW_CALL counters
      
          * the new module StgCmmArgRep breaks cyclic dependency between
            Layout and Ticky (which the SLOW_CALL counters cause)
      
          * renamed them SLOW_CALL_fast_<pattern> and VERY_SLOW_CALL
      
        * added ALLOC_RTS_ctr and _tot ticky counters
      
          * eg allocation by Storage.c:allocate or a BUILD_PAP in stg_ap_*_info
      
          * resurrected ticky counters for ALLOC_THK, ALLOC_PAP, and
            ALLOC_PRIM
      
          * added -ticky and -DTICKY_TICKY in ways.mk for debug ways
      
        * added a ticky counter for total LNE entries
      
        * new flags for ticky: -ticky-allocd -ticky-dyn-thunk -ticky-LNE
      
          * all off by default
      
          * -ticky-allocd: tracks allocation *of* closure in addition to
             allocation *by* that closure
      
          * -ticky-dyn-thunk tracks dynamic thunks as if they were functions
      
          * -ticky-LNE tracks LNEs as if they were functions
      
        * updated the ticky report format, including making the argument
          categories (more?) accurate again
      
        * the printed name for things in the report include the unique of
          their ticky parent as well as if they are not top-level
      460abd75
  12. 19 Nov, 2012 1 commit
    • Simon Marlow's avatar
      Code-size optimisation for top-level indirections (#7308) · 7da13762
      Simon Marlow authored
      Top-level indirections are often generated when there is a cast, e.g.
      
      foo :: T
      foo = bar `cast` (some coercion)
      
      For these we were generating a full-blown CAF, which is a fair chunk
      of code.
      
      This patch makes these indirections generate a single IND_STATIC
      closure (4 words) instead.  This is exactly what the CAF would
      evaluate to eventually anyway, we're just shortcutting the whole
      process.
      7da13762
  13. 16 Oct, 2012 1 commit
    • ian@well-typed.com's avatar
      Some alpha renaming · cd33eefd
      ian@well-typed.com authored
      Mostly d -> g (matching DynFlag -> GeneralFlag).
      Also renamed if* to when*, matching the Haskell if/when names
      cd33eefd
  14. 08 Oct, 2012 1 commit
    • Simon Marlow's avatar
      Produce new-style Cmm from the Cmm parser · a7c0387d
      Simon Marlow authored
      The main change here is that the Cmm parser now allows high-level cmm
      code with argument-passing and function calls.  For example:
      
      foo ( gcptr a, bits32 b )
      {
        if (b > 0) {
           // we can make tail calls passing arguments:
           jump stg_ap_0_fast(a);
        }
      
        return (x,y);
      }
      
      More details on the new cmm syntax are in Note [Syntax of .cmm files]
      in CmmParse.y.
      
      The old syntax is still more-or-less supported for those occasional
      code fragments that really need to explicitly manipulate the stack.
      However there are a couple of differences: it is now obligatory to
      give a list of live GlobalRegs on every jump, e.g.
      
        jump %ENTRY_CODE(Sp(0)) [R1];
      
      Again, more details in Note [Syntax of .cmm files].
      
      I have rewritten most of the .cmm files in the RTS into the new
      syntax, except for AutoApply.cmm which is generated by the genapply
      program: this file could be generated in the new syntax instead and
      would probably be better off for it, but I ran out of enthusiasm.
      
      Some other changes in this batch:
      
       - The PrimOp calling convention is gone, primops now use the ordinary
         NativeNodeCall convention.  This means that primops and "foreign
         import prim" code must be written in high-level cmm, but they can
         now take more than 10 arguments.
      
       - CmmSink now does constant-folding (should fix #7219)
      
       - .cmm files now go through the cmmPipeline, and as a result we
         generate better code in many cases.  All the object files generated
         for the RTS .cmm files are now smaller.  Performance should be
         better too, but I haven't measured it yet.
      
       - RET_DYN frames are removed from the RTS, lots of code goes away
      
       - we now have some more canned GC points to cover unboxed-tuples with
         2-4 pointers, which will reduce code size a little.
      a7c0387d
  15. 18 Sep, 2012 2 commits
  16. 16 Sep, 2012 1 commit
  17. 03 Sep, 2012 1 commit
  18. 06 Aug, 2012 1 commit
  19. 30 Jul, 2012 1 commit
    • Simon Marlow's avatar
      New codegen: do not split proc-points when using the NCG · f1ed6a10
      Simon Marlow authored
      Proc-point splitting is only required by backends that do not support
      having proc-points within a code block (that is, everything except the
      native backend, i.e. LLVM and C).
      
      Not doing proc-point splitting saves some compilation time, and might
      produce slightly better code in some cases.
      f1ed6a10
  20. 24 Jul, 2012 1 commit
  21. 20 Jun, 2012 1 commit
  22. 13 Jun, 2012 1 commit
  23. 07 Jun, 2012 1 commit
    • Simon Marlow's avatar
      Fix for earger blackholing of thunks with no free variables (#6146) · 21a53a1c
      Simon Marlow authored
      A thunk with no free variables was not getting blackholed when
      -feager-blackholing was on, but we were nevertheless pushing the
      stg_bh_upd_frame version of the update frame that expects to see a
      black hole.
      
      I fixed this twice for good measure:
      
       - we now call blackHoleOnEntry when pushing the update frame to check
         whether the closure was actually blackholed, and so that we use the
         same predicate in both places
      
       - we now black hole thunks even if they have no free variables.
         These only occur when optimisation is off, but presumably if you say
         -feager-blackholing then that's what you want to happen.
      21a53a1c
  24. 05 Jun, 2012 1 commit
  25. 15 May, 2012 1 commit
    • batterseapower's avatar
      Support code generation for unboxed-tuple function arguments · 09987de4
      batterseapower authored
      This is done by a 'unarisation' pre-pass at the STG level which
      translates away all (live) binders binding something of unboxed
      tuple type.
      
      This has the following knock-on effects:
        * The subkind hierarchy is vastly simplified (no UbxTupleKind or ArgKind)
        * Various relaxed type checks in typechecker, 'foreign import prim' etc
        * All case binders may be live at the Core level
      09987de4
  26. 14 Feb, 2012 1 commit
    • Simon Marlow's avatar
      Fix an SRT-related bug · b8172ba1
      Simon Marlow authored
      We were using the SRT information generated by the computeSRTs pass to
      decide whether to add a static link field to a constructor or not, and
      this broke when I disabled computeSRTs for the new code generator.  So
      I've hacked it for now to only rely on the SRT information generated
      by CoreToStg.
      b8172ba1
  27. 25 Jan, 2012 1 commit
    • Iavor S. Diatchki's avatar
      Add support for type-level "strings". · 5851f847
      Iavor S. Diatchki authored
      These are types that look like "this" and "that".
      They are of kind `Symbol`, defined in module `GHC.TypeLits`.
      
      For each type-level symbol `X`, we have a singleton type, `TSymbol X`.
      
      The value of the singleton type can be named with the overloaded
      constant `tSymbol`.  Here is an example:
      
      tSymbol :: TSymbol "Hello"
      5851f847
  28. 13 Jan, 2012 1 commit
  29. 19 Dec, 2011 1 commit
  30. 04 Nov, 2011 1 commit
  31. 02 Oct, 2011 1 commit
  32. 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
    • Simon Marlow's avatar
      fix the eager-blackholing check, which I inadvertently broke in · 6ffaf6ff
      Simon Marlow authored
      1c2f8953 (symptom was broken
      biographical profiling, see #5451).
      6ffaf6ff
  33. 25 Aug, 2011 4 commits