Ticket #3800: ghc_StgArrWords.2.dpatch

Fri Jan  1 12:33:46 CST 2010  Antoine Latter <aslatter@gmail.com>
  * FIX #38000 Store StgArrWords payload size in bytes

New patches:

[FIX #38000 Store StgArrWords payload size in bytes
Antoine Latter <aslatter@gmail.com>**20100101183346
 Ignore-this: 7bf3ab4fc080c46311fc10b179361bb6
] {
hunk ./compiler/codeGen/CgPrimOp.hs 146
                 CmmMayReturn
 
 --  #define sizzeofByteArrayzh(r,a) \
---     r = (((StgArrWords *)(a))->words * sizeof(W_))
+--     r = ((StgArrWords *)(a))->bytes
 emitPrimOp [res] SizeofByteArrayOp [arg] _
    = stmtC $
hunk ./compiler/codeGen/CgPrimOp.hs 149
-       CmmAssign (CmmLocal res) (CmmMachOp mo_wordMul [
-                         cmmLoadIndexW arg fixedHdrSize bWord,
-                         CmmLit (mkIntCLit wORD_SIZE)
-                       ])
+       CmmAssign (CmmLocal res) (cmmLoadIndexW arg fixedHdrSize bWord)
 
 --  #define sizzeofMutableByteArrayzh(r,a) \
hunk ./compiler/codeGen/CgPrimOp.hs 152
---      r = (((StgArrWords *)(a))->words * sizeof(W_))
+--      r = ((StgArrWords *)(a))->bytes
 emitPrimOp [res] SizeofMutableByteArrayOp [arg] live
    = emitPrimOp [res] SizeofByteArrayOp [arg] live
 
hunk ./compiler/codeGen/StgCmmPrim.hs 220
                [(CmmReg (CmmGlobal BaseReg), AddrHint), (mutv,AddrHint)]
 
 --  #define sizzeofByteArrayzh(r,a) \
---     r = (((StgArrWords *)(a))->words * sizeof(W_))
+--     r = ((StgArrWords *)(a))->bytes
 emitPrimOp [res] SizeofByteArrayOp [arg]
    = emit $
hunk ./compiler/codeGen/StgCmmPrim.hs 223
-       mkAssign (CmmLocal res) (CmmMachOp mo_wordMul [
-                         cmmLoadIndexW arg fixedHdrSize bWord,
-                         CmmLit (mkIntCLit wORD_SIZE)
-                       ])
+       mkAssign (CmmLocal res) (cmmLoadIndexW arg fixedHdrSize bWord)
 
 --  #define sizzeofMutableByteArrayzh(r,a) \
hunk ./compiler/codeGen/StgCmmPrim.hs 226
---      r = (((StgArrWords *)(a))->words * sizeof(W_))
+--      r = ((StgArrWords *)(a))->bytes
 emitPrimOp [res] SizeofMutableByteArrayOp [arg]
    = emitPrimOp [res] SizeofByteArrayOp [arg]
 
hunk ./includes/Cmm.h 418
 /* The offset of the payload of an array */
 #define BYTE_ARR_CTS(arr)  ((arr) + SIZEOF_StgArrWords)
 
+/* The number of words allocated in an array payload */
+#define BYTE_ARR_WDS(arr) ROUNDUP_BYTES_TO_WDS(StgArrWords_bytes(arr))
+
 /* Getting/setting the info pointer of a closure */
 #define SET_INFO(p,info) StgHeader_info(p) = info
 #define GET_INFO(p) StgHeader_info(p)
hunk ./includes/mkDerivedConstants.c 285
     closure_field(StgMutArrPtrs, size);
 
     closure_size(StgArrWords);
-    closure_field(StgArrWords, words);
+    closure_field(StgArrWords, bytes);
     closure_payload(StgArrWords, payload);
 
     closure_field(StgTSO, _link);
hunk ./includes/rts/storage/ClosureMacros.h 130
 
 #define SET_ARR_HDR(c,info,costCentreStack,n_words)    \
    SET_HDR(c,info,costCentreStack);                    \
-   (c)->words = n_words;
+   (c)->bytes = n_words*sizeof(W_);
 
 /* -----------------------------------------------------------------------------
    How to get hold of the static link field for a static closure.
hunk ./includes/rts/storage/ClosureMacros.h 277
 INLINE_HEADER StgOffset pap_sizeW( StgPAP* x )
 { return PAP_sizeW(x->n_args); }
 
+INLINE_HEADER StgWord arr_words_words( StgArrWords* x)
+{ return ROUNDUP_BYTES_TO_WDS(x->bytes); }
+
 INLINE_HEADER StgOffset arr_words_sizeW( StgArrWords* x )
hunk ./includes/rts/storage/ClosureMacros.h 281
-{ return sizeofW(StgArrWords) + x->words; }
+{ return sizeofW(StgArrWords) + arr_words_words(x); }
 
 INLINE_HEADER StgOffset mut_arr_ptrs_sizeW( StgMutArrPtrs* x )
 { return sizeofW(StgMutArrPtrs) + x->size; }
hunk ./includes/rts/storage/Closures.h 132
 
 typedef struct {
     StgHeader  header;
-    StgWord    words;
+    StgWord    bytes;
     StgWord    payload[FLEXIBLE_ARRAY];
 } StgArrWords;
 
hunk ./rts/PrimOps.cmm 64
     ("ptr" p) = foreign "C" allocate(MyCapability() "ptr",words) [];
     TICK_ALLOC_PRIM(SIZEOF_StgArrWords,WDS(payload_words),0);
     SET_HDR(p, stg_ARR_WORDS_info, W_[CCCS]);
-    StgArrWords_words(p) = payload_words;
+    StgArrWords_bytes(p) = n;
     RET_P(p);
 }
 
hunk ./rts/PrimOps.cmm 73
 
 stg_newPinnedByteArrayzh
 {
-    W_ words, bytes, payload_words, p;
+    W_ words, n, bytes, payload_words, p;
 
     MAYBE_GC(NO_PTRS,stg_newPinnedByteArrayzh);
hunk ./rts/PrimOps.cmm 76
-    bytes = R1;
+    n = R1;
+    bytes = n;
     /* payload_words is what we will tell the profiler we had to allocate */
     payload_words = ROUNDUP_BYTES_TO_WDS(bytes);
     /* When we actually allocate memory, we need to allow space for the
hunk ./rts/PrimOps.cmm 97
     p = p + ((-p - SIZEOF_StgArrWords) & BA_MASK);
 
     SET_HDR(p, stg_ARR_WORDS_info, W_[CCCS]);
-    StgArrWords_words(p) = payload_words;
+    StgArrWords_bytes(p) = n;
     RET_P(p);
 }
 
hunk ./rts/PrimOps.cmm 103
 stg_newAlignedPinnedByteArrayzh
 {
-    W_ words, bytes, payload_words, p, alignment;
+    W_ words, n, bytes, payload_words, p, alignment;
 
     MAYBE_GC(NO_PTRS,stg_newAlignedPinnedByteArrayzh);
hunk ./rts/PrimOps.cmm 106
-    bytes = R1;
+    n = R1;
     alignment = R2;
 
hunk ./rts/PrimOps.cmm 109
+    bytes = n;
+
     /* payload_words is what we will tell the profiler we had to allocate */
     payload_words = ROUNDUP_BYTES_TO_WDS(bytes);
 
hunk ./rts/PrimOps.cmm 132
     p = p + ((-p - SIZEOF_StgArrWords) & (alignment - 1));
 
     SET_HDR(p, stg_ARR_WORDS_info, W_[CCCS]);
-    StgArrWords_words(p) = payload_words;
+    StgArrWords_bytes(p) = n;
     RET_P(p);
 }
 
hunk ./rts/PrimOps.cmm 381
   TICK_ALLOC_PRIM(SIZEOF_StgArrWords,WDS(payload_words),0);
   SET_HDR(p, stg_ARR_WORDS_info, W_[CCCS]);
 
-  StgArrWords_words(p)     = payload_words;
+  StgArrWords_bytes(p)     = WDS(payload_words);
   StgArrWords_payload(p,0) = fptr;
   StgArrWords_payload(p,1) = ptr;
   StgArrWords_payload(p,2) = eptr;
hunk ./rts/PrimOps.cmm 1517
     
     bitmap_arr = R5;
 
-    words = BYTES_TO_WDS(SIZEOF_StgBCO) + StgArrWords_words(bitmap_arr);
+    words = BYTES_TO_WDS(SIZEOF_StgBCO) + BYTE_ARR_WDS(bitmap_arr);
     bytes = WDS(words);
 
     ALLOC_PRIM( bytes, R1_PTR&R2_PTR&R3_PTR&R5_PTR, stg_newBCOzh );
hunk ./rts/PrimOps.cmm 1535
     W_ i;
     i = 0;
 for:
-    if (i < StgArrWords_words(bitmap_arr)) {
+    if (i < BYTE_ARR_WDS(bitmap_arr)) {
        StgBCO_bitmap(bco,i) = StgArrWords_payload(bitmap_arr,i);
        i = i + 1;
        goto for;
hunk ./rts/PrimOps.cmm 1629
        is promoted. */
     
     SET_HDR(nptrs_arr, stg_ARR_WORDS_info, W_[CCCS]);
-    StgArrWords_words(nptrs_arr) = nptrs;
+    StgArrWords_bytes(nptrs_arr) = WDS(nptrs);
     p = 0;
 for2:
     if(p < nptrs) {
hunk ./rts/Printer.c 309
             for (i = 0; arrWordsGetChar(obj,i); ++i) {
                 putchar(arrWordsGetChar(obj,i));
                } */
-           for (i=0; i<((StgArrWords *)obj)->words; i++)
+           for (i=0; i<arr_words_words((StgArrWords *)obj); i++)
              debugBelch("%lu", (lnat)((StgArrWords *)obj)->payload[i]);
             debugBelch("\")\n");
             break;
hunk ./rts/parallel/Pack.c 1281
   ASSERT(info->type == ARR_WORDS || info->type == MUT_ARR_PTRS ||
         info->type == MUT_ARR_PTRS_FROZEN || info->type == MUT_VAR);
 
-  n = ((StgArrWords *)closure)->words;
+  n = arr_words_words(((StgArrWords *)closure));
   // this includes the header!: arr_words_sizeW(stgCast(StgArrWords*,q)); 
 
   IF_PAR_DEBUG(pack,
hunk ./rts/parallel/Pack.c 1302
   if (RtsFlags.ParFlags.ParStats.Global &&
       RtsFlags.GcFlags.giveStats > NO_GC_STATS) {
     globalParStats.tot_arrs++;
-    globalParStats.tot_arr_size += ((StgArrWords *)closure)->words;
+    globalParStats.tot_arr_size += arr_words_words(((StgArrWords *)closure));
   }
 
   /* record offset of the closure and allocate a GA */
hunk ./rts/parallel/Pack.c 1316
 
   /* Pack the header (2 words: info ptr and the number of words to follow) */
   Pack((StgWord)*(StgPtr)closure);
-  Pack(((StgArrWords *)closure)->words);
+  Pack(arr_words_words(((StgArrWords *)closure)));
 
   /* pack the payload of the closure (all non-ptrs) */
   for (i=0; i<n; i++)
hunk ./rts/parallel/Pack.c 2820
           ASSERT(info->type == ARR_WORDS || info->type == MUT_ARR_PTRS ||
                  info->type == MUT_ARR_PTRS_FROZEN || info->type == MUT_VAR));
 
-  n = ((StgArrWords *)bufptr)->words;
+  n = arr_words_words(((StgArrWords *)bufptr));
   // this includes the header!: arr_words_sizeW(stgCast(StgArrWords*,q)); 
 
   IF_PAR_DEBUG(pack,
hunk ./rts/parallel/Pack.c 2837
 
   /* Unpack the header (2 words: info ptr and the number of words to follow) */
   ((StgArrWords *)graph)->header.info = (StgInfoTable*)*bufptr++;  // assumes _HS==1; yuck!
-  ((StgArrWords *)graph)->words = (StgWord)*bufptr++;
+  ((StgArrWords *)graph)->bytes = ((StgWord)*bufptr++) * sizeof(StgWord);
 
   /* unpack the payload of the closure (all non-ptrs) */
   for (i=0; i<n; i++)
hunk ./rts/parallel/Pack.c 3931
       /* ToDo: check whether this is really needed */
       if (ip->type == ARR_WORDS) {
        ptrs = vhs = 0;
-       nonptrs = ((StgArrWords *)bufptr)->words;
+       nonptrs = arr_words_words(((StgArrWords *)bufptr));
        size = arr_words_sizeW((StgArrWords *)bufptr);
       }
 
hunk ./rts/parallel/Pack.c 4090
       /* ToDo: check whether this is really needed */
       if (ip->type == ARR_WORDS) {
        ptrs = vhs = 0;
-       nonptrs = ((StgArrWords *)bufptr)->words+1; // payload+words
+       nonptrs = arr_words_words(((StgArrWords *)bufptr))+1; // payload+words
        size = arr_words_sizeW((StgArrWords *)bufptr);
        ASSERT(size==_HS+vhs+nonptrs);
       }
hunk ./rts/parallel/Parallel.c 1048
     /* ToDo: check whether this can be merged with the default case */
     *size = arr_words_sizeW((StgArrWords *)node); 
     *ptrs = 0;
-    *nonptrs = ((StgArrWords *)node)->words;
+    *nonptrs = arr_words_words(((StgArrWords *)node));
     *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
     return info;
 
hunk ./rts/parallel/ParallelDebug.c 1272
   case ARR_WORDS:
     /* an array of (non-mutable) words */
     fprintf(stderr, "ARR_WORDS (%p) of %d non-ptrs (maybe a string?)\n", 
-           p, ((StgArrWords *)q)->words);
+           p, arr_words_words((StgArrWords *)q));
     break;
 
   case MUT_ARR_PTRS:
hunk ./rts/parallel/ParallelDebug.c 1629
   case ARR_WORDS:
     {
        char str[6];
-       sprintf(str,"%d",((StgArrWords*)p)->words);
+       sprintf(str,"%d",arr_words_words((StgArrWords*)p));
        strcat(finger_print,str); 
     }
     break;
}

Context:

[take newCAF() out from sm_mutex; use the capability-local mut list instead
Simon Marlow <marlowsd@gmail.com>**20091231160223
 Ignore-this: 81a9a0a1e279dea805a4ffd9cf124c90
] 
[Use local mut lists in UPD_IND(), also clean up Updates.h
Simon Marlow <marlowsd@gmail.com>**20091231113435
 Ignore-this: a4659d4d24f8c6626fa8403314c6a2e4
] 
[use local mut lists rather than global mut lists in sequential GC
Simon Marlow <marlowsd@gmail.com>**20091231113118
 Ignore-this: 782239ddca2a0ec5c928c310b1fad4e9
] 
[Allow throwTo() to be called without a source thread
Simon Marlow <marlowsd@gmail.com>**20091218163200
 Ignore-this: cb7265bc6c1c75f0dd49501c1bb74f64
 Returns false if the exception could not be thrown becuase the tartget
 thread was running.  Not used yet, but might come in handy later.
] 
[If ACTIVITY_INACTIVE is set, wait for GC before resetting it
Simon Marlow <marlowsd@gmail.com>**20091213201246
 Ignore-this: a3cd1a3aacbd68789ccc191e3b8d7778
 I don't think this fixes any real bugs, but there's a small
 possibility that when the RTS is woken up for an idle-time GC, the IO
 manager thread might be pre-empted which would prevent the idle GC
 from happening; this change ensures that the idle GC happens anyway.
] 
[Fix rules/build-dependencies.mk on OS X
Ian Lynagh <igloo@earth.li>**20091230185239
 Also more comments on why we have the sed rules that we do.
] 
[Copying Simon M's fix for 650 to the new codegen
dias@cs.tufts.edu**20091222222017
 Ignore-this: 4bd46e6ef23debc39c7c10aea3dfdf5c
] 
[Better error checking and code cleanup
dias@cs.tufts.edu**20091222221946
 Ignore-this: 16e89f4115cb392ebbb0899c081157ed
] 
[Add comments to darcs-all
simonpj@microsoft.com**20091221160511
 Ignore-this: 5a369a030785aec6ef0169e36757bba4
 
 The comments explain how darcs-all decides what repo to use
] 
[Fix Trac #3772: dict funs for single-field classes
simonpj@microsoft.com**20091221160431
 Ignore-this: 808f1a0633c600689653ab4763dc8628
 
 This patch fixes a bug that meant that INLINE pragamas on
 a method of a single-field class didn't work properly.
 
 See Note [Single-method classes] in TcInstDcls, and Trac #3772
] 
[Comments only (about implementing SPECIALISE pragmas)
simonpj@microsoft.com**20091221155745
 Ignore-this: c8c98b061c162a4585ff1141b65ea91a
] 
[A bit of refactoring, plus a sanity check
simonpj@microsoft.com**20091221155632
 Ignore-this: ba3efed78ce0b752f26891179d6b3987
 
 Check that a bottoming rhs does indeed get exposed with bottoming strictness
 Almost all the changed lines reflect some refactoring of tidyTopIdInfo.
] 
[Fix Trac #3776
simonpj@microsoft.com**20091221155509
 Ignore-this: 69607bdc7208775a305a5f39a575f0e2
 
 An easy fix.  See Note [Usage for sub-bndrs] in RnEnv.
] 
[Move all the CoreToDo stuff into CoreMonad
simonpj@microsoft.com**20091218164521
 Ignore-this: 57b3f63c1faa82f7246ca46e4c9a4412
 
 This patch moves a lot of code around, but has zero functionality change.
 The idea is that the types
 
     CoreToDo
     SimplifierSwitch   
     SimplifierMode
     FloatOutSwitches
 
 and 
 
     the main core-to-core pipeline construction
 
 belong in simplCore/, and *not* in DynFlags.
] 
[Always expose the unfolding of something with an InlineRule
simonpj@microsoft.com**20091218164316
 Ignore-this: 4f952f423848b8840fab69d63ee81d8f
 
 Previously a bottoming function with a strictness wrapper 
 had a hidden inlining, and that was Very Bad, because in 
     f x = if ... then bot_fun x else x+1
 we really want to pass the *unboxed* x to bot_fun. This
 happens quite a bit in error handling code, eg for array
 indexing.
] 
[Comments only
simonpj@microsoft.com**20091218164119
 Ignore-this: b4731841b036e614385cadbdfeda70b0
] 
[Move loop-breaker info from original function to worker in work/wrap
simonpj@microsoft.com**20091218164107
 Ignore-this: cc5c062f02577834baa5031e25497c57
 
 When doing a w/w split, if the original function is a loop breaker
 then the worker (not the wrapper) becomes one instead.
 
 This isn't very important, because loop breaker information is
 recalculated afresh by the occurrence analyser, but it seems more
 kosher.  And Lint was bleating piteously about things with InlineRules
 that were loop breakers.
] 
[Make -ddump-inlinings and -ddump-rule-firings less noisy 
simonpj@microsoft.com**20091218163742
 Ignore-this: aea0634c569afd5486de9c6e7dad2ae2
 
 By default, these two now print *one line* per inlining or rule-firing.
 
 If you want the previous (voluminous) behaviour, use -dverbose-core2core.
] 
[Make warning printing a bit less noisy
simonpj@microsoft.com**20091218163549
 Ignore-this: 86bc5d020b077b6c9d666d3e4d93bd1e
 
 Use -dppr-debug to make it noisy again
] 
[Set fixity (left-assoc) for setIdOccInfo
simonpj@microsoft.com**20091218163513
 Ignore-this: 6de9c34824e7713d120c889fc019a72a
] 
[Comments only
simonpj@microsoft.com**20091218105434
 Ignore-this: 48a8ed9e9703b412a7dd3201f22cf92d
] 
[Add an extra heading in the output for count_lines
simonpj@microsoft.com**20091218105403
 Ignore-this: 9e4e91930aba49ad6a247aa1d38297cd
] 
[Fixes to account for the new layout of MUT_ARR_PTRS (see #650)
Simon Marlow <marlowsd@gmail.com>**20091221115249
 Ignore-this: ca4a58628707b362dccedb74e81ef052
] 
[Partial support for Haiku (#3727)
Simon Marlow <marlowsd@gmail.com>**20091221110250
 Ignore-this: 5d4a3104c1bd50b7eae64780cb73071d
] 
[Fix #3751, also fix some lexical error SrcLocs
Simon Marlow <marlowsd@gmail.com>**20091217132658
 Ignore-this: 63e11a7a64bb0c98e793e4cc883f051d
] 
[kill some old GRAN/PARALLEL_HASKELL code
Simon Marlow <marlowsd@gmail.com>**20091217103816
 Ignore-this: 9bcfe3e62c556074a6f9396385ba1cf4
] 
[improve panic messages for srcLocLine, srcLocCol
Simon Marlow <marlowsd@gmail.com>**20091217103801
 Ignore-this: f58623a39bcc65201f150ce9560739d1
] 
[Tweak the build-dependencies rule, and add comments for it
Ian Lynagh <igloo@earth.li>**20091219145808] 
[When removing $(TOP) with sed, do so case insensitively
Ian Lynagh <igloo@earth.li>**20091219135339
 This avoids problems on Windows, where drive letters may not be the
 case we expect.
] 
[Fix a braino in a comment
Ian Lynagh <igloo@earth.li>**20091218213541] 
[Avoid a failing shell command when cleaning
Ian Lynagh <igloo@earth.li>**20091218201146
 It wasn't fatal, but better to avoid it anyway
] 
[Fix another sed problem on Solaris
Ian Lynagh <igloo@earth.li>**20091217000421] 
[unused named variables
dias@cs.tufts.edu**20091218195430
 Ignore-this: c2d56a21a039bb73023c54883a8c1fa3
] 
[missed a case in a previous fix
dias@cs.tufts.edu**20091217210443
 Ignore-this: ff40b8516a3de3fc36a55534620e4f50
 
 Here's the obscure problem:
 -- However, we also want to allow an assignment to be generated
 -- in the case when the types are compatible, because this allows
 -- some slightly-dodgy but occasionally-useful casts to be used,
 -- such as in RtClosureInspect where we cast an HValue to a MutVar#
 -- so we can print out the contents of the MutVar#.  If we generate
 -- code that enters the HValue, then we'll get a runtime panic, because
 -- the HValue really is a MutVar#.  The types are compatible though,
 -- so we can just generate an assignment.
 
] 
[Fix #650: use a card table to mark dirty sections of mutable arrays
Simon Marlow <marlowsd@gmail.com>**20091217224228
 Ignore-this: 75c354682c9ad1b71b68b5bc4cedd6de
 The card table is an array of bytes, placed directly following the
 actual array data.  This means that array reading is unaffected, but
 array writing needs to read the array size from the header in order to
 find the card table.
 
 We use a bytemap rather than a bitmap, because updating the card table
 must be multi-thread safe.  Each byte refers to 128 entries of the
 array, but this is tunable by changing the constant
 MUT_ARR_PTRS_CARD_BITS in includes/Constants.h.
] 
[Fix build with Solaris sed
Ian Lynagh <igloo@earth.li>**20091216204354
 Rather than trying to handle tabs with sed portably, we just use tr to
 remove them before we start.
] 
[Build and install inplace the count_lines and compareSizes utils
Ian Lynagh <igloo@earth.li>**20091216165608] 
[Adjust Activations for specialise and work/wrap, and better simplify in InlineRules
simonpj@microsoft.com**20091216145205
 Ignore-this: 2606cf9b00f2172097332b8b25b0553c
 
 This patch does two main things:
 
 1. Adjusts the way we set the Activation for
 
    a) The wrappers generated by the strictness analyser
       See Note [Wrapper activation] in WorkWrap
 
    b) The RULEs generated by Specialise and SpecConstr
       See Note [Auto-specialisation and RULES] in Specialise
           Note [Transfer activation] in SpecConstr
 
 2. Refines how we set the phase when simplifying the right
    hand side of an InlineRule.  See
    Note [Simplifying inside InlineRules] in SimplUtils.
 
 Most of the extra lines are comments!  
 
 The merit of (2) is that a bit more stuff happens inside InlineRules,
 and that in turn allows better dead-code elimination.
] 
[Comments only
simonpj@microsoft.com**20091216144908
 Ignore-this: 3dae7793802ded696b01f891a77aaf8
] 
[fix up libm detection and use (#3724)
Simon Marlow <marlowsd@gmail.com>**20091216113652
 Ignore-this: 6bbdd7302b262ac3b8ddc5c852dc538
] 
[configure.ac: fix libm checks (Trac #3730)
Sergei Trofimovich <slyfox@inbox.ru>**20091204214012
 Ignore-this: f3372535a68f3833247f679b023745c8
 
 libbfd pulled libm as dependency and broke LIBM= detection.
 
 Patch moves libm in library tests as early as possible.
 Thanks to asuffield for suggesting such a simple fix.
 Thanks to Roie Kerstein and Renato Gallo for finding
 and tracking down the issue.
] 
[#include <sys/select.h> if we have it (#3760)
Simon Marlow <marlowsd@gmail.com>**20091216095501
 Ignore-this: 7c00991a67ae6715e16c6458bf0b78af
] 
[add a couple of assertions
Simon Marlow <marlowsd@gmail.com>**20091123101918
 Ignore-this: e631da990055fd28156a6c887e1468ca
] 
[Add comments
simonpj@microsoft.com**20091216090344
 Ignore-this: 6468afc939ab795d5a0eb9fd5dc08a48
] 
[Refactor to combine two eqExpr functions
simonpj@microsoft.com**20091216085033
 Ignore-this: 925dec0fc9af1e0a9359226359627ae7
 
 I'd forgotten that Rules.lhs already has an eqExpr function.  This
 patch combines Rules.eqExpr with the (recent) CoreUtils.eqExpr.
 
 I also did a little refactoring by defining CoreSyn.expandUnfolding_maybe
 (see Note [Expanding variables] in Rules.lhs), and using it in
      a) CoreUnfold.exprIsConApp_maybe
      b) Rule matching
] 
[Two improvements to optCoercion
simonpj@microsoft.com**20091216084706
 Ignore-this: 699d2deb1b1bf0c7bd7afb809bee26d2
 
 * Fix a bug that meant that 
      (right (inst (forall tv.co) ty)) 
   wasn't getting optimised.  This showed up in the
   compiled code for ByteCodeItbls
 
 * Add a substitution to optCoercion, so that it simultaneously
   substitutes and optimises.  Both call sites wanted this, and
   optCoercion itself can use it, so it seems a win all round.
] 
[Comments only
simonpj@microsoft.com**20091216084558
 Ignore-this: e5fc7949893dbbdc756d0616647a999b
] 
[Make setInlineActivation left-associative
simonpj@microsoft.com**20091216084536
 Ignore-this: 4d166f158c79c819ac73a0368e52473c
] 
[Fix a long-standing infelicity in the type pretty printer
simonpj@microsoft.com**20091216084513
 Ignore-this: 2d99f8733f6642671fcb88f2179e91e9
 
 We weren't parenthesising 
    List (C Int)
 correctly, when (C Int) is a PredTy
] 
[Deal with warnings in Coercion.lhs
simonpj@microsoft.com**20091216084053
 Ignore-this: 8f5a0537c76ed366003253e1f550d4f5
] 
[Fix a bug in the in-scope set that led to some lookupIdSubst errors
simonpj@microsoft.com**20091215160216
 Ignore-this: ed89f1bf6ece2c1e1cd135f11b130786
] 
[Fix Trac #3717: exprOkForSpeculation should look through case expressions
simonpj@microsoft.com**20091215160124
 Ignore-this: 1b848137f7fb81b2c1f72cc903f1c008
 
 See Note [exprOkForSpeculation: case expressions] in CoreUtils
] 
[Add a size-comparison util
Ian Lynagh <igloo@earth.li>**20091215202636] 
[Just make C dependencies once, rather than each way
Ian Lynagh <igloo@earth.li>**20091215135350
 This makes generating C dependencies for the RTS take 3 seconds, rather
 than 30.
] 
[Make addCFileDeps quieter
Ian Lynagh <igloo@earth.li>**20091215134033
 Move a comment out of the definition, so it doesn't get printed as
 a shell command every time we call the definition
] 
[Don't make C deps for compiler/parser/cutils.c in stage1
Ian Lynagh <igloo@earth.li>**20091215123757
 CPP finds the Rts.h, RtsFlags.h etc from the tree, rather than the
 bootstrapping compiler, and then fails because it doesn't think
 RtsFlags.h should be used any more.
] 
[Tidy up computation of result discounts in CoreUnfold
simonpj@microsoft.com**20091214134647
 Ignore-this: 351076027f8e9cb8aa44db6d60798c47
 
 Mostly this patch is a tidy-up, but it did reveal one inconsistency
 that I fixed.  When computing result discounts for case expressions,
 we were *adding* result-discounts for cases on non-arguments, but
 *picking the one for the max-size branch* for arguments. I think you
 could argue the toss, but it seems neater (and the code is nicer)
 to be consistent (ie always add).  See Note [addAltSize result discounts].
 
 The nofib results seem fine
 
         Program           Size    Allocs   Runtime   Elapsed
 --------------------------------------------------------------------------------
           boyer          -0.8%     -4.8%      0.06      0.07
          sphere          -0.7%     -2.5%      0.15      0.16
 --------------------------------------------------------------------------------
             Min          -0.8%     -4.8%    -19.1%    -24.8%
             Max          -0.5%     +0.0%     +3.4%   +127.1%
  Geometric Mean          -0.7%     -0.1%     -4.3%     -1.3%
 
 The +127% elapsed is a timing error; I re-ran the same binary and it's
 unchanged from the baseline.
] 
[Use full equality for CSE
simonpj@microsoft.com**20091211173920
 Ignore-this: c6d73febf652aa34dc1197a49e599ee
 
 In CSE we were getting lots of apprarently-unequal expressions with
 the same hash code.  In fact they were perfectly equal -- but we were
 using a cheap-and-cheerful equality tests for CoreExpr that said False
 for any lambda expression!
 
 This patch adds a proper equality test for Core, with alpha-renaming.
 It's easy to do, and will avoid silly cases of CSE failing to fire.
 
 We should get less of this:
   WARNING: file compiler/simplCore/CSE.lhs line 326
   extendCSEnv: long list, length 18
 from a compiler built with -DDEBUG
] 
[Improve strictness analysis for bottoming functions
simonpj@microsoft.com**20091211162324
 Ignore-this: dd5ef03a1b4728c25a2333f59024dc9c
 
 I found the following results from strictness analyis:
   f x = error (fst x)      -- Strictness U(SA)b
   g x = error ('y':fst x)  -- Strictness Tb
 
 Surely 'g' is no less strict on 'x' than 'f' is!  The fix turned out
 be to very nice and simple.  See Note [Bottom demands] in DmdAnal.
] 
[Bottom extraction: float out bottoming expressions to top level
simonpj@microsoft.com**20091211161928
 Ignore-this: a1a96b36dc982d83f5c01a4259518b
   
 The idea is to float out bottoming expressions to top level,
 abstracting them over any variables they mention, if necessary.  This
 is good because it makes functions smaller (and more likely to
 inline), by keeping error code out of line. 
 
 See Note [Bottoming floats] in SetLevels.
 
 On the way, this fixes the HPC failures for cg059 and friends.
 
 I've been meaning to do this for some time.  See Maessen's paper 1999
 "Bottom extraction: factoring error handling out of functional
 programs" (unpublished I think).
 
 Here are the nofib results:
 
 
         Program           Size    Allocs   Runtime   Elapsed
 --------------------------------------------------------------------------------
             Min          +0.1%     -7.8%    -14.4%    -32.5%
             Max          +0.5%     +0.2%     +1.6%    +13.8%
  Geometric Mean          +0.4%     -0.2%     -4.9%     -6.7%
 
 Module sizes
         -1 s.d.                -----           -2.6%
         +1 s.d.                -----           +2.3%
         Average                -----           -0.2%
 
 Compile times:
         -1 s.d.                -----          -11.4%
         +1 s.d.                -----           +4.3%
         Average                -----           -3.8%
 
 I'm think program sizes have crept up because the base library
 is bigger -- module sizes in nofib decrease very slightly.  In turn
 I think that may be because the floating generates a call where
 there was no call before.  Anyway I think it's acceptable.
 
 
 The main changes are:
 
 * SetLevels floats out things that exprBotStrictness_maybe 
   identifies as bottom.  Make sure to pin on the right 
   strictness info to the newly created Ids, so that the
   info ends up in interface files.
 
   Since FloatOut is run twice, we have to be careful that we
   don't treat the function created by the first float-out as
   a candidate for the second; this is what worthFloating does.
 
   See SetLevels Note [Bottoming floats]
                 Note [Bottoming floats: eta expansion]
 
 * Be careful not to inline top-level bottoming functions; this 
   would just undo what the floating transformation achieves.
   See CoreUnfold Note [Do not inline top-level bottoming functions
  
   Ensuring this requires a bit of extra plumbing, but nothing drastic..
 
 * Similarly pre/postInlineUnconditionally should be 
   careful not to re-inline top-level bottoming things!
   See SimplUtils Note [Top-level botomming Ids]
                  Note [Top level and postInlineUnconditionally]
] 
[Expose all EventLog events as DTrace probes
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20091212100809
 Ignore-this: 2c5ef30b1ff7fb2ea5fba8cf0a187d45
 - Defines a DTrace provider, called 'HaskellEvent', that provides a probe
   for every event of the eventlog framework.
 - In contrast to the original eventlog, the DTrace probes are available in
   all flavours of the runtime system (DTrace probes have virtually no
   overhead if not enabled); when -DTRACING is defined both the regular
   event log as well as DTrace probes can be used.
 - Currently, Mac OS X only.  User-space DTrace probes are implemented
   differently on Mac OS X than in the original DTrace implementation.
   Nevertheless, it shouldn't be too hard to enable these probes on other
   platforms, too.
 - Documentation is at http://hackage.haskell.org/trac/ghc/wiki/DTrace
] 
[Fix two related bugs in u_tys
simonpj@microsoft.com**20091211120122
 Ignore-this: 25e826e0915c6f6267cadff96f1d7ca6
 
 When we normalise a type family application we must recursively call
 uTys, *not* 'go', because the latter loop is only there to look
 through type synonyms.  This bug made the type checker generate
 ill-typed coercions, which were rejected by Core Lint.
 
 A related bug only affects the size of coercions.  If faced with
   (m a) ~ (F b c)
 where F has arity 1, we want to decompose to 
    m ~ F Int,  a ~ c
 rather than deferring.  The application decomposition was being
 tried last, so we were missing this opportunity.
 
 Thanks to Roman for an example that showed all this up.
] 
[Fix spelling in comment
simonpj@microsoft.com**20091211115744
 Ignore-this: bd02fc0eb67efc7404536f1ee96d4d1f
] 
[Make -ddump-simpl-stats a bit more informative by default
simonpj@microsoft.com**20091208175445
 Ignore-this: 1bbe3f4c4b727a3b1580236c1f9c2583
 
 This mades -ddump-simpl-stats print out per-rule and per-id
 information by default, rather than requiring -dppr-debug.
 On the whole that is what you want.  The -dppr-debug flag
 now just controls printing of the log.
] 
[Improve dumping for rules, and documentation of same
simonpj@microsoft.com**20091208105556
 Ignore-this: 4b09e56f953d130d5cb2807cf9da7303
 
 Inspired by Trac #3703
] 
[Fix #3741, simplifying things in the process
Simon Marlow <marlowsd@gmail.com>**20091210160909
 Ignore-this: 8a668af4eb9e1aa71b4764b84f148dac
 The problem in #3741 was that we had confused column numbers with byte
 offsets, which fails in the case of UTF-8 (amongst other things).
 Fortunately we're tracking correct column offsets now, so we didn't
 have to make a calculation based on a byte offset.  I got rid of two
 fields from the PState (last_line_len and last_offs).and one field
 from the AI (alex input) constructor.
] 
[Allow spaces at either end of the C import spec (#3742)
Simon Marlow <marlowsd@gmail.com>**20091210124537
 Ignore-this: 840424ea49d5e81ab8f8ce3209d5eedf
] 
[Put README and INSTALL into bindists
Ian Lynagh <igloo@earth.li>**20091209174305
 Also tidied up the way configure.ac gets into bindists
] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20091209152223] 
[Fix the stage1 version number munging
Ian Lynagh <igloo@earth.li>**20091209151715
 It was munging 6.12.1 into 62
] 
[Add a comment about why $(CPP) is defined the way it is in config.mk.in
Ian Lynagh <igloo@earth.li>**20091209131917] 
[add a missing unlockTSO()
Simon Marlow <marlowsd@gmail.com>**20091209124113
 Ignore-this: 9ff0aedcb6d62e5b4bd2fab30bfce105
] 
[Eliminate mkdependC
Ian Lynagh <igloo@earth.li>**20091209123929
 We now just call gcc to get the dependencies directly
] 
[Change some HC_OPTS to CC_OPTS, so they are used when making dependencies
Ian Lynagh <igloo@earth.li>**20091208200315] 
[Add -Iincludes to hp2ps's CC_OPTS
Ian Lynagh <igloo@earth.li>**20091208175718
 Making C deps for hp2ps always failed, but we used to carry on regardless
] 
[add locking in mkWeakForeignEnv#
Simon Marlow <marlowsd@gmail.com>**20091208101229
 Ignore-this: 3902631687fc252c0e6794d58641371b
] 
[declare g0 (fixes compilation failure with -fvia-C)
Simon Marlow <marlowsd@gmail.com>**20091208100925] 
[simplify weak pointer processing
Simon Marlow <marlowsd@gmail.com>**20091208094822
 Ignore-this: d88091b23860eeba6cd971282b05c2e6
] 
[simplification/optimisation: update tso->bound->tso when scavenging the TSO
Simon Marlow <marlowsd@gmail.com>**20091208085739
 Ignore-this: 401e2c67e42de9671191ba9d18c3fcf7
] 
[threadStackUnderflow: fix recently introduced bug (conc068(threaded1) failure)
Simon Marlow <marlowsd@gmail.com>**20091207170127
 Ignore-this: cab7b66b3b1478d44ad5272eeec84004
 
 bug introduced by "threadStackUnderflow: put the new TSO on the mut
 list if necessary"
] 
[need locking around use of weak_ptr_list in mkWeak#
Simon Marlow <marlowsd@gmail.com>**20091207145213
 Ignore-this: 9c7d506c30652de4dd5c47d1989022c1
] 
[remove global 'total_allocated', seems to be the same as 'GC_tot_alloc'
Simon Marlow <marlowsd@gmail.com>**20091207115359
 Ignore-this: d174f167a2be6864bbab672f3d5b7c5
] 
[Add some explanation about overlapping instances
simonpj@microsoft.com**20091207153915
 Ignore-this: 627db39187f0ed8a10fe46e667a849a
 
 Trac #3734 suggested addding some extra guidance about 
 incoherence and overlap; now done
] 
[Tidy up deriving error messages
simonpj@microsoft.com**20091207130850
 Ignore-this: 4e134f6b62814ea6f361df7525c25a2d
 
 I did this in response to a suggestion in Trac #3702
] 
[Fix profiling build
Simon Marlow <marlowsd@gmail.com>**20091207092314
 Ignore-this: eb397ec713cb7a8f6e56f409e0663ffe
] 
[Minor refactoring to remove redundant code
simonpj@microsoft.com**20091207083312
 Ignore-this: 3203447fa823823ae27565f53d39bd10
] 
[Fix a nasty (and long-standing) FloatOut performance bug
simonpj@microsoft.com**20091207083246
 Ignore-this: a64b98992fa4ced434d1edf0b89842ec
 
 The effect was that, in deeply-nested applications, FloatOut would
 take quadratic time.  A good example was compiling 
     programs/barton-mangler-bug/Expected.hs
 in which FloatOut had a visible pause of a couple of seconds!
 Profiling showed that 40% of the entire compile time was being
 consumbed by the single function partitionByMajorLevel.
 
 The bug was that the floating bindings (type FloatBinds) was kept
 as a list, which was partitioned at each binding site.  In programs
 with deeply nested lists, such as
        e1 : e2 : e3 : .... : e5000 : []
 this led to quadratic behaviour.
 
 The solution is to use a proper finite-map representation;
 see the new definition of FloatBinds near the bottom of FloatOut.
] 
[Add a new to-do to cmm-notes
simonpj@microsoft.com**20091207081130
 Ignore-this: fc835da15dd8a206c2c1bdc6c7053c5b
] 
[Comments only, principally about IfaceDeclExtras
simonpj@microsoft.com**20091207081108
 Ignore-this: 1004303ab0df7802295d67c613c4ab24
] 
[Comments only, about RULE plumbing
simonpj@microsoft.com**20091207080442
 Ignore-this: 1a559744f6ad75e151afbfb2281bceb4
] 
[Add splitUFM to UniqFM (used in a forthcoming patch)
simonpj@microsoft.com**20091204160820
 Ignore-this: 332aa029f25ec3f22e4f195ecd44b40b
 
 splitUFM :: Uniquable key => UniqFM elt -> key -> (UniqFM elt, Maybe elt, UniqFM elt)
    -- Splits a UFM into things less than, equal to, and greater than the key
] 
[Add lengthBag to Bag (using in forthcoming patch)
simonpj@microsoft.com**20091204155055
 Ignore-this: 5af0f45d6b51bc77e54c5cb0e2b1e607
] 
[Use addToUFM_Acc where appropriate
simonpj@microsoft.com**20091204155036
 Ignore-this: 38e768c4a9f00d7870a631a9472e6edc
 
 This way of extending a UniqFM has existed for some time, but
 we weren't really using it.
 
 addToUFM_Acc   :: Uniquable key =>
                              (elt -> elts -> elts)     -- Add to existing
                           -> (elt -> elts)             -- New element
                           -> UniqFM elts               -- old
                           -> key -> elt                -- new
                           -> UniqFM elts               -- result
] 
[Add comments to "OPTIONS_GHC -fno-warn-orphans" pragmas
Ian Lynagh <igloo@earth.li>**20091205165721] 
[Add some missing exports back for GHC package users; fixes trac #3715
Ian Lynagh <igloo@earth.li>**20091205153532] 
[Add some comments on the alternative layout rule state
Ian Lynagh <igloo@earth.li>**20091205152039] 
[Tweak layout for alternative layout rule
Ian Lynagh <igloo@earth.li>**20091203164424] 
[Link all dynamic libraries with the correct install_name on Mac OS/X.
Ian Lynagh <igloo@earth.li>**20091204143614
 This is a rerecord of
     Stephen Blackheath <oversensitive.pastors.stephen@blacksapphire.com>**20090930222855
 to avoid conflicts.
] 
[Document the new -dylib-install-name option in the user's guide.
Stephen Blackheath <oversensitive.pastors.stephen@blacksapphire.com>**20091001051637
 Ignore-this: 568f6ad423f737ccda3a79f2d8efdb97
] 
[Add -dylib-install-name option to GHC so the install name can be set for dynamic libs on Mac OS/X.
Stephen Blackheath <oversensitive.pastors.stephen@blacksapphire.com>**20090930223708
 Ignore-this: 2323929595c0dc03a2e2ea802477a930
] 
[Force -fPIC when linking against dynamic libraries on Mac OS/X.
Stephen Blackheath <oversensitive.pastors.stephen@blacksapphire.com>**20090928203800
 Ignore-this: 465433af2349779b510f500dc79768f3
 Otherwise you get
 /tmp/ghc7602_0/ghc7602_0.s:207:0:
    non-relocatable subtraction expression, "___stginit_Lib_dyn" minus "L1x2;4"
 /tmp/ghc7602_0/ghc7602_0.s:207:0:
    symbol: "___stginit_Lib_dyn" can't be undefined in a subtraction expression
] 
[evaluate_large: evaluate large objects to bd->dest rather than gen->to
Simon Marlow <marlowsd@gmail.com>**20091204111037
 Ignore-this: 6c77407750d4a6178851aeb79ded20d1
 This fixes aging of large objects in the new scheme.  Bug found by
 perf/space_leaks/space_leak_001.  Yay perf regressions tests.
] 
[Correction to the allocation stats following earlier refactoring
Simon Marlow <marlowsd@gmail.com>**20091204110839
 Ignore-this: 7ac497c67706bedd29c79091c100d22f
] 
[export g0
Simon Marlow <marlowsd@gmail.com>**20091203165209
 Ignore-this: 69b5445beb91ac99bb018b9806de90a
] 
[GC refactoring, remove "steps"
Simon Marlow <marlowsd@gmail.com>**20091203150728
 Ignore-this: 5360b8bf30c6847ccb7ffa8c431e81ff
 
 The GC had a two-level structure, G generations each of T steps.
 Steps are for aging within a generation, mostly to avoid premature
 promotion.  
 
 Measurements show that more than 2 steps is almost never worthwhile,
 and 1 step is usually worse than 2.  In theory fractional steps are
 possible, so the ideal number of steps is somewhere between 1 and 3.
 GHC's default has always been 2.
 
 We can implement 2 steps quite straightforwardly by having each block
 point to the generation to which objects in that block should be
 promoted, so blocks in the nursery point to generation 0, and blocks
 in gen 0 point to gen 1, and so on.
 
 This commit removes the explicit step structures, merging generations
 with steps, thus simplifying a lot of code.  Performance is
 unaffected.  The tunable number of steps is now gone, although it may
 be replaced in the future by a way to tune the aging in generation 0.
] 
[fix error message on Windows (fixes rtsflags001)
Simon Marlow <marlowsd@gmail.com>**20091202141135
 Ignore-this: 239fed52f7f5358b034acd6512d26ef4
] 
[Fix loading of annotations
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091204024259
 Ignore-this: 5750856feecbf9c6aeebfec012b1a1fd
 
 The problem was that we collected all annotations we knew about once when the
 simplifier started and threaded them through the CoreM monad. If new interface
 files were loaded during simplification, their annotations would not be
 visible to the simplifier.
 
 Now, we rebuild the annotation list at the start of every simplifier pass that
 needs it (which is only SpecConstr at the moment). This ensures that we see
 all annotations that have been loaded so far. This is somewhat similar to how
 RULES are handled.
] 
[Add new ForceSpecConstr annotation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091203065455
 Ignore-this: ca5327f85d9d40c78d95e8bfe3e7fab1
 
 Annotating a type with {-# ANN type T ForceSpecConstr #-} makes SpecConstr
 ignore -fspec-constr-threshold and -fspec-constr-count for recursive functions
 that have arguments of type T. Such functions will be specialised regardless
 of their size and there is no upper bound on the number of specialisations
 that can be generated. This also works if T is embedded in other types such as
 Maybe T (but not T -> T).
 
 T should not be a product type because it could be eliminated by the
 worker/wrapper transformation. For instance, in
 
 data T = T Int Int
 
 foo :: T -> Int
 foo (T m n) = ... foo (T m' n') ...
 
 SpecConstr will never see the T because w/w will get rid of it. I'm still
 thinking about whether fixing this is worthwhile.
] 
[Generate INLINE pragmas for PA methods
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091203031452
 Ignore-this: 3435044aec2737ba58d269aeff915fbd
] 
[Add a GHC layout extension to the alternative layout rule
Ian Lynagh <igloo@earth.li>**20091203155708] 
[Fix HPC column numbers, following the column number changes in GHC
Ian Lynagh <igloo@earth.li>**20091203135520] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20091203132259] 
[Fix column numbers used when highlighting :list output
Ian Lynagh <igloo@earth.li>**20091203130328] 
[add a missing lock around allocGroup()
Simon Marlow <marlowsd@gmail.com>**20091203110209
 Ignore-this: 5898b3de4010e16789b628b004aa77db
] 
[remove unused cap->in_gc flag
Simon Marlow <marlowsd@gmail.com>**20091202154240
 Ignore-this: db2ef6c957c8d32233bbcc344e3c06b6
] 
[Refactoring only
Simon Marlow <marlowsd@gmail.com>**20091202123806
 Ignore-this: 95a93f6e330f2c609c197194412cac75
] 
[move sanity checking code from Storage.c to Sanity.c
Simon Marlow <marlowsd@gmail.com>**20091202121141
 Ignore-this: 216d434c3c3d2250effac22b37bc2b4d
] 
[stg_ap_0_fast: sanity-check only the topmost frame, not the whole stack
Simon Marlow <marlowsd@gmail.com>**20091202115109
 Ignore-this: ad45e07c26aa961913d367d7c53efb75
 Sanity checking was getting too slow in some cases, this returns it to
 a constant-factor overhead.
] 
[Fix profiling build
Simon Marlow <marlowsd@gmail.com>**20091203085930
 Ignore-this: ff3de527cbf7703e8bac4a48933cd8ba
] 
[More work on the simplifier's inlining strategies
simonpj@microsoft.com**20091202174256
 Ignore-this: 5840392a95d9a47f37c3074f7394f2c2
 
 This patch collects a small raft of related changes
 
 * Arrange that during 
      (a) rule matching and 
      (b) uses of exprIsConApp_maybe
   we "look through" unfoldings only if they are active
   in the phase. Doing this for (a) required a bit of 
   extra plumbing in the rule matching code, but I think
   it's worth it.
 
   One wrinkle is that even if inlining is off (in the 'gentle'
   phase of simplification) during rule matching we want to
   "look through" things with inlinings.  
    See SimplUtils.activeUnfInRule.
 
   This fixes a long-standing bug, where things that were
   supposed to be (say) NOINLINE, could still be poked into
   via exprIsConApp_maybe. 
 
 * In the above cases, also check for (non-rule) loop breakers; 
   we never look through these.  This fixes a bug that could make
   the simplifier diverge (and did for Roman).  
   Test = simplCore/should_compile/dfun-loop
 
 * Try harder not to choose a DFun as a loop breaker. This is 
   just a small adjustment in the OccurAnal scoring function
 
 * In the scoring function in OccurAnal, look at the InlineRule
   unfolding (if there is one) not the actual RHS, beause the
   former is what'll be inlined.  
 
 * Make the application of any function to dictionary arguments
   CONLIKE.  Thus (f d1 d2) is CONLIKE.  
   Encapsulated in CoreUtils.isExpandableApp
   Reason: see Note [Expandable overloadings] in CoreUtils
 
 * Make case expressions seem slightly smaller in CoreUnfold.
   This reverses an unexpected consequences of charging for
   alternatives.
 
 Refactorings
 ~~~~~~~~~~~~
 * Signficantly refactor the data type for Unfolding (again). 
   The result is much nicer.  
 
 * Add type synonym BasicTypes.CompilerPhase = Int
   and use it
 
 Many of the files touched by this patch are simply knock-on
 consequences of these two refactorings.
] 
[Fix Trac #3100: reifyType
simonpj@microsoft.com**20091130175204
 Ignore-this: ad1578c3d2e3da6128cd5052c8b64dc
 
 A type without any leading foralls may still have constraints
    eg:  ?x::Int => Int -> Int
 
 But reifyType was failing in this case.
 
 Merge to 6.12.
] 
[Fix Trac #3102: pre-matching polytypes
simonpj@microsoft.com**20091130174441
 Ignore-this: 3e3fa97e0de28b005a1aabe9e5542b32
 
 When *pre-matching* two types
      forall a. C1 => t1  ~  forall a. C2 => t2
 we were matching t1~t2, but totally ignoring C1,C2
 That's utterly wrong when pre-matching
        (?p::Int) => String  ~  a
 because we emerge with a:=String!
 
 All this is part of the impredicative story, which is about
 to go away, but still.
 
 Worth merging this to 6.12
] 
[threadStackUnderflow: put the new TSO on the mut list if necessary
Simon Marlow <marlowsd@gmail.com>**20091202144549
 Ignore-this: 839e7ad7893b3d7ea6481030ce7c6fe6
] 
[don't sanity check the whole stack when switching interp<->compiled
Simon Marlow <marlowsd@gmail.com>**20091202134121
 Ignore-this: 999b44d4dd096eceda81dda65f65a2df
] 
[fix to sanity checking for ThreadRelocated TSOs
Simon Marlow <marlowsd@gmail.com>**20091202134041
 Ignore-this: 52364f29041e6909b550956087649220
] 
[sanity check the top stack frame, not the whole stack
Simon Marlow <marlowsd@gmail.com>**20091202134020
 Ignore-this: c4c9b58c13299eecf7ec8cb79e34dc1f
] 
[Make allocatePinned use local storage, and other refactorings
Simon Marlow <marlowsd@gmail.com>**20091201160321
 Ignore-this: ec1334a9a5ec0de2567aa81d74b715ba
 
 This is a batch of refactoring to remove some of the GC's global
 state, as we move towards CPU-local GC.  
 
   - allocateLocal() now allocates large objects into the local
     nursery, rather than taking a global lock and allocating
     then in gen 0 step 0.
 
   - allocatePinned() was still allocating from global storage and
     taking a lock each time, now it uses local storage. 
     (mallocForeignPtrBytes should be faster with -threaded).
     
   - We had a gen 0 step 0, distinct from the nurseries, which are
     stored in a separate nurseries[] array.  This is slightly strange.
     I removed the g0s0 global that pointed to gen 0 step 0, and
     removed all uses of it.  I think now we don't use gen 0 step 0 at
     all, except possibly when there is only one generation.  Possibly
     more tidying up is needed here.
 
   - I removed the global allocate() function, and renamed
     allocateLocal() to allocate().
 
   - the alloc_blocks global is gone.  MAYBE_GC() and
     doYouWantToGC() now check the local nursery only.
] 
[Free full_prog_argv at exit, closing a memory leak
Simon Marlow <marlowsd@gmail.com>**20091201122801
 Ignore-this: 8fdb41e09bfc318821c427d2f22af737
] 
[free cap->saved_mut_lists too
Simon Marlow <marlowsd@gmail.com>**20091201113448
 Ignore-this: 973e1de140e104c126fe4a213791ba86
 fixes some memory leakage at shutdown
] 
[exitScheduler: move boundTaskExiting call outside #ifdef THREADED_RTS
Simon Marlow <marlowsd@gmail.com>**20091201113352
 Ignore-this: d913df43b14054f73c0fa06d0205952c
 Fixes a little leaked memory at shutdown in non-threaded RTS
] 
[Use dlltool from the in-tree mingw installation
Ian Lynagh <igloo@earth.li>**20091201190544
 We only use dlltool on Windows, and this way we don't require that
 the user has it installed.
] 
[Fix Commentary link in the HACKING file; trac #3706
Ian Lynagh <igloo@earth.li>**20091201150149] 
[Add an entry fo the ghci command :run to the user guide
Ian Lynagh <igloo@earth.li>**20091201173339] 
[Fix typo in docs
Ian Lynagh <igloo@earth.li>**20091201170550] 
[Delay expansion of some makefile variables until they are available
Ian Lynagh <igloo@earth.li>**20091201133609] 
[Call $(SED) rather than sed
Ian Lynagh <igloo@earth.li>**20091201131123] 
[Look for sed as gsed first
Ian Lynagh <igloo@earth.li>**20091201130741
 Solaris's sed apparently doesn't understand [:space:]
] 
[Avoid running empty for loops; fixes trac #3683
Ian Lynagh <igloo@earth.li>**20091201125927
 Solaris's sh gives
     /bin/sh: syntax error at line 1: `;' unexpected
 when faced with something like
     for x in ; do ...; done
 Patch from Christian Maeder.
] 
[Fix PS file generation
Simon Marlow <marlowsd@gmail.com>**20091201154254
 Ignore-this: 7b7122208e845b029a8b7215149fd203
 (the image doesn't work, but at least db2latex doesn't fall over)
] 
[Implement a new heap-tuning option: -H
Simon Marlow <marlowsd@gmail.com>**20091130151836
 Ignore-this: 2089b9dfaf6c095dc0460cef39e9d586
 
 -H alone causes the RTS to use a larger nursery, but without exceeding
 the amount of memory that the application is already using.  It trades
 off GC time against locality: the default setting is to use a
 fixed-size 512k nursery, but this is sometimes worse than using a very
 large nursery despite the worse locality.
 
 Not all programs get faster, but some programs that use large heaps do
 much better with -H.  e.g. this helps a lot with #3061 (binary-trees),
 though not as much as specifying -H<large>.  Typically using -H<large>
 is better than plain -H, because the runtime doesn't know ahead of
 time how much memory you want to use.
 
 Should -H be on by default?  I'm not sure, it makes some programs go
 slower, but others go faster.
] 
[Store a destination step in the block descriptor
Simon Marlow <marlowsd@gmail.com>**20091129164251
 Ignore-this: c406550acfe10141fcc38d3949d67490
 At the moment, this just saves a memory reference in the GC inner loop
 (worth a percent or two of GC time).  Later, it will hopefully let me
 experiment with partial steps, and simplifying the generation/step
 infrastructure.
] 
[Fix the prof_scc.png image in the profiling section (#3694)
Simon Marlow <marlowsd@gmail.com>**20091130132703
 Ignore-this: 9774bad70187274e3dd283d66703004
] 
[document 'recache' command in the help output (#3684)
Simon Marlow <marlowsd@gmail.com>**20091130122040
 Ignore-this: 95a51f76e66055af27cdfc7b5ad7deb3
] 
[Check whether the main function is actually exported (#414)
Simon Marlow <marlowsd@gmail.com>**20091130112327
 Ignore-this: 1afaa18d8c0c9e1d029531ac9d4865bb
] 
[Avoid using non-standard GNU tar option --force-local
Simon Marlow <marlowsd@gmail.com>**20091130112605
 Ignore-this: ac066722b15eb93e752d4f63391c9e3c
] 
[Reorder ALL_RTS_LIBS
Matthias Kilian <kili@outback.escape.de>**20091115175405
 Ignore-this: 795cfd5215ec73eea729aa2b3097817e
 
 ALL_RTS_LIBS is (ab)used for linking ghc when BootingFromHc=Yes,
 which needs libHSrtsmain.a before libHSrts.a.
 
] 
[Update dependencies
Ian Lynagh <igloo@earth.li>**20091129165534] 
[Follow Cabal changes
Ian Lynagh <igloo@earth.li>**20091129165141] 
[Tweak layout to work with alternative layout rule
Ian Lynagh <igloo@earth.li>**20091129163044] 
[Tweak the alternative layout rule: {} contains commas
Ian Lynagh <igloo@earth.li>**20091129155454] 
[Correct the advanceSrcLoc calculation for tabs
Ian Lynagh <igloo@earth.li>**20091129153933
 It was off-by-one
] 
[Tweak alternative layout rule
Ian Lynagh <igloo@earth.li>**20091129152323] 
[Make the alternative layout rule cope with file pragmas
Ian Lynagh <igloo@earth.li>**20091129145840] 
[Give more informative error messages
Ian Lynagh <igloo@earth.li>**20091129031029
 We used to just get
     ghc: panic! (the 'impossible' happened)
       (GHC version 6.13.20091128 for x86_64-unknown-linux):
         too few bytes. Failed reading at byte position 32753
 with no indication of what was being parsed.
] 
[Teach advanceSrcLoc about tab characters
Ian Lynagh <igloo@earth.li>**20091128151204] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20091128150731] 
[Columns now start at 1, as lines already did
Ian Lynagh <igloo@earth.li>**20091127224050
 Also corrected a couple of line 0's to line 1
] 
[Remove configure tests on tarballs that no longer exist
Ian Lynagh <igloo@earth.li>**20091127150101] 
[Implement non-decreasing do indentation in the alternative layout rule
Ian Lynagh <igloo@earth.li>**20091127011932] 
[add docs for Unicode entities in #2978
Simon Marlow <marlowsd@gmail.com>**20091125153649
 Ignore-this: f3d1561ef8f55606d9022ab7243e3800
] 
[Apply patch from #2978: add more Unicode syntax
Simon Marlow <marlowsd@gmail.com>**20090918130333
 Ignore-this: 1393009fdf2383ca43046ba0767a51e0
] 
[Use UTF-8 explicitly for InstalledPackageInfo
Simon Marlow <marlowsd@gmail.com>**20091125141730
 Ignore-this: 45be1506dd5c3339fb229a44aa958235
 So ghc-pkg register/update takes input in UTF-8, and ghc-pkg dump
 outputs in UTF-8.  Textual package config files in the package DB are
 assumed to be in UTF-8.
] 
[Comments only, esp about RecStmts
simonpj@microsoft.com**20091126163241
 Ignore-this: 6fb05bd70b1d0cbb55fb01cf1f17ea77
] 
[Fix a bug in alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125231901] 
[Fix a bug in alternative layout
Ian Lynagh <igloo@earth.li>**20091125230616
 And make the code simpler in the process!
] 
[Bug fix for alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125205809] 
[Tweak alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125193854] 
[Add unboxed parentheses to the alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125182421] 
[Tweak the warning suppression flags used in Lexer
Ian Lynagh <igloo@earth.li>**20091125171815] 
[Implement the alternative layout rule
Ian Lynagh <igloo@earth.li>**20091125171656
 Caution: Largely untested
] 
[Fix some warning in Lexer
Ian Lynagh <igloo@earth.li>**20091124233726] 
[threadStackOverflow: check whether stack squeezing released some stack (#3677)
Simon Marlow <marlowsd@gmail.com>**20091125125917
 Ignore-this: d35089eb93f5b367b7d1c445bda79232
 
 In a stack overflow situation, stack squeezing may reduce the stack
 size, but we don't know whether it has been reduced enough for the
 stack check to succeed if we try again.  Fortunately stack squeezing
 is idempotent, so all we need to do is record whether *any* squeezing
 happened.  If we are at the stack's absolute -K limit, and stack
 squeezing happened, then we try running the thread again.
 
 We also want to avoid enlarging the stack if squeezing has already
 released some of it.  However, we don't want to get into a
 pathalogical situation where a thread has a nearly full stack (near
 its current limit, but not near the absolute -K limit), keeps
 allocating a little bit, squeezing removes a little bit, and then it
 runs again.  So to avoid this, if we squeezed *and* there is still
 less than BLOCK_SIZE_W words free, then we enlarge the stack anyway.
] 
[add a comment to TSO_MARKED
Simon Marlow <marlowsd@gmail.com>**20091125104954
 Ignore-this: 7111281a443533dc453dbf9481dba519
] 
[Pass --no-user-package-conf to ghc-pkg in bindisttest
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091125115953] 
[Add a note saying what Haddock relies on about Instance.is_dfun
David Waern <david.waern@gmail.com>**20091124210308] 
[Treat () as an enumeration tycon
Ian Lynagh <igloo@earth.li>**20091124011313
 This fixes deriving Ord (), which previously failed with
   ghc-stage1: panic! (the 'impossible' happened)
     (GHC version 6.13.20091123 for x86_64-unknown-linux):
           TcGenDeriv:mk_FunBind
] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20091124003221] 
[inline has moved to GHC.Magic
Ian Lynagh <igloo@earth.li>**20091123200308] 
[Use the ghc-perl tarball on Windows, instead of the msys one
Ian Lynagh <igloo@earth.li>**20091120153953] 
[Install perl on Windows
Ian Lynagh <igloo@earth.li>**20091120223830] 
[Remove cprAnalysis directory from hs-source-dirs
simonpj@microsoft.com**20091120161911
 Ignore-this: e7d3707794979e45b43136137c939af1
] 
[Remove -fasm from mk/validate-settings.mk
Ian Lynagh <igloo@earth.li>**20091120125656
 Makes it easier to do unregisterised validate runs
] 
[Fix some dependencies in bindists
Ian Lynagh <igloo@earth.li>**20091120125342
 We can't depend on sources in a bindist, because we don't have the sources.
] 
[Add a rule to allow us to sdist libraries easily
Ian Lynagh <igloo@earth.li>**20091119160527] 
[Check upper/lower bounds on various RTS flags (#3633)
Simon Marlow <marlowsd@gmail.com>**20091119142422
 Ignore-this: 8cbbb3f0f2c46711967491d5c028a410
 
 Also, make K mean 1024 rather than 1000, in RTS flags (similarly for M
 and G).  The main reason I want to change it is that otherwise this
 might be confusing:
   
 exp3_8: error in RTS option -H4k: size outside allowed range (4096 - 18446744073709551615)
 
 And I think the original reason for using 1000 instead of 1024,
 worries about direct-mapped caches, is not an issue in this context
 (even if you can find a direct-mapped cache these days).
] 
[define HS_WORD_MAX
Simon Marlow <marlowsd@gmail.com>**20091119140143
 Ignore-this: ed27e7c7ac0bd03cddcd745ae7053a74
] 
[Print the prog name in errorBelch() even if prog_argv is not set yet
Simon Marlow <marlowsd@gmail.com>**20091119135230
 Ignore-this: ec42e7a4f344ebc34befddfc3d74a946
 This means we get the prog name in error messages from the flag parser
] 
[Remove dead code
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091112070455
 Ignore-this: d30b668cb3c396fe21e5e4cd9b8be151
] 
[Remove the (very) old strictness analyser
simonpj@microsoft.com**20091119154347
 Ignore-this: 5d49f66b0baad989ca66c53fde8f2d23
 
 I finally got tired of the #ifdef OLD_STRICTNESS stuff.  I had been
 keeping it around in the hope of doing old-to-new comparisions, but
 have failed to do so for many years, so I don't think it's going to
 happen.  This patch deletes the clutter.
] 
[Make INLINE warning more precise
simonpj@microsoft.com**20091119132711
 Ignore-this: f1494494f37c5e618e639912ff82a7f5
] 
[Implement -fexpose-all-unfoldings, and fix a non-termination bug
simonpj@microsoft.com**20091119125711
 Ignore-this: 54d029014659959151d1681842210cde
 
 The -fexpose-all-unfoldings flag arranges to put unfoldings for *everything*
 in the interface file.  Of course,  this makes the file a lot bigger, but
 it also makes it complete, and that's great for supercompilation; or indeed
 any whole-program work.
 
 Consequences:
   * Interface files need to record loop-breaker-hood.  (Previously,
     loop breakers were never exposed, so that info wasn't necessary.)
     Hence a small interface file format change. 
 
   * When inlining, must check loop-breaker-hood. (Previously, loop
     breakers didn't have an unfolding at all, so no need to check.)
 
   * Ditto in exprIsConApp_maybe.  Roman actually tripped this bug, 
     because a DFun, which had an unfolding, was also a loop breaker
 
   * TidyPgm.tidyIdInfo must be careful to preserve loop-breaker-hood
 
 So Id.idUnfolding checks for loop-breaker-hood and returns NoUnfolding
 if so. When you want the unfolding regardless of loop-breaker-hood, 
 use Id.realIdUnfolding.
 
 I have not documented the flag yet, because it's experimental.  Nor
 have I tested it thoroughly.  But with the flag off (the normal case)
 everything should work.
] 
[Re-implement the binder-swap stuff in OccurAnal
simonpj@microsoft.com**20091119124524
 Ignore-this: 662ed559e161be958b1eff1a49d750a3
 
 This is a pretty big patch, but it has a very local effect.
 It affects only the binder-swap mechanism in OccurAnal, which
 was not working well becuase it's more subtle than I'd realised
 (See Note [getProxies is subtle]).  I think this does a much
 better job.
] 
[Try harder not to make DFuns into loop breakers
simonpj@microsoft.com**20091119124127
 Ignore-this: 922d9a2b3406a3dbbfc5a42d1a286e2a
 
 See Note [DFuns should not be loop breakers]
] 
[Extend the GHCi FAQ slightly
simonpj@microsoft.com**20091117132308
 Ignore-this: 8257aaf06ff32904a91121a0734d1c4
] 
[Add gnutar to the list of names we use when looking for GNU tar
Ian Lynagh <igloo@earth.li>**20091119144927] 
[Add support for the man page to the new build system
Ian Lynagh <igloo@earth.li>**20091119140811] 
[Refactor case-merging and identical-alternative optimisations
simonpj@microsoft.com**20091119123704
 Ignore-this: db12d31395ed99c2341cc4d7d5dca1e
 
 These two optimisations were originally done by SimplUtils.mkCase
 *after* all the pieces have been simplified.  Some while ago I
 moved them *before*, so they were done by SimplUtils.prepareAlts.
 It think the reason was that I couldn't rely on the dead-binder 
 information on OutIds, and that info is useful in these optimisations.
 
 However, 
  (a) Other changes (notably moving case-binder-swap to OccurAnal)
      have meant that dead-binder information is accurate in 
      OutIds
 
  (b) When there is a cascade of case-merges, they happen in 
      one sweep if you do it after, but in many sweeps if you
      do it before.  Reason: doing it after means you are looking
      at nice simplified Core.
] 
[Fix a nasty infelicity in the size computation of CoreUnfold
simonpj@microsoft.com**20091119115736
 Ignore-this: ecff5289ab14c0df572135bf0b5179d6
 
 The size computation was treating gigantic case expressions as
 practically free, which they really aren't.  It was exacerbated by
 recent decisions to charge 0 for naked variables and constructors, so
 the RHS of the case might look free too.  A good example was 
 Foreign.C.Error.errnoToIOError, which hsa lots of join points
 that were getting inlined way to vigorously, so we had:
 
   *** Simplifier Phase 2 [main]:
       Result size = 2983
   *** Core Linted result of Simplifier mode 2 [main], iteration 1 out of 4:
       Result size = 640327
   *** Core Linted result of Simplifier mode 2 [main], iteration 2 out of 4:
       Result size = 1659
 
 Notice that gigantic intermediate!
 
 This patch adds a small charge for each *alternative*.  Of course,
 that'll also mean that there's a bit less inling of things involving
 case expressions.
] 
[Comments and white space only
simonpj@microsoft.com**20091119115122
 Ignore-this: dc8f9a72d6d57378d83154877b1d1126
] 
[Fix splitAppTys
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20091119102639
 Ignore-this: e669950c7d151c8a67910cd4bbac9cd6
] 
[Windows DLLs: Slurp across the actually static version of libffi
Ben.Lippmeier@anu.edu.au**20091119000239] 
[Windows DLLs: Don't rely on stg/DLL.h being included in RtsAPI.h
Ben.Lippmeier@anu.edu.au**20091118110548
 Ignore-this: 7dce0ede283974d7834fe12af3f71bd5
] 
[Fix warnings about unused imports
Ben.Lippmeier@anu.edu.au**20091118110525
 Ignore-this: 93841770eadabf5bd3b9f859ca2de7eb
] 
[Windows DLLs: stifle more warnings about auto imported symbols
Ben.Lippmeier@anu.edu.au**20091118090105] 
[Windows DLLs: stifle warnings about symbols being auto imported from DLLs
Ben.Lippmeier@anu.edu.au**20091118051526] 
[Windows DLLs: add #ifdefery to turn off DLL import of libffi when building statically.
Ben.Lippmeier@anu.edu.au**20091118043901] 
[Windows DLLs: disable extra shutdownHaskell() when unloading the RTS DLL
Ben.Lippmeier@anu.edu.au**20091117050648] 
[Windows DLLs: remove dup symbol from def file
Ben.Lippmeier@anu.edu.au**20091117043851] 
[Use opt_PIC not #defined __PIC__ in compiler source.
Ben.Lippmeier@anu.edu.au**20091117043716] 
[Windows DLLs: CHARLIKE_closure and INTLIKE_closure aren't defined in this way.
Ben.Lippmeier@anu.edu.au**20091114063240] 
[If a comment says "Is this correct?", it's not.
Ben.Lippmeier@anu.edu.au**20091114063157] 
[Windows DLLs: gmp is in the integer-gmp package now.
Ben.Lippmeier@anu.edu.au**20091114063046] 
[Use DLL aware runIO_closure instead of base_GHCziTopHandler_runIO_closure directly
Ben.Lippmeier@anu.edu.au**20091114061559] 
[RTS also uses runSparks_closure from base
Ben.Lippmeier@anu.edu.au**20091114061445] 
[Provide extralibs when linking Windows DLLs
Ben.Lippmeier@anu.edu.au**20091114061109] 
[Don't share low valued Int and Char closures with Windows DLLs
Ben.Lippmeier@anu.edu.au**20091114060455] 
[Windows DLLs: use one import lib for each DLL the RTS needs.
Ben.Lippmeier@anu.edu.au**20091111014821] 
[Add autoconf code to locate dlltool on Windows
Ben.Lippmeier@anu.edu.au**20091110051257] 
[Break recursive imports between the RTS and base library on Windows.
Ben.Lippmeier@anu.edu.au**20091106062732
 
 The file rts/win32/libHSbase.def contains a list of all the 
 symbols from the base library that the RTS needs. 
 
 When building the RTS into a DLL on Windows, we want to link the DLL
 for the RTS before we link the DLL for the base library. We use 
 libHSbase.def to make the "import library" libHSbase.so.a, which 
 contains stubs for each of the symbols from the base library that
 the RTS needs.
] 
[Add the msysCORE*.tar.gz tarball to the list of tarballs we unpack
Ian Lynagh <igloo@earth.li>**20091118195523] 
[Put the libffi files to be installed into a dist directory
Ian Lynagh <igloo@earth.li>**20091118150508
 This meakes it easier to correctly clean libffi
] 
[Add ghc-tarballs to the list of directories that go into an sdist
Ian Lynagh <igloo@earth.li>**20091118131047] 
[Remove redundant libffi/tarball directory
Ian Lynagh <igloo@earth.li>**20091118124102
 We now use the tarball in the ghc-tarballs repo
] 
[Fix gen_contents_index on MSYS
Ian Lynagh <igloo@earth.li>**20091117223556
 On MSYS
     sed 's/.*[ \t]//'
 wasn't matching
     version:<tab>1.0
 so I've switched to
     's/.*[[:space:]]//'
 which works on Linux, cygwin and MSYS.
] 
[include the GHC package docs in a bindist
Simon Marlow <marlowsd@gmail.com>**20091117151133
 Ignore-this: c4a10221b1a2a4778494018bca7d2169
] 
[exclude some haddock-related rules during BINDIST
Simon Marlow <marlowsd@gmail.com>**20091117151123
 Ignore-this: 20b4194b26766d6ab701683af520a7d4
] 
[Add an install-docs target that emits a helpful diagnostic (#3662)
Simon Marlow <marlowsd@gmail.com>**20091116120137
 Ignore-this: 1c5414730614b205c67919f3ea363c00
] 
[fix install_docs dependencies, and add a missing $(INSTALL_DIR)
Simon Marlow <marlowsd@gmail.com>**20091116115630
 Ignore-this: 21230df54e79f12f61e9c82a0ae02fad
] 
[Tweak to the directory-building rule
Simon Marlow <marlowsd@gmail.com>**20091113125719
 Ignore-this: b9e1fe6bcbfd4ff56905517f32b646f7
 So we don't try to recreate directories just because they are older
 than mkdirhier, since mkdirhier won't touch them.
] 
[exprIsHNF should "look through" lets
simonpj@microsoft.com**20091117125526
 Ignore-this: 3e77d029c0f314c53171f0378939b496
 
 I can't quite remember when I spotted this, but exprIsHNF (and
 similarly exprIsConLike) should ignore enclosing let-bindings,
 since they don't affect termination.
] 
[Improvement to typecheck higher-rank rules better
simonpj@microsoft.com**20091117125417
 Ignore-this: c5791cbe9540376b9ff46e2a6563bcc2
 
 See Note [Typechecking rules] in TcRules.  
 Suggested by Roman
] 
[Apply RULES to simplified arguments
simonpj@microsoft.com**20091117104437
 Ignore-this: 9a3475a9871f45ffa115dec44e376e3c
 
 See Note [RULEs apply to simplified arguments] in Simplify.lhs
 A knock-on effect is that rules apply *after* we try inlining
 (which uses un-simplified arguments), but that seems fine.
] 
[Improvements to pretty-printing of Core
simonpj@microsoft.com**20091117103626
 Ignore-this: ad386865644b4dbcd98adab409d7c523
] 
[Fix formatting of module deprecation/warning messages
Duncan Coutts <duncan@well-typed.com>**20091115155617
 Ignore-this: a41444bdda003aee4412eb56a0e7d052
 It was accidentally using list syntax. Fixes #3303 again.
] 
[Wibble to comment
simonpj@microsoft.com**20091113145944
 Ignore-this: 730f7cad452ac96d59ee2e74a855c19d
] 
[TAG 2009-11-15
Ian Lynagh <igloo@earth.li>**20091115155059] 
Patch bundle hash:
5957932fc762a36aee3d2f81b787371222260dfe