Ticket #885: fix-windows-DEP-violations-bug-885.dpatch

New patches:

[Fix Windows DEP violations (bug #885)
brianlsmith@gmail.com**20061007060621] 
<
> {
hunk ./compiler/ghci/ByteCodeFFI.lhs 7
 \section[ByteCodeGen]{Generate machine-code sequences for foreign import}
 
 \begin{code}
-module ByteCodeFFI ( mkMarshalCode, moan64 ) where
+module ByteCodeFFI ( mkMarshalCode, moan64, newExec ) where
 
 #include "HsVersions.h"
 
hunk ./compiler/ghci/ByteCodeFFI.lhs 20
 -- there is ifdeffery below
 import Control.Exception ( throwDyn )
 import DATA_BITS       ( Bits(..), shiftR, shiftL )
-import Foreign         ( newArray )
 import Data.List        ( mapAccumL )
 
 import DATA_WORD       ( Word8, Word32 )
hunk ./compiler/ghci/ByteCodeFFI.lhs 23
-import Foreign         ( Ptr )
+import Foreign         ( Ptr, FunPtr, castPtrToFunPtr,
+                         Storable, sizeOf, pokeArray )
+import Foreign.C       ( CUInt )
 import System.IO.Unsafe ( unsafePerformIO )
 import IO              ( hPutStrLn, stderr )
 -- import Debug.Trace  ( trace )
hunk ./compiler/ghci/ByteCodeFFI.lhs 74
 -}
 mkMarshalCode :: CCallConv
               -> (Int, CgRep) -> Int -> [(Int, CgRep)] 
-              -> IO (Ptr Word8)
+              -> IO (FunPtr ())
 mkMarshalCode cconv (r_offW, r_rep) addr_offW arg_offs_n_reps
    = let bytes = mkMarshalCode_wrk cconv (r_offW, r_rep) 
                                    addr_offW arg_offs_n_reps
hunk ./compiler/ghci/ByteCodeFFI.lhs 78
-     in  Foreign.newArray bytes
-
+     in  newExec bytes
 
hunk ./compiler/ghci/ByteCodeFFI.lhs 80
+newExec :: Storable a => [a] -> IO (FunPtr ())
+newExec code
+   = do ptr <- _allocateExec (fromIntegral $ codeSize undefined code)
+        pokeArray ptr code
+        return (castPtrToFunPtr ptr)
+   where
+   codeSize :: Storable a => a -> [a] -> Int
+   codeSize dummy array = sizeOf(dummy) * length array
 
hunk ./compiler/ghci/ByteCodeFFI.lhs 89
+foreign import ccall unsafe "allocateExec"
+  _allocateExec :: CUInt -> IO (Ptr a)  
 
 mkMarshalCode_wrk :: CCallConv 
                   -> (Int, CgRep) -> Int -> [(Int, CgRep)] 
hunk ./compiler/ghci/ByteCodeGen.lhs 12
 #include "HsVersions.h"
 
 import ByteCodeInstr
+import ByteCodeItbls   ( ItblPtr(..) )
 import ByteCodeFFI     ( mkMarshalCode, moan64 )
 import ByteCodeAsm     ( CompiledByteCode(..), UnlinkedBCO, 
                          assembleBCO, assembleBCOs, iNTERP_STACK_CHECK_THRESH )
hunk ./compiler/ghci/ByteCodeGen.lhs 58
 
 import Data.List       ( intersperse, sortBy, zip4, zip6, partition )
 import Foreign         ( Ptr, castPtr, mallocBytes, pokeByteOff, Word8,
-                         withForeignPtr )
+                         withForeignPtr, castFunPtrToPtr )
 import Foreign.C       ( CInt )
 import Control.Exception       ( throwDyn )
 
hunk ./compiler/ghci/ByteCodeGen.lhs 148
    -> Int
    -> [StgWord]
    -> Bool     -- True <=> is a return point, rather than a function
-   -> [Ptr ()]
+   -> [BcPtr]
    -> ProtoBCO name
 mkProtoBCO nm instrs_ordlist origin arity bitmap_size bitmap
   is_ret mallocd_blocks
hunk ./compiler/ghci/ByteCodeGen.lhs 923
          ioToBc (mkMarshalCode cconv
                     (r_offW, r_rep) addr_offW
                     (zip args_offW a_reps))    `thenBc` \ addr_of_marshaller ->
-         recordMallocBc addr_of_marshaller     `thenBc_`
+         recordItblMallocBc (ItblPtr (castFunPtrToPtr addr_of_marshaller)) `thenBc_`
      let
         -- Offset of the next stack frame down the stack.  The CCALL
         -- instruction needs to describe the chunk of stack containing
hunk ./compiler/ghci/ByteCodeGen.lhs 932
         stk_offset   = d_after_r - s
 
          -- do the call
-         do_call      = unitOL (CCALL stk_offset (castPtr addr_of_marshaller))
+         do_call      = unitOL (CCALL stk_offset (castFunPtrToPtr addr_of_marshaller))
          -- slide and return
          wrapup       = mkSLIDE r_sizeW (d_after_r - r_sizeW - s)
                         `snocOL` RETURN_UBX r_rep
hunk ./compiler/ghci/ByteCodeGen.lhs 1099
                            -- to be on the safe side we copy the string into
                            -- a malloc'd area of memory.
                                 ioToBc (mallocBytes (n+1)) `thenBc` \ ptr ->
-                                recordMallocBc ptr         `thenBc_`
+                                recordMallocBc ptr `thenBc_`
                                 ioToBc (
                                    withForeignPtr fp $ \p -> do
                                      memcpy ptr p (fromIntegral n)
hunk ./compiler/ghci/ByteCodeGen.lhs 1305
 -- -----------------------------------------------------------------------------
 -- The bytecode generator's monad
 
+type BcPtr = Either ItblPtr (Ptr ())
+
 data BcM_State 
    = BcM_State { 
        nextlabel :: Int,               -- for generating local labels
hunk ./compiler/ghci/ByteCodeGen.lhs 1310
-       malloced  :: [Ptr ()] }         -- ptrs malloced for current BCO
+       malloced  :: [BcPtr] }          -- thunks malloced for current BCO
                                        -- Should be free()d when it is GCd
 
 newtype BcM r = BcM (BcM_State -> IO (BcM_State, r))
hunk ./compiler/ghci/ByteCodeGen.lhs 1344
   (>>)  = thenBc_
   return = returnBc
 
-emitBc :: ([Ptr ()] -> ProtoBCO Name) -> BcM (ProtoBCO Name)
+emitBc :: ([BcPtr] -> ProtoBCO Name) -> BcM (ProtoBCO Name)
 emitBc bco
   = BcM $ \st -> return (st{malloced=[]}, bco (malloced st))
 
hunk ./compiler/ghci/ByteCodeGen.lhs 1350
 recordMallocBc :: Ptr a -> BcM ()
 recordMallocBc a
-  = BcM $ \st -> return (st{malloced = castPtr a : malloced st}, ())
+  = BcM $ \st -> return (st{malloced = Right (castPtr a) : malloced st}, ())
+
+recordItblMallocBc :: ItblPtr -> BcM ()
+recordItblMallocBc a
+  = BcM $ \st -> return (st{malloced = Left a : malloced st}, ())
 
 getLabelBc :: BcM Int
 getLabelBc
hunk ./compiler/ghci/ByteCodeInstr.lhs 14
 #include "HsVersions.h"
 #include "../includes/MachDeps.h"
 
+import ByteCodeItbls   ( ItblPtr )
+
 import Outputable
 import Name            ( Name )
 import Id              ( Id )
hunk ./compiler/ghci/ByteCodeInstr.lhs 42
        -- what the BCO came from
        protoBCOExpr       :: Either  [AnnAlt Id VarSet] (AnnExpr Id VarSet),
        -- malloc'd pointers
-        protoBCOPtrs       :: [Ptr ()]
+        protoBCOPtrs       :: [Either ItblPtr (Ptr ())]
    }
 
 type LocalLabel = Int
hunk ./compiler/ghci/ByteCodeItbls.lhs 10
 
 {-# OPTIONS -optc-DNON_POSIX_SOURCE #-}
 
-module ByteCodeItbls ( ItblEnv, ItblPtr, mkITbls ) where
+module ByteCodeItbls ( ItblEnv, ItblPtr(..), itblCode, mkITbls ) where
 
 #include "HsVersions.h"
 
hunk ./compiler/ghci/ByteCodeItbls.lhs 14
+import ByteCodeFFI     ( newExec )
 import Name            ( Name, getName )
 import NameEnv
 import SMRep           ( typeCgRep )
hunk ./compiler/ghci/ByteCodeItbls.lhs 26
 import Util             ( lengthIs, listLengthCmp )
 
 import Foreign
-import Foreign.C
 import DATA_BITS       ( Bits(..), shiftR )
 
 import GHC.Exts                ( Int(I#), addr2Int# )
hunk ./compiler/ghci/ByteCodeItbls.lhs 43
 %************************************************************************
 
 \begin{code}
-type ItblPtr = Ptr StgInfoTable
+newtype ItblPtr = ItblPtr (Ptr ()) deriving Show
+
+itblCode :: ItblPtr -> Ptr ()
+itblCode (ItblPtr ptr)
+   = (castPtr ptr) `plusPtr` (wORD_SIZE * 2)
+
 type ItblEnv = NameEnv (Name, ItblPtr)
        -- We need the Name in the range so we know which
        -- elements to filter out when unloading a module
hunk ./compiler/ghci/ByteCodeItbls.lhs 115
                  -- This is the only arch-dependent bit.
                  code = mkJumpToAddr entry_addr
              in
-                 do addr <- malloc_exec (sizeOf itbl)
+                 do addr <- newExec [itbl]
                     --putStrLn ("SIZE of itbl is " ++ show (sizeOf itbl))
                     --putStrLn ("# ptrs  of itbl is " ++ show ptrs)
                     --putStrLn ("# nptrs of itbl is " ++ show nptrs_really)
hunk ./compiler/ghci/ByteCodeItbls.lhs 119
-                    poke addr itbl
-                    return (getName dcon, addr `plusPtr` (2 * wORD_SIZE))
+                    return (getName dcon, ItblPtr (castFunPtrToPtr addr))
 
 
 -- Make code which causes a jump to the given address.  This is the
hunk ./compiler/ghci/ByteCodeItbls.lhs 364
 load = do addr <- advance
           lift (peek addr)
 
-foreign import ccall unsafe "allocateExec"
-  _allocateExec :: CUInt -> IO (Ptr a)
-
-malloc_exec :: Int -> IO (Ptr a)
-malloc_exec bytes = _allocateExec (fromIntegral bytes)
-
 \end{code}
hunk ./compiler/ghci/ByteCodeLink.lhs 18
 
 #include "HsVersions.h"
 
-import ByteCodeItbls   ( ItblEnv, ItblPtr )
+import ByteCodeItbls   ( ItblEnv, ItblPtr, itblCode )
 import ByteCodeAsm     ( UnlinkedBCO(..), BCOPtr(..), sizeSS, ssElts )
 import ObjLink         ( lookupSymbol )
 
hunk ./compiler/ghci/ByteCodeLink.lhs 51
 
 import GHC.Arr         ( Array(..) )
 import GHC.IOBase      ( IO(..) )
-import GHC.Ptr         ( Ptr(..) )
+import GHC.Ptr         ( Ptr(..), castPtr )
 import GHC.Base                ( writeArray#, RealWorld, Int(..) )
 \end{code}
 
hunk ./compiler/ghci/ByteCodeLink.lhs 129
             ptrs_parr = case ptrs_arr of Array lo hi parr -> parr
 
             itbls_arr = listArray (0, n_itbls-1) linked_itbls
-                        :: UArray Int ItblPtr
+
             itbls_barr = case itbls_arr of UArray lo hi barr -> barr
 
             literals_arr = listArray (0, n_literals-1) linked_literals
hunk ./compiler/ghci/ByteCodeLink.lhs 227
 lookupIE :: ItblEnv -> Name -> IO (Ptr a)
 lookupIE ie con_nm 
    = case lookupNameEnv ie con_nm of
-        Just (_, Ptr a) -> return (Ptr a)
+        Just (_, a) -> return (castPtr (itblCode a))
         Nothing
            -> do -- try looking up in the object files.
                  let sym_to_find1 = nameToCLabel con_nm "con_info"
hunk ./rts/Linker.c 13
 #include "PosixSource.h"
 #endif
 
-/* Linux needs _GNU_SOURCE to get RTLD_DEFAULT from <dlfcn.h> and 
+/* Linux needs _GNU_SOURCE to get RTLD_DEFAULT from <dlfcn.h> and
    MREMAP_MAYMOVE from <sys/mman.h>.
  */
 #ifdef __linux__
hunk ./rts/Linker.c 1253
    void *map_addr = NULL;
 #else
    FILE *f;
-   int misalignment;
 #endif
    initLinker();
 
hunk ./rts/Linker.c 1258
    /* debugBelch("loadObj %s\n", path ); */
 
-   /* Check that we haven't already loaded this object. 
+   /* Check that we haven't already loaded this object.
       Ignore requests to load multiple times */
    {
        ObjectCode *o;
hunk ./rts/Linker.c 1348
 #define EXTRA_MAP_FLAGS 0
 #endif
 
-   oc->image = mmap(map_addr, n, PROT_EXEC|PROT_READ|PROT_WRITE, 
+   oc->image = mmap(map_addr, n, PROT_EXEC|PROT_READ|PROT_WRITE,
                    MAP_PRIVATE|EXTRA_MAP_FLAGS, fd, 0);
    if (oc->image == MAP_FAILED)
       barf("loadObj: can't map `%s'", path);
hunk ./rts/Linker.c 1362
    if (!f)
        barf("loadObj: can't read `%s'", path);
 
-#ifdef darwin_HOST_OS
+#   if defined(mingw32_HOST_OS)
+       // TODO: We would like to use allocateExec here, but allocateExec
+       //       cannot currently allocate blocks large enough.
+    oc->image = VirtualAlloc(NULL, oc->fileSize, MEM_RESERVE | MEM_COMMIT,
+                             PAGE_EXECUTE_READWRITE);
+#   elif defined(darwin_HOST_OS)
     // In a Mach-O .o file, all sections can and will be misaligned
     // if the total size of the headers is not a multiple of the
     // desired alignment. This is fine for .o files that only serve
hunk ./rts/Linker.c 1377
     // We calculate the correct alignment from the header before
     // reading the file, and then we misalign oc->image on purpose so
     // that the actual sections end up aligned again.
-   misalignment = machoGetMisalignment(f);
-   oc->misalignment = misalignment;
-#else
-   misalignment = 0;
-#endif
-
+   oc->misalignment = machoGetMisalignment(f);
    oc->image = stgMallocBytes(oc->fileSize + misalignment, "loadObj(image)");
hunk ./rts/Linker.c 1379
-   oc->image += misalignment;
-   
+#  else
+   oc->image = stgMallocBytes(oc->fileSize, "loadObj(image)");
+#  endif
+
    n = fread ( oc->image, 1, oc->fileSize, f );
    if (n != oc->fileSize)
       barf("loadObj: error whilst reading `%s'", path);
hunk ./rts/Linker.c 1495
                prev->next = oc->next;
            }
 
-           /* We're going to leave this in place, in case there are
-              any pointers from the heap into it: */
-           /* stgFree(oc->image); */
+           // We're going to leave this in place, in case there are
+           // any pointers from the heap into it:
+               // #ifdef mingw32_HOST_OS
+               //  VirtualFree(oc->image);
+               // #else
+           //  stgFree(oc->image);
+           // #endif
            stgFree(oc->fileName);
            stgFree(oc->symbols);
            stgFree(oc->sections);
hunk ./rts/Linker.c 1576
 
 /*
   ocAllocateJumpIslands
-  
+
   Allocate additional space at the end of the object file image to make room
   for jump islands.
   
hunk ./rts/Storage.c 995
    in the page, and when the page is emptied (all objects on the page
    are free) we free the page again, not forgetting to make it
    non-executable.
+
+   TODO: The inability to handle objects bigger than BLOCK_SIZE_W means that
+         the linker cannot use allocateExec for loading object code files
+         on Windows. Once allocateExec can handle larger objects, the linker
+         should be modified to use allocateExec instead of VirtualAlloc.
    ------------------------------------------------------------------------- */
 
 static bdescr *exec_block;
}

Context:

[remove unused origPkgIdMap field from PackageState
Simon Marlow <simonmar@microsoft.com>**20061006105148] 
[Fix _module_registered bug for sparc linux.
Simon Marlow <simonmar@microsoft.com>**20061006104534
 Patch by Ferris McCormick <fmccor@gentoo.org>
 This patch has been tested with GHC-6.4.2 where it fixes a
 huge number of testsuite failures (down from 406 to 17)
] 
[Cache the package database the first time it is read
Simon Marlow <simonmar@microsoft.com>**20061006104221
 This was a slight oversight on my part, I intended to store the
 pristine database in the pkgDatabase of DynFlags, but managed to
 forget to do it.
] 
[Improve the correlation betweens documented and existent options
Ian Lynagh <igloo@earth.li>**20061003220354] 
[Document -dfaststring-stats
Ian Lynagh <igloo@earth.li>**20061003154147] 
[Rearrange docs to have all the -ddump-* options together
Ian Lynagh <igloo@earth.li>**20061003153422] 
[Remove unused option -femit-extern-decls
Ian Lynagh <igloo@earth.li>**20061003145854] 
[Documentation updates
Ian Lynagh <igloo@earth.li>**20061003142658] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20061003121926] 
[MERGE: Improve unification error messages (again) (push to 6.6 branch)
Ian Lynagh <igloo@earth.li>**20061001011202] 
[Latin-1-to-UTF8 pre-processor example for docs from Christian Maeder
Ian Lynagh <igloo@earth.li>**20061001010700] 
[Amplify scoped tyvar changes
simonpj@microsoft.com**20060929165038] 
[Update release notes
simonpj@microsoft.com**20060929122855] 
[Remove casts from lvalues to allow compilation under GCC 4.0
brianlsmith@gmail.com**20060929185931] 
[rejig library include/ files
sof@galois.com**20060929225751] 
[add :edit to the release notes, and improve the docs a bit
Simon Marlow <simonmar@microsoft.com>**20060929112108] 
[:edit runs notepad by default on Windows
Simon Marlow <simonmar@microsoft.com>**20060929102739] 
[unbreak :edit patch on Windows
Simon Marlow <simonmar@microsoft.com>**20060928155951] 
[Fix #906, and do #914 while I'm in here (it wasn't too hard)
Simon Marlow <simonmar@microsoft.com>**20060928151705] 
[Add basic :edit support
Simon Marlow <simonmar@microsoft.com>**20060928135156
 Without jumping to line numbers or %-expansion, we could add that later.
] 
[tiny fix in porting docs I just spotted
Simon Marlow <simonmar@microsoft.com>**20060928105611] 
[only make stdin/stdout unbuffered in GHCi, not runghc or ghc -e.
Simon Marlow <simonmar@microsoft.com>**20060928105403] 
[testsuite *is* boring
Simon Marlow <simonmar@microsoft.com>**20060928105342] 
[Fix mulIntMayOflo on 64-bit arches; fixes trac #867
Ian Lynagh <igloo@earth.li>**20060928004806
 We were assuming we could multiply 2 32-bit numbers without overflowing
 a 64-bit number, but we can't as the top bit is the sign bit.
] 
[Handle clock_gettime failing
Ian Lynagh <igloo@earth.li>**20060927234630] 
[fix typo in comment
Andres Loeh <mail@andres-loeh.de>**20060914235648] 
[remove non-boring directories
Norman Ramsey <nr@eecs.harvard.edu>**20060915234902] 
[Modify toArgs to parse quotes/escapes like /bin/sh
rjmccall@gmail.com**20060917003641
 Addresses ticket #197, which asks for escape sequences to be supported directly (i.e.
 not only in dquoted strings) on :load commands in GHCI.  Fix modifies the toArgs
 function to parse its input like /bin/sh does, i.e. recognizing escapes anywhere
 and treating quoted strings as atomic chunks.  Thus:
   :load a\ b c\"d e" "f
 would parse with three arguments, namely 'a b', 'c"d', and 'e f'.
 
 toArgs is used to parse arguments for both :load and :main, but doesn't appear to
 be used elsewhere.  I see no harm in modifying both to be consistent -- in fact,
 the functionality is probably more useful for :main than for :load.
] 
[Rename -no-recomp to -fforce-recomp, and document it
Simon Marlow <simonmar@microsoft.com>**20060927132707] 
[Make printing of binding results optional in GHCi, and document it
Simon Marlow <simonmar@microsoft.com>**20060927132550
 You can say :set -fno-print-bind-result in GHCi to disable this behaviour.
 Addresses #887
] 
[Various documentation improvements suggested by Bulat Ziganshin
Ian Lynagh <igloo@earth.li>**20060925231855] 
[Fix comment/code inconsistency spotted by Bulat Ziganshin
Ian Lynagh <igloo@earth.li>**20060925195925
 I'm not sure if this is the example that was intended, but it's at least
 now consistent.
] 
[Document -F in the flag reference
Ian Lynagh <igloo@earth.li>**20060925134816] 
[Remove duplicate call to getDOpts
simonpj@microsoft.com**20060922190350] 
[64bit fixes for the symbol lookup table
sven.panne@aedion.de**20060923162408] 
[Fix Linker import when BREAKPOINT is off
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20060921210029] 
[Use --export-dynamic to ensure ghci works on newer openbsds
Don Stewart <dons@cse.unsw.edu.au>**20060921010155
 
 Changes to the RTLD_DEFAULT semantics broke the trick we used to ensure
 libc symbols were available to the ghci linker, in OpenBSD 4.0. We can
 fix this by linking the ghc binary itself with --export-dynamic on this
 system, removing the need for any magic Linker.c games.
 
 GHCi now works on OpenBSD 4.0
 
 Contributed by Eric Mertens <emertens at gmail.com>
 
] 
[Currently we don't build cabal-setup
sven.panne@aedion.de**20060919081759] 
[Packages cleanup, and allow new packages to be loaded with :set again
Simon Marlow <simonmar@microsoft.com>**20060919012448
 
 This cleans up the package subsystem a little.  There are some
 changes to the GHC API as a result.
 
   - GHC.init and GHC.initFromArgs are no longer necessary.
 
   - GHC.newSession takes the root of the GHC tree as an argument
     (previously passed to GHC.init).
 
   - You *must* do GHC.setSessionDynFlags after GHC.newSession,
     this is what loads the package database.
 
   - Several global vars removed from SysTools
 
   - The :set command in GHCi can now cause new packages to be loaded,
     or can hide/ignore existing packages.
] 
[one more boring file
Simon Marlow <simonmar@microsoft.com>**20060919011849] 
[fix one boring file
Simon Marlow <simonmar@microsoft.com>**20060919011823] 
[unused imports
Simon Marlow <simonmar@microsoft.com>**20060919011746] 
[add boring files from a build tree
Simon Marlow <simonmar@microsoft.com>**20060919011722] 
[remove old comment
Simon Marlow <simonmar@microsoft.com>**20060919010333] 
[unused import
Simon Marlow <simonmar@microsoft.com>**20060919010303] 
[some updates
Simon Marlow <simonmar@microsoft.com>**20060918232924] 
[use ghc-pkg --force-files, and update command-line syntax
Simon Marlow <simonmar@microsoft.com>**20060918232903] 
[add --force-files, like --force but doesn't allow missing dependencies
Simon Marlow <simonmar@microsoft.com>**20060918232834] 
[emit an error if the user ran autoconf instead of autoreconf
Simon Marlow <simonmar@microsoft.com>**20060916084205] 
[Sanity check that all the core packages are present
Simon Marlow <simonmar@microsoft.com>**20060916070529
 To catch the case of not running darcs-all get.
] 
[reformat import
Simon Marlow <simonmar@microsoft.com>**20060913103512] 
[minor reformatting
Simon Marlow <simonmar@microsoft.com>**20060913103427] 
[compiler/ isn't boring
Simon Marlow <simonmar@microsoft.com>**20060913021300] 
[Added parsing rule for BangPattern in case expr
Markus Lauer <markus.lauer@acm.org>**20060918161850] 
[Fix a bug in subsumption, and tweak error messages
simonpj@microsoft.com**20060918005223
 
 This commit does two largely-unrelated things, but they hit the same code.
 
 First, I tweaked the error messages a bit, to give better errors
 for impredicative polymorphism.  This added the mb_fun argument to
 tc_sub.
 
 Second, I fixed a long-standing bug in tc_sub.  In the isBoxyTyVar case 
 of tc_sub (rule F2) I was not recursing to tc_sub as the rule suggests,
 but rather calling u_tys.  This is plain wrong, because the first
 arugment might have more foralls.   
 
 The solution is to recurse to tc_sub, but that in turn requires a parameter,
 exp_ib, which says when we are inside a box.
 
 Test is tc210.
 
] 
[Comments
simonpj@microsoft.com**20060918005142] 
[Ensure that only zonked poly_ids are passed to tcSpecPrag
simonpj@microsoft.com**20060918004805
 
 This is a long-standing bug really (Trac #900).  The poly_id passed
 to tcSpecPrag should be zonked, else it calls tcSubExp with a non-zonked
 type; but that contradicts the latter's invariant.
 
 I ended up doing a bit of refactoring too.  The extra lines are 
 comments I think; the code line count is reduced.
 
 Test is tc212.hs
 
] 
[Comments only
simonpj@microsoft.com**20060918004109] 
[Add a missing renamer dump (related to Template Haskell)
simonpj@microsoft.com**20060917171707] 
[Instantiate data constructor type variables with the type constructor type variables in constraints for derived class instances. Fixes instance deriving for GADTs which declar H98 types, closing ticket #902.
bringert@cs.chalmers.se**20060915233315] 
[Fixed error in user's manual, gadt section, part about deriving. Data constructor type was Maybe, should be Maybe1.
bringert@cs.chalmers.se**20060915230517] 
[remove generated files in a 'finally' manner
sof@galois.com**20060909144432] 
[Replace "&" with "and" as this also gets pulled into the docbook docs
Ian Lynagh <igloo@earth.li>**20060912125617] 
[Another s/autrijus/audreyt/ in comments.
audreyt@audreyt.org**20060912121323] 
[Take away XXXs in GADT records related code that are no longer TODOs.
audreyt@audreyt.org**20060912120942] 
[Add postfix ops to the release notes
simonpj@microsoft.com**20060912081104] 
[Document postfix operators
simonpj@microsoft.com**20060911162843] 
[Fix ~2000 second profiling time wrapping bug
Ian Lynagh <igloo@earth.li>**20060911223210] 
[move the "meat" into the wiki, this file just contains pointers now
Simon Marlow <simonmar@microsoft.com>**20060911135037] 
[Simplify desugaring of left sections
simonpj@microsoft.com**20060911083510
 
        MERGE TO 6.6 branch!
 
 Some while ago I made the type checker a tiny bit more lenient about
 left sections, so that 
        (x !)
 would typecheck iff
        ((!) x) 
 typechecks.  
 
 Strictly, Haskell 98 requires that the section typechecks iff
        (\y. (!) x y)
 typechecks, and I should really have made the relaxation dependent on a 
 flag, but I didn't.
 
 Anyway, this commit fixes the *desugarer* so that it correctly desugars
 the programs that the typechecker passes.
 
 
] 
[Add comment
simonpj@microsoft.com**20060911083440] 
[adapt stylesheet to example-contents class used by xsltproc
Ross Paterson <ross@soi.city.ac.uk>**20060910143941] 
[Fix warnings traceBegin/traceEnd implicitly declared
Ian Lynagh <igloo@earth.li>**20060910200611] 
[Fix linking to expf on Windows
Ian Lynagh <igloo@earth.li>**20060910141506] 
[8 byte align data. Fixes SIBGUSs on HPPA/Linux.
Ian Lynagh <igloo@earth.li>**20060909102445] 
[We now need alex >= 2.0.1
Ian Lynagh <igloo@earth.li>**20060908191706] 
[Add source code links to Haddock docs
Simon Marlow <simonmar@microsoft.com>**20060908112725
 
 Right now we can only manage to add a source code link for the module,
 but that's better than nothing.
 
 I had to put the list of core packages in a Makefile variable,
 $(CorePackages), so we'll have to be careful to keep this up to date.
 (I could have slurped it out of libraries/core-packages with $(shell),
 but that's ugly and really slow on Windows).
 
 There are a couple of new tweakables: CorePackageSourceURL and
 ExtraPackageSourceURL in config.mk.in, set these to the appropriate
 patterns for generating source links.
 
 (when we merge this patch onto the HEAD we'll have to tweak these
 settings).
 
 Unfortunately it still doesn't work for all the modules, because
 modules compiled without -cpp don't get any #line directives.  More
 hackery required...
] 
[Catch errors in pattern matching for unboxed tuples
simonpj@microsoft.com**20060908095217
 
 When fiddling with pattern-matching for unboxed tuples, I'd messed up
 the slightly-tricky tests for pattern matching on unboxed tuples, notably
        case (# foo, bar #) of r -> ...r...
 
 The fix is in TcPat, and test are tcfail115, tcfail120, and tc209
 
] 
[Fixed typo in users guide section about lexically scoped type variables.
bringert@cs.chalmers.se**20060907214626] 
[Typo, spotted by Bulat Ziganshin
Ian Lynagh <igloo@earth.li>**20060908014947] 
[Release note tweaks suggested by Bulat Ziganshin
Ian Lynagh <igloo@earth.li>**20060908014050] 
[Doc fix: generic classes are no longer broken
Ian Lynagh <igloo@earth.li>**20060907205426
 Spotted by Bulat Ziganshin.
] 
[If we get an unknown or unimplemented opcode, say what it is
Ian Lynagh <igloo@earth.li>**20060907171038] 
[remove __HUGS__ #if's (Hugs uses the standalone version)
Ross Paterson <ross@soi.city.ac.uk>**20060907152930] 
[Fix the handling of names in declaration brackets
simonpj@microsoft.com**20060907141845
 
 The handling of top-level names in declaration brackets is a bit tricky.
 This commit fixes Trac #977;  test is TH_spliceD2.
 
 The changes are commented in RnExpr.rnBracket and RdrName.hideSomeUnquals
 
 
] 
[Remove the -optP-P from .raw-hs generation
Simon Marlow <simonmar@microsoft.com>**20060907151855
 We need the #line directives left in, so that Haddock can figure out
 what the name of the original source file was called, which is
 necessary for generating source links.  You probably now need an
 updated Haddock to generate HTML from the libraries, but a release
 will be forthcoming shortly.
 
] 
[urk, the dependencies added in the last commit don't really work properly
Simon Marlow <simonmar@microsoft.com>**20060907113702
 first, I got the dependencies wrong (should be the .o file, not the
 .hs), and secondly GHC's recompilation checker refuses to recompile
 these files anyway.  I haven't done anything about the second problem
 yet, except to comment it.
 
] 
[Add dependencies on .h files #included into Haskell source
Simon Marlow <simonmar@microsoft.com>**20060907094751
 Our .depend machinery doesn't automatically generate these, so we have
 to add them manually.  (this fixes one instance of missing
 dependencies in the GHC build tree, there are lots more...).
] 
[Remove CONSTR_CHARLIKE and CONSTR_INTLIKE closure types
Simon Marlow <simonmar@microsoft.com>**20060907093005
 These closure types aren't used/needed, as far as I can tell.  The
 commoning up of Chars/Ints happens by comparing info pointers, and
 the info table for a dynamic C#/I# is CONSTR_0_1.  The RTS seemed
 a little confused about whether CONSTR_CHARLIKE/CONSTR_INTLIKE were
 supposed to be static or dynamic closures, too.
] 
[Documentation for impredicative polymorphism
simonpj@microsoft.com**20060907111540] 
[Comments only
simonpj@microsoft.com**20060907105705] 
[Remove result type signatures from documentation
simonpj@microsoft.com**20060907104301] 
[Fix bug in error message
simonpj@microsoft.com**20060907103052] 
[Result type signatures are no longer supported (partial)
simonpj@microsoft.com**20060907102718
 
 I had failed to remove the bit where result type signatures bind
 lexical type variables.  And now we are planning to remove them entirely.
 
 This commit therefore does a partial removal (to avoid destablising 6.6).
 It also arranges that
        f :: sig = rhs
 means a *pattern* binding (not a function binding with no arguments 
 and a result signature), which makes sense.
 
] 
[Remove trailing CRs with sed rather than relying on diff in nofib
Ian Lynagh <igloo@earth.li>**20060907112027
 Some diffs don't understand --strip-trailing-cr.
] 
[document -V in the +RTS --help outpout
Simon Marlow <simonmar@microsoft.com>**20060907084445] 
[Pattern-match warning police
simonpj@microsoft.com**20060906220417] 
[Improve error reporting for SigTvs, and add comments
simonpj@microsoft.com**20060906220309] 
[Check that top-level binders are unqualified names
simonpj@microsoft.com**20060906220101
 
 Not having this check led to strange error messages.
 See test rnfail046.
 
] 
[Documentation for lexically-scoped type variables
simonpj@microsoft.com**20060906164103
 
 GHC's design for lexically scoped type variables has changed.
 Here, belatedly, is the documentation.
 
] 
[Make record selection look cheap
simonpj@microsoft.com**20060906115242
 
 exprIsCheap was already making record selection look cheap, esp for
 dictionary selection; e.g.
    (==) dEq
 
 The idea is to allow those record selections to migrate inside a
 lambda, because on the whole it's more expensive to share than 
 repeat them.
 
 But sometimes dictionary selection is nested; e.g.
    (==) ($p1Num dNum)
 
 This turned out to make a (fragile) rewrite rule fire a little
 more robustly, but it seems like a good idea in any case.
 
 This patch makes nested record selections also look cheap.
 
] 
[Now in the wiki
Simon Marlow <simonmar@microsoft.com>**20060906104022] 
[-threaded and -prof do not currently work together
Simon Marlow <simonmar@microsoft.com>**20060906093158] 
[Don't fail on missing happy/alex if we don't need them
Ian Lynagh <igloo@earth.li>**20060906195415] 
[Fix the Windows "VirtualAlloc MEM_COMMIT failed" bug
Ian Lynagh <igloo@earth.li>**20060906112750
 We had
     base=01100000 size=1048576 size_delta=0 it->size=2097152 
     it->base=00F00000 base-it->base=00200000
 in commitBlocks.
 Esa Ilari Vuokko identified this inequality test as the cause.
] 
[Tell the 6.6 branch where to find extralibs
Ian Lynagh <igloo@earth.li>**20060906124640] 
[Correct the Cabal version number and remove features.
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060905232047
 We're not going to include cabal-setup and cabal-install in this release.
] 
[Strip trailing CRs when comparing output for nofib. Fixes #797.
Ian Lynagh <igloo@earth.li>**20060905184910] 
[Fix dependency analysis (notably bindInstsOfLocalFuns) in TcBinds
simonpj@microsoft.com**20060905105143
 
 GHC 6.5 does enhanced dependency analysis for recursive bindings, to 
 maximise polymorphism based on type signatures.  (See Mark Jones's
 THIH paper.)  
 
 I didn't do the bindInstsOfLocalFuns part correctly though, and jhc
 showed up the bug.  (It only matters when you have a recursive group
 of two or more functions with a type signature, not at top level, which
 is why it hasn't shown up till now.) 
 
 Test is tc207.hs
 
 
] 
[Add note about overlapping instances
simonpj@microsoft.com**20060905092201] 
[Record that TH doesn't support pattern types signature
simonpj@microsoft.com**20060905091834] 
[new RTS flag: -V to modify the resolution of the RTS timer
Ian Lynagh <igloo@earth.li>**20060905141545
 Fixed version of an old patch by Simon Marlow. His description read:
  Also, now an arbitrarily short context switch interval may now be
  specified, as we increase the RTS ticker's resolution to match the
  requested context switch interval.  This also applies to +RTS -i (heap
  profiling) and +RTS -I (the idle GC timer).  +RTS -V is actually only
  required for increasing the resolution of the profile timer.
] 
[Refactoring for derived Read
simonpj@microsoft.com**20060904132212
 
 There are no functional changes in this commit.  But the code for
 derived Read is refactored to make it tidier --- and also to make
 it very easy if we want derived Read to parse the prefix form of
 infix ocnstructors.  
 
 For example,
        data T = Int `T1` Int
 According to the H98 report, the derived Read instance will parse
 infix uses of T1, but not prefix uses (T1 4 3).  It's arguable that it
 should parse both -- and easy to implement, but it would cause a little bit
 of code bloat.
 
 Similarly records.
 
 Anyway this commit doesn't implement the change; just makes it easy
 to do so.
 
] 
[Improve pretty-printing for HsExpr
simonpj@microsoft.com**20060904131334] 
[Fix typos.
Ian Lynagh <igloo@earth.li>**20060904190958] 
[Enable bang-patterns only when the flag says so (had missed a case before)
simonpj@microsoft.com**20060904131412] 
[Remove linear implicit parameters, and document in release notes
simonpj@microsoft.com**20060904125105] 
[Release notes should mention better newtype-deriving
simonpj@microsoft.com**20060904124458] 
[Documentation for bang patterns, and other improvements
simonpj@microsoft.com**20060904123438] 
[Add a hint on tab completion
Ian Lynagh <igloo@earth.li>**20060903224823] 
[Add :main docs to ghci commands page
Ian Lynagh <igloo@earth.li>**20060903223107] 
[Ambiguities are now allowed in ghci command names
Ian Lynagh <igloo@earth.li>**20060903222115] 
[More output updates
Ian Lynagh <igloo@earth.li>**20060903221933] 
[Add docs for :main
Ian Lynagh <igloo@earth.li>**20060903220130] 
[More doc output fixes
Ian Lynagh <igloo@earth.li>**20060903215748] 
[Update ghci output in docs
Ian Lynagh <igloo@earth.li>**20060903214128] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20060903212651] 
[Update ghci output in docs
Ian Lynagh <igloo@earth.li>**20060903210805] 
[Remove a tab causing ghci's :? alignment to go wrong
Ian Lynagh <igloo@earth.li>**20060903210349] 
[Change default repo root for the 6.6 branch
Ian Lynagh <igloo@earth.li>**20060902174936] 
[Don't lose linked list tail
Esa Ilari Vuokko <ei@vuokko.info>**20060831223315] 
[Fix Windows MBlock alloctor bookkeeping bug
Esa Ilari Vuokko <ei@vuokko.info>**20060830185540] 
[-fglasgow-exts no longer implies -fbang-patterns
simonpj@microsoft.com**20060901125714] 
[Fix error in release notes, spotted by Esa Ilari Vuokko
Ian Lynagh <igloo@earth.li>**20060901125841] 
[Remove changes in packages we don't build
Ian Lynagh <igloo@earth.li>**20060901125436] 
[Don't enable SMP if we are unregisterised
Ian Lynagh <igloo@earth.li>**20060829123228] 
[Add a pointer to the fundeps paper
simonpj@microsoft.com**20060831135511] 
[free the task *after* calling closeCond and closeMutex
Simon Marlow <simonmar@microsoft.com>**20060831103648] 
[add missing ghc_ge_605
Simon Marlow <simonmar@microsoft.com>**20060831101813] 
[don't closeMutex() the Capability lock
Simon Marlow <simonmar@microsoft.com>**20060831085728
 There might be threads in foreign calls that will attempt to return
 via resumeThread() and grab this lock, so we can't safely destroy it.
 
 Fixes one cause of
 
    internal error: ASSERTION FAILED: file Capability.c, line 90
 
 although I haven't repeated that assertion failure in the wild, only
 with a specially crafted test case, so I can't be sure I really got
 it.
] 
[fix Unix build
Simon Marlow <simonmar@microsoft.com>**20060830141529] 
[add sysErrorBelch() for reporting system call errors
Simon Marlow <simonmar@microsoft.com>**20060830140252] 
[call ShutdownIOManager() before closing handles
Simon Marlow <simonmar@microsoft.com>**20060830123131
 To avoid IO requests completing only to discover that the
 completed_table_sema has been CloseHandle()'d.  This all looks a bit
 wrong, though: we shouldn't really be waiting for these requests to
 complete, they might take forever.
] 
[Windows: make some soft failures into fatal errors
Simon Marlow <simonmar@microsoft.com>**20060830091859
 Some of the memory allocation calls were being checked for error, but
 the RTS was printing a message and continuing.  These error cases
 lead to crashes later, so better to just fail immediately.
] 
[MAYBE_GC: initialise HpAlloc
Simon Marlow <simonmar@microsoft.com>**20060830091529
 HpAlloc was not being set when returning to the scheduler via MAYBE_GC(),
 which at the least was just wrong (the scheduler might allocate a large
 block more than once), and at worst could lead to crashes if HpAlloc contains
 garbage.
 
 Fixes at least one threaded2 test on Windows.
] 
[FILL_SLOP: don't fill slop for BLACKHOLE/CAF_BLACKHOLE
Simon Marlow <simonmar@microsoft.com>**20060830083311
 This affects -debug only, avoids crash with test conc012.
] 
[oops, got the sense of the error case wrong
Simon Marlow <simonmar@microsoft.com>**20060829151751] 
[fix some rerrors in the worker counting
Simon Marlow <simonmar@microsoft.com>**20060829135150] 
[add missing case for BlockedOnDoProc
Simon Marlow <simonmar@microsoft.com>**20060829113345] 
[omit HGL on Windows
Simon Marlow <simonmar@microsoft.com>**20060829104921] 
[Don't trust "ln -sf" to do the right thing (it doesn't on Solaris)
Simon Marlow <simonmar@microsoft.com>**20060829093735
 Patch from: Roman Leshchinskiy
] 
[don't include HaXml, Japi and monads in a GHC checkout
Simon Marlow <simonmar@microsoft.com>**20060829085946
 They aren't built as part of a GHC build anyway, it doesn't make much
 sense to include them in checkouts or source tarballs.
] 
[don't include .depend (attempt to fix Windows stage2 build failure)
Simon Marlow <simonmar@microsoft.com>**20060829083842] 
[Add mipsel case to configure.ac
Ian Lynagh <igloo@earth.li>**20060825193603] 
[incremented versions of arrows and X11
Ross Paterson <ross@soi.city.ac.uk>**20060825162415] 
[omit Control.Sequential.STM
Ross Paterson <ross@soi.city.ac.uk>**20060825161645
 
 It's an internal module used by non-GHC implementations only.
] 
[various minor tweaks, and rearrange to put "important" changes near the top
Simon Marlow <simonmar@microsoft.com>**20060825154955] 
[mention -fno-mono-pat-binds, since this is a diversion from Haskell 98
Simon Marlow <simonmar@microsoft.com>**20060825152613] 
[Document SMP support
Simon Marlow <simonmar@microsoft.com>**20060825151236] 
[Load the target of a dynamic foreign call into a temporary
Simon Marlow <simonmar@microsoft.com>**20060825140906
 Fixes ffi011(opt) on x86_64.  I don't know why this has only just
 appeared today, it's apparently been broken for some time.
] 
[Sparc supports SMP too
Simon Marlow <simonmar@microsoft.com>**20060825133628] 
[Fix rewriting of Control.Exception.Assert; fixes 875
Ian Lynagh <igloo@earth.li>**20060825010219] 
[Add the regex reshuffle to the release notes
Ian Lynagh <igloo@earth.li>**20060825110520] 
[parsec is now a core library
Ian Lynagh <igloo@earth.li>**20060825102418] 
[Add a default case to pprDynamicLinkerAsmLabel
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20060825101846
 
 This is mainly for the benefit of Solaris. I'll fix this properly later.
] 
[Reserve a register for REG_Base on the Sparc
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20060825101820] 
[Add atomic SMP primitives for the Sparc
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20060825101753] 
[Make sure GCC uses the Sparc V9 instruction set
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20060825101646
 
 We only support Sparc V9 and better as V8 lacks an atomic CAS instruction
 which we need for SMP. This means that we have to pass -mcpu=v9 to GCC when
 compiling and assembling. Hardcoding the flag is hackish but seems to be
 our best bet at the moment. It can still be overridden by the user as GCC
 picks the best -mcpu flag regardless of the ordering.
] 
[shutdownCapability(): don't bail out after 50 iterations
Simon Marlow <simonmar@microsoft.com>**20060825100244
 See comments for details.  Fixes assertion failures in stage 3 build
 which appeared after recent closeMutex() addidion.  May fix other
 shutdown issues.
] 
[add dependency on regex-compat
Simon Marlow <simonmar@microsoft.com>**20060825093226] 
[move parsec into $(GhcBootLibs); tidy up
Simon Marlow <simonmar@microsoft.com>**20060825091013] 
[Mips registerised support
Simon Marlow <simonmar@microsoft.com>**20060825085712
 Contributed by: Thiemo Seufer <ths@networkno.de>
] 
[parsec is required to be a core package, genprimopcode uses it
Simon Marlow <simonmar@microsoft.com>**20060825084607] 
[Free Win32 Handles on shutdown
Simon Marlow <simonmar@microsoft.com>**20060825084435
 patch from #878
] 
[Fix unregisterised builds, and building on non-x86/amd64/powerpc
Ian Lynagh <igloo@earth.li>**20060825003945] 
[Release notes for GHC 6.6
Ian Lynagh <igloo@earth.li>**20060824211646] 
[Update for changes to packages
Simon Marlow <simonmar@microsoft.com>**20060824153500
 Not much has changed really: just the removal of the overlap
 restriction, and the re-instatement of the requirement that
 -package-name must be used when compiling a package now.
] 
[somehow I lost the unix subdir; recover it
Simon Marlow <simonmar@microsoft.com>**20060824152529] 
[expand the section on getting the source.
Simon Marlow <simonmar@microsoft.com>**20060824150647] 
[config in regex-posix too
Simon Marlow <simonmar@microsoft.com>**20060824145717] 
[make all AC_CONFIG_SUBDIRS optional
Simon Marlow <simonmar@microsoft.com>**20060824143016] 
[Add dynCompileExpr
Esa Ilari Vuokko <ei@vuokko.info>**20060823221828] 
[Remove duplicate documentation of -package flag
Ian Lynagh <igloo@earth.li>**20060824121806] 
[Remove a reference to -fglobalise-toplev-names that got left behind
Ian Lynagh <igloo@earth.li>**20060824121442] 
[Add closeMutex and use it on clean up
Esa Ilari Vuokko <ei@vuokko.info>**20060823194604] 
[Add shared Typeable support
Esa Ilari Vuokko <ei@vuokko.info>**20060823003041] 
[Ignore sections generated from .ident
Esa Ilari Vuokko <ei@vuokko.info>**20060823155023] 
[update with respect to darcs-all changes
Simon Marlow <simonmar@microsoft.com>**20060824115535] 
[divide packages into "core" and "extra" packages
Simon Marlow <simonmar@microsoft.com>**20060824114902
 The following packages are now "core" packages:
 
   base, Cabal, haskell98, readline, regex-base, regex-compat
   regex-posix, stm, template-haskell, unix, Win32
 
 Core packages are those packages required to bootstrap GHC, or are
 closely tied to GHC (stm, template-haskell).  These are the packages
 that will be provided in a source distribution from now on.
 
 All other packages are classified as "extra" packages.  As far as
 binary distributions and nightly builds go, nothing will change -
 we'll still build and include all these packages in the distributions.
 
 NOTE: 'sh darcs-all get' will now get the core packages only.  To get
 the extra packages too, use 'sh darcs-all --extra get'.
] 
[Sparc fix: work around gcc optimising away the reserved stack chunk
Simon Marlow <simonmar@microsoft.com>**20060824113750
 This bug causes crashse on Sparc when calling foreign functions with
 more than 13 arguments.
] 
[add new regex packages
Simon Marlow <simonmar@microsoft.com>**20060824094443] 
[Clean up coding style
Esa Ilari Vuokko <ei@vuokko.info>**20060823075822] 
[Use stgMallc and stgFree instead of malloc/free
Esa Ilari Vuokko <ei@vuokko.info>**20060823002902] 
[Remove wrong VirtualAlloc MEM_DECOMMITs on cleanup
Esa Ilari Vuokko <ei@vuokko.info>**20060821180332] 
[Remove few format-warnings by adding casts
Esa Ilari Vuokko <ei@vuokko.info>**20060813111029] 
[Remove warning: Correct includes for mingw
Esa Ilari Vuokko <ei@vuokko.info>**20060813002216] 
[Add few more guesses where to find bits of mingw-gcc
Esa Ilari Vuokko <ei@vuokko.info>**20060812020901] 
[in the GHCi prompt, print ModuleNames not Modules
Simon Marlow <simonmar@microsoft.com>**20060823095258] 
[In the Compiling/Skipping message, print ModuleNames not Modules
Simon Marlow <simonmar@microsoft.com>**20060823095225
 These modules are always home modules, by definition, so the package
 name is redundant.
 
] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20060822163300] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20060822163212] 
[FastString and StringBuffer need -funbox-strict-fields too
Simon Marlow <simonmar@microsoft.com>**20060822143337
 For the benefit of old GHCs that don't understand {-# UNPACK #-}
] 
[minor fix to the clashing export error message
Simon Marlow <simonmar@microsoft.com>**20060822112518
 The ordering of items in the parsed export list is now correct, so we
 have to compensate to get the right output again.
] 
[findModule: add a fallthrough error case
Simon Marlow <simonmar@microsoft.com>**20060822112409] 
[notes about which versions of GHC can be used to bootstrap
Simon Marlow <simonmar@microsoft.com>**20060822093554] 
[disable .ident generation on darwin_TARGET_OS
Simon Marlow <simonmar@microsoft.com>**20060822090349] 
[fix typo
Simon Marlow <simonmar@microsoft.com>**20060822073731] 
[fixes to PPC version of cas(), from David Kirkman <dkirkman@gmail.com>
Simon Marlow <simonmar@microsoft.com>**20060821153136
 
 From David's email:
 The problem is that the inline assembler code was placing the result
 of an operation in a register that is used as input later in the code.
 At the bottom of this message I've extracted a short short code
 fragment that you can run through gcc (on a powerpc machine) to see
 the generated assembly output.
 
 The changes to fix the problem are fairly simple.  The first adds an
 ampersand to the output list of the assembly fragment ("=r" (result)
 --> "=&r" (result)) The ampersand just tells gcc that result can not
 be placed in a register used for any of the input parameters (o, n, or
 p).  Otherwise, it feels free to place output parameters in the same
 registers used by the inputs -- but because of the flow of control
 here we need everything in a distinct register.  This change fixes the
 TVar program above.
 
 The second change adds a clobber list (the :"cc", "memory").  This
 tells gcc that the condition code (due to the compare) and memory (due
 to the store) might be changed during the asm execution.  The lack of
 a clobber list did not seem to be causing any trouble, but without it
 gcc is free to assume that no state is changed during the execution.
] 
[Always use -funbox-strict-fields for Binary
Simon Marlow <simonmar@microsoft.com>**20060821152111
 For some reason this was only enabled when $(bootstrapped)=YES.  This
 would be one reason why the stage1 compiler is slow.  I guess we'll
 find out if anything goes wrong.
] 
[disable automagic building of GHCi in stage1
Simon Marlow <simonmar@microsoft.com>**20060821151957] 
[remove ancient file with incorrect information
Simon Marlow <simonmar@microsoft.com>**20060821141946] 
[new option -a (append) for hasktags
Martin Grabmueller <magr@cs.tu-berlin.de>**20060816091427] 
[ugly hack to cause ghc_boot_platform.h to be built before primops.txt
Simon Marlow <simonmar@microsoft.com>**20060821120630] 
[add libraries/cgi and libraries/xhtml
Simon Marlow <simonmar@microsoft.com>**20060821102908] 
[(temp) #814 - More flexible memory allocation in Windows
Esa Ilari Vuokko <ei@vuokko.info>**20060820150720] 
[fix export/import list parsing (allow (,)), and remove unnecessary reverses
Simon Marlow <simonmar@microsoft.com>**20060821102633] 
[comply with Haskell 98 by not allowing extra commas in import/export lists
Simon Marlow <simonmar@microsoft.com>**20060821095912] 
[Missing stage1's in hc-build
Ian Lynagh <igloo@earth.li>**20060821092226
 Add mising stage1/ directories to object files touched by hc-build, and
 give stage=1 as an argument to make install.
] 
[remove spurious commas in imports
Ross Paterson <ross@soi.city.ac.uk>**20060819173423] 
[whitespace cleanup only
Ross Paterson <ross@soi.city.ac.uk>**20060818224014] 
[remove gcj libs from bin dist
sof@galois.com**20060818214155] 
[I don't thing we want to add a call-context here; it just clutters the output
simonpj@microsoft.com**20060818160729] 
[Avoid duplicate "In type ..." in error messages
simonpj@microsoft.com**20060818160611] 
[Better pretty-printing for TvSubst
simonpj@microsoft.com**20060818160551] 
[Fall over more gracefully when there's a Template Haskell error
simonpj@microsoft.com**20060818110702
 
 For a long time, Template Haskell has fallen over in a very un-graceful
 way (i.e. panic) even when it encounters a programmer error.  In particular,
 when DsMeta converts HsSyn to TH syntax, it may find Haskell code that
 TH does not understand. This should be reported as a normal programmer
 error, not with a compiler panic!
 
 Originally the desugarer was supposed to never generate error
 messages, but this TH desugaring thing does make it do so.  And in
 fact, for other reasons, the desugarer now uses the TcRnIf monad, the
 common monad used by the renamer, typechecker, interface checker, and
 desugarer.  
 
 This patch completes the job, by 
  - allowing the desugarer to generate errors
  - re-plumbing the error handling to take account of this
  - making DsMeta use the new facilities to report error gracefully
 
 Quite a few lines of code are touched, but nothing deep is going on.
 
 Fixes Trac# 760.
 
] 
[Fix typo (fst --> head) in docs on implicit parameters
simonpj@microsoft.com**20060818075937] 
[One last hs-boot update
simonpj@microsoft.com**20060817134216] 
[Missing import for stage 2
simonpj@microsoft.com**20060817133247] 
[One more hs-boot file
simonpj@microsoft.com**20060817133220] 
[Refactoring for valid rule checking
simonpj@microsoft.com**20060817130141] 
[Do not CSE in INLINE and NOINLINE things
simonpj@microsoft.com**20060817130005
 
 See extensive comments with Note [INLINE and NOINLINE] in this file.
 
] 
[Update lhs-boot files
simonpj@microsoft.com**20060817132003
 
 A consequence of my recent meddling with hs-boot files is that GHC is
 more picky about the correpondence between the hs-boot file and the hs file.
 In particular, you must use the same type synonyms.
 
 This patche fixes up GHC's own hs-boot files to match the restriction.
 
] 
[Add ad-hoc typing checks for tagToEnum#
simonpj@microsoft.com**20060816203156
 
 The problem with tagToEnum# is that it is not overloaded (in the
 Haskell sense) but you are only supposed to apply it to a TyCon
 that is an enumeration (isEnumerationTyCon).
 
 The Real Way to do this is to have some special kind of type constraint
 for the purpose, but that is wild overkill. So this patch adds a small
 rather ad-hoc check to TcExpr.instFun.  Crude, simple, but it works fine.
 
 Fixes Trac #786
 Test is tcfail164
 
] 
[Get dead-ness right in knownCon
simonpj@microsoft.com**20060816164216] 
[Tuning for argToPat
simonpj@microsoft.com**20060816164103
 
 argToPat is a crucial function for SpecConstr, because it decides
 what patterns are worth specialising.  I was being much too gung-ho about
 constants.  This patch makes it much better.
 
] 
[Re-factor mkAtomicArgs and completeNonRecX
simonpj@microsoft.com**20060816163645
 
 This refactoring ensures that when mkAtomicArgs adds new bindings,
 it does so using completeNonRecX, which adds unfoldings etc.  More
 modular, and saves passes too.
 
 (This was important when getting rules to work right.  We want tob
 fire a rule as soon as possible, taking into account all inlinings,
 else a less-good rule applies.  That's what I found when doing 
 stream fusion anyway.)
 
 Regardless, this is an improvement.
 
] 
[Another try at the continuation-swapping stuff
simonpj@microsoft.com**20060816105042
 
 I have spent altogether too long on my attempt to avoid case-of-case
 in situations where it is a Bad Thing.  All the action is in the
 case for mkDupableAlt that handles cases with a single alternative.
 
 I've added rather extensive comments, and it finally seems to be working
 more or less right.  If you compile (say) GHC/Real.o you'll see quite a
 few case-of-cases remain (which didn't happen before), and they mostly look
 pretty sensible to me.
 
] 
[Don't build unnecessary lets in knownCon
simonpj@microsoft.com**20060816104831
 
 Faced with
        case x of y { (a,b) -> rhs }
 
 where x is bound to (c,d), we were generating
        
        let y = (c,d) in rhs
 
 and thenn hoping to get rid of the y binding by CSE or some such.  It's
 better simply not to build it in the first place, by generating
 
        let y = x in rhs
 
 This patch does the job.
 
] 
[Comments only
simonpj@microsoft.com**20060816104817] 
[Refactoring, plus record recursive-function *components* as RecArg too
simonpj@microsoft.com**20060816085809] 
[Record constructor arg occs correctly (bug-fix)
simonpj@microsoft.com**20060816085628
 
 I was forgetting the non-pattern-matched type args of a constructor.
 
] 
[Disable form-checking for rule LHSs
simonpj@microsoft.com**20060816085612
 
 Previously we checked the form of the arguments of a RULE lhs, to 
 ensure that they were simple applications. There was no good reason
 for that, save to prevent you writing LHSs that were unlikely to match.
 
 And Don Stewart found he wanted to do something we didn't allow (a section,
 I think).  So I have just disabled the check.
 
] 
[Allow class and instance decls in hs-boot files
simonpj@microsoft.com**20060815123402
 
 For some reason, in 6.5 the manual said you could put a class decl in
 an interface file, but not an instance decl; whereas the implementation
 was exactly the othe way round.
 
 This patch makes it possible to put *both* class and instance decls
 in an interface file. 
 
 I also did a bit of re-factoring; comparing the declarations in the
 hs-boot and hs file is now done by converting to IfaceSyn, because we
 have good comparison operations for IfaceSyn already implemented.
 This fixed a bug that previously let through an inconsistent declaration 
 of a data type.
 
 The remaining infelicity concerns "abstract" TyCons.  They are a bit
 of a hack anyway; and Classes are not handled in the same way.  Need
 to think about this, but I think it's probably ok as it stands.
 
 
] 
[Reject derivable type classes with higher-rank methods
simonpj@microsoft.com**20060815075928
 
 Trac #864 suggested a derivable type class with a higher-rank method.
 
 In principle this is quite do-able, but in practice the mechanism works
 by generating source code and then doing type inference.  To make this work
 with higher-rank types would require impredicative polymorphism. And we 
 do have that, so it could probably be made to work by generating (source-level)
 type annotations.  But it's real work, so I'm settling for generating a
 decent error message rather than crashing.
 
 
] 
[SpecConstr now specialises on constants and lambdas 
simonpj@microsoft.com**20060815162605
 
 Roman inspired me to beef up SpecConstr to deal with
 a) constant arguments
 b) lambda arguments
 
 This is described in elaborate comments in the file:
        Note [Specialising for constant parameters]
        Note [Specialising for lambda parameters]
 
 I also took the opportunity to fix the usage analysis done by
 SpecConstr, which was only handling the top-level correctly.
 Now it does nesting too.
 
 
] 
[Fix two bugs in rule-matching
simonpj@microsoft.com**20060815162030
 
 These two typo-like bugs have been there for a long time!
 
   One concerns the selection of overlapping rules, 
   which was back to front
 
   The other was name-lining-up bug in the Case case of matching
 
 This patch also arranges to export matchN. 
   (Not a good name, but still!)
 
 
] 
[Moving list-length code from one place in the file to another
simonpj@microsoft.com**20060815161947] 
[Make UniqSM into a proper monad
simonpj@microsoft.com**20060815161829] 
[Typo in patch that dealt with duplicating continuations in Simplify
simonpj@microsoft.com**20060815070246] 
[Be more conservative about duplicating continuations
simonpj@microsoft.com**20060814165424
 
 Roman found that GHC was duplicating continuations that arose (essentially)
 from uses of 'seq', or strict constructors.  This fixes the problem;
 see the comments mkDupableCont (the Select case with a single alternative).
 
 I'm a little concerned that this may also miss useful case-of-case
 tranformations, so I'd like to know if anyone finds that this patch
 makes performance worse.
 
 To make it a bit more gung-ho, one could check for all the binders
 being dead, before choosing this new, conservative alternative.
 
 
] 
[Inline into tail-called constructor args
simonpj@microsoft.com**20060814165127
 
 Consider
        x = case y of { True -> (p,q); ... }
 
 The occurrence analyser was marking p,q as 'Many', because they args
 of a constructor in an RhsCtxt.  But actually they aren't in a RhsCtxt,
 and in this case it's better to inline.
 
] 
[Improve exprIsCheap
simonpj@microsoft.com**20060814165043
 
 exprIsCheap is meant to return True iff it's ok to push the expression
 inside a lambda.  But the previous version would return True of a nested
 construtor application like (1:2:3:[]), which isn't right.
 
 This patch re-factors the code somewhat, and fixes the bug.
 
] 
[Added xhtml and cgi as default libraries.
bringert@cs.chalmers.se**20060814113242] 
[Improve error message in TcHsType
simonpj@microsoft.com**20060814095617
 
 Fixes Trac #863.
 Test is tcfail162
 
] 
[Warning police: Removed overlapped pattern warnings
sven.panne@aedion.de**20060811151353] 
[Complete -fmono-pat-binds patch
simonpj@microsoft.com**20060811142842
 
 When adding the experimental -fmono-pat-binds, I forgot to check
 for type signatures of the now-monomorphic patterns.  This patch
 completes the job.
 
 I documented the design too:
    http://haskell.galois.com/cgi-bin/haskell-prime/trac.cgi/wiki/MonomorphicPatternBindings
 
] 
[Avoid warning about overlapped pattern for Linux target
sven.panne@aedion.de**20060811140512] 
[Improve error message layouts
simonpj@microsoft.com**20060811133317] 
[Add type signature
simonpj@microsoft.com**20060811133302] 
[Improve the "could not find module" error message
Simon Marlow <simonmar@microsoft.com>**20060811132135
 In particular, if we're searching for the profiling version of a
 module in another package, then suggest that perhaps it might not have
 been installed.
] 
[On FreeBSD, use -lthr instead of -pthread for now (see comments)
Simon Marlow <simonmar@microsoft.com>**20060811113453] 
[Two more error message indendations
simonpj@microsoft.com**20060811110435] 
[Go back to calling type veriables t
simonpj@microsoft.com**20060811110412] 
[Indent an error message
simonpj@microsoft.com**20060811110347] 
[Improve error message (imported from Prelude at Implicit import declaration)
simonpj@microsoft.com**20060811110301] 
[don't qualify module name for importedSrcLoc
Simon Marlow <simonmar@microsoft.com>**20060811101327] 
[use "Defined in" rather than "Imported from" when printing ImportedSrcLoc
Simon Marlow <simonmar@microsoft.com>**20060811101159] 
[Now that we have an "html" package, put the Haddock docs somewhere else
sven.panne@aedion.de**20060811092609] 
[Nuked hschooks.h in favour of cutils.h, which has the prototypes we need
sven.panne@aedion.de**20060810154225] 
[Match format strings and arguments for printf-like functions
sven.panne@aedion.de**20060810153624] 
[Warning police: Make prototype for LDV_recordDead_FILL_SLOP_DYNAMIC visible
sven.panne@aedion.de**20060810144837] 
[Warning police: Make strlen and friends known
sven.panne@aedion.de**20060810144729] 
[Tweak GCC's inlining parameters to get thread_obj inlined
sven.panne@aedion.de**20060810144505] 
[Add an IAmDead case to postInlineUnconditionally, and comments
simonpj@microsoft.com**20060810142034] 
[Do not repeatedly simplify an argument more than once
simonpj@microsoft.com**20060810141526
 
 A very important invariant of the simplifier is that we do not simplify
 an arbitrarily large expression more than once in a single pass. If this
 can happen, then we can get exponential behaviour, when the large expression
 itself has a large sub-expression which is simplified twice, and so on.
 
 GHC has a long-standing bug which allows this repeated simplification to 
 happen.  It shows up when we have a function like this
 
        f d BIG
 where f's unfolding looks like
        \x -> case x of (a,b) -> a
 Of course this is v common for overloaded functions.
 
 Before this patch we simplified all the args (d and BIG) before
 deciding to unfold f.  Then we push back the simplified BIG onto the
 continuation stack, inline f, so now we have
        (case d of (a,b) -> a) BIG
 After we reduce the case a bit, we'll simplify BIG a second time.  And
 that's the problem.
 
 The quick-and-dirty solution is to keep a flag in the ApplyTo continuation
 to say whather the arg has already been simplified.  An alternative would
 be to simplify it when first encountered, but that's a bigger change.
 
 
] 
[Do not call preInlineUnconditionally in simplNonRecX
simonpj@microsoft.com**20060810141340
 
 This looks to me like a long-standing bug. simplNonRecX was calling
 preInlineUnconditionally, even though it was given an already-simplified
 expression.  Exponential behaviour beckons.
 
] 
[Make postInlineUnconditaionally more conservative
simonpj@microsoft.com**20060810141145
 
 I'm being more paranoid about repeatedly simplifying things (to avoid
 exponential behaviour.)  postInlineUnconditionally looks as if it
 could repeated simplify the same expression; this patch stops it doing
 so.
 
 The extra lines are all comments!
 
 
] 
[Control.Exception.unblock wasn't unblocking exceptions
Simon Marlow <simonmar@microsoft.com>**20060810132307] 
[remove out of date comment
Simon Marlow <simonmar@microsoft.com>**20060810130154] 
[move html before network, for now
Simon Marlow <simonmar@microsoft.com>**20060810121930] 
[add html package
Simon Marlow <simonmar@microsoft.com>**20060810113719] 
[Egregious bug in tcLHsConResTy
simonpj@microsoft.com**20060810120828
 
 This terrible bug in tcLHsConTy is pretty much guaranteed to show up
 on an program involving a GADT with more than one type parameter.
 
 This bug isn't present in the STABLE branch.
 
 Manuel: it is *not* necesary to merge this patch into the FC branch; 
 just ignore it.
 
] 
[Comments about improvements to SpecConstr
simonpj@microsoft.com**20060810120759] 
[Remove HasBounds-instance and implement MArray.getBounds instead
Esa Ilari Vuokko <ei@vuokko.info>**20060809163012] 
[Fix Array imports
Esa Ilari Vuokko <ei@vuokko.info>**20060809161341] 
[Where we use $(GhcHcOpts), also add $(GhcStage1HcOpts)
Simon Marlow <simonmar@microsoft.com>**20060809144845
 This fixes building the compiler with -prof in $(GhcStage1HcOpts)
] 
[fixes to the stage2 build following removal of old FFI syntax
Simon Marlow <simonmar@microsoft.com>**20060809143153] 
[fix bug in task freeing
Simon Marlow <simonmar@microsoft.com>**20060809141225] 
[add some more options to stage 2
Simon Marlow <simonmar@microsoft.com>**20060809141058] 
[remove debugging code accidentally left in
Simon Marlow <simonmar@microsoft.com>**20060809102936] 
[remember that old FFI syntax has been dropped
Simon Marlow <simonmar@microsoft.com>**20060809101655] 
[only define GHCI if $(GhcWithInterpreter)=YES, also add -threaded
Simon Marlow <simonmar@microsoft.com>**20060809101634] 
[move altzone test to base package
Ross Paterson <ross@soi.city.ac.uk>**20060809124215] 
[remove unused FPTOOLS_CHECK_HTYPE macro
Ross Paterson <ross@soi.city.ac.uk>**20060809124036] 
[Remove the artifical cap on the number of workers
Simon Marlow <simonmar@microsoft.com>**20060809095908
 See #805.  This was here to catch bugs that resulted in an infinite
 number of worker threads being created.  However, we can't put a
 reasonable bound on the number of worker threads, because legitimate
 programs may need to create large numbers of (probably blocked) worker
 threads.  Furthermore, the OS probably has a bound on the number of
 threads that a process can create in any case.
 
 
 
] 
[Remove old FFI syntax
Simon Marlow <simonmar@microsoft.com>**20060809095201
 See #815
] 
[make exit() overridable, for use in DLLs
Simon Marlow <simonmar@microsoft.com>**20060809092439
 See #753
] 
[More fixes to pre-matching and pre-subsumption
simonpj@microsoft.com**20060808224924
 
 Actually this patch fixes two errors. one was a trivial typo in 
 tha last patch (b_ty should be b_tau), which led to an infinite loop
 when compiling Data.Generic.Twins.  
 
 Fixing that revealed a more serious error in the same function.
 I was sloppy about dealing robsutly with name-capture for nested
 quantifiers in pre-subsumption and pre-matching; and sure enough
 I got bitten.  Sigh.  I think it is right now.
 
] 
[Group exports so that all length functions are together; no semantic change
simonpj@microsoft.com**20060808224808] 
[Check that lazy patterns are for lifted types
simonpj@microsoft.com**20060808135910
 
 A lazy pattern match must be for a lifted type. This is illegal:
 
        f x = case g x of 
                 ~(# x,y #) -> ...
 
 This commit fixes the problem.  Trac #845, test is tcfail159
  
] 
[Spelling in a comment
simonpj@microsoft.com**20060808123514] 
[Remove srcSpanStartLine/srcSpanEndLine crash
simonpj@microsoft.com**20060808123211
 
 srcSpanStartLine/srcSpanEndLine panic on UnhelpfulLoc. They should not
 really be exported by SrcLoc at all, but unfortunately they are used in
 Lexer.x, which knows enough to avoid the panic.
 
 However the call in RnEnv didn't know, and the panic was triggered 
 by Template Haskell spliced code.  This patch fixes it by exporting
 the predicate RnEnv wanted, namely isOneLineSpan.
 
] 
[Replace deprecated AC_TRY_COMPILE macro with the reccomended replcament
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060706114902
 See: http://www.gnu.org/software/autoconf/manual/html_node/Obsolete-Macros.html
] 
[Add ghc and version number in .ident directive in NCG
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060706114712
 Just because we can and because every other compiler does,
 lets stick in an identifier directive: .ident "GHC x.y.z"
 into the assembly output of the NCG.
] 
[Support the GNU non-exec stack annotation system
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060706114331
 On recent GNU ELF systems one can mark an object file as not
 requiring an executable stack. If all objects- linked into a
 program have this note then the program will not use an executable
 stack, which is good for security (and some distros have it as a
 QA policy). GHC generated code does not need an executable stack
 so add the note to the assembly output of the native code
 generator (conditional on a configure test).
] 
[Complain more loudly if any of the hsc2hs phases fail
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060703234356
 previously hsc2hs just exits with a non-zero exit code, now if any of
 the compilation, linking or runing phases fail then we get a message
 saying so and the failing command is printed.
] 
[Remember to free() memory on exit
Simon Marlow <simonmar@microsoft.com>**20060808103110
 Patch mostly from Lennart Augustsson in #803, with additions to
 Task.c by me.
] 
[Fix pre-subsumption and pre-matching
simonpj@microsoft.com**20060808091108
 
 The pre-subsuption and pre-matching functions should NEVER make bogus
 bindings of type variables, although they are free to bale out and make
 too few bindings.
 
 I hadn't been thiking carefully enough about this, and there were two
 separate bugs.  
 
 - Firstly, in pre-subsumption we must ignore the 'theta'
   part of any overloaded type.  
 
 - Second, in pre-matching, we must return the empty subustition 
   on a mis-match, rather than returning the substitution so far.
 
 This bug showed up when compiling Data.Generics.Schemes.hs, and is
 imortalised in test tc206
 
] 
[Improve error message
simonpj@microsoft.com**20060808080255
 
 Improve a little-used error message.  Given
        f :: a -> a
        f x y = e
 the error says 
 
        The equations for f have two arguments
        but its type `a -> a' has only one
 
 (Before, it said "its type `a' has only one" which is bogus.
 
] 
[Pull out common removal code, and detect does-not-exist correctly
Ian Lynagh <igloo@earth.li>**20060710214308] 
[Create our own directory in the temporary directory to avoid various races
Ian Lynagh <igloo@earth.li>**20060710204424] 
[Merge SysTools import declarations
Ian Lynagh <igloo@earth.li>**20060709183850] 
[Don't freeze the dynamic flags used for filename generation before the pipeline starts
Ian Lynagh <igloo@earth.li>**20060709145101] 
[#807: Removed double fclose of prof_file
Ian Lynagh <igloo@earth.li>**20060708152424
 prof_file was being fclose'd in both gen_XML_logfile and hs_exit, leading
 to glibc complaining of a double free.
] 
[Add -fextended-default-rules and -fmono-pat-binds
simonpj@microsoft.com**20060807112107
 
 Add -fextended-deafult-rules (in response to Don Stewart's message below),
 and document them.
 
 Also doucument -fmono-pat-binds/-fno-mono-pat-binds, which has been in 
 GHC a few weeks now. 
 
 (The two are in one patch because the diffs were so close together
 that Darcs combined them.)
 
 Simon
 
 
 From: Donald Bruce Stewart [mailto:dons@cse.unsw.edu.au] 
 Sent: 07 August 2006 10:52
 
 While we're thinking about defaulting, I have a question..
 
 ghci uses an extended defaulting system, to allow things like:
         Prelude> reverse []
         []
 to work, and to have the right instance of Show found. The manual says:
 
     "..it is tiresome for the user to have to specify the type, so GHCi extends
     Haskell's type-defaulting rules (Section 4.3.4 of the Haskell 98 Report
     (Revised)) as follows. If the expression yields a set of type constraints
     that are all from standard classes (Num, Eq etc.), and at least one is
     either a numeric class or the Show, Eq, or Ord class, GHCi will try to use
     one of the default types, just as described in the Report. The standard
     defaulting rules require that one of the classes is numeric; the difference
     here is that defaulting is also triggered at least one is Show, Eq, or Ord."
 
 Currently, there is no way to get at this "extended" defaulting for compiled
 modules. However, I have a use case for in fact doing this.
 
 With runtime evaluated Haskell, embedding 'interpreters' (over hs-plugins) is
 easy. lambdabot, for example, implements a sandboxed haskell eval system. But
 it doesn't have access to the defaulting mechanism of ghci, so we have:
 
     dons:: > reverse []
     lambdabot:: Add a type signature
     dons:: > reverse [] :: [()]
     lambdabot:: []
 
 Which is annoying -- newbies wonder why they have to add these extra
 constraints to get a Show instance.
 
 I'm wondering, since the extended defaulting mechanisms are already
 implemented, could they be made available to compiled modules as well,
 perhaps using a flag, -fextended-defaulting? 
 
] 
[add a comment
Simon Marlow <simonmar@microsoft.com>**20060807143102] 
[Do pre-subsumption in the main subsumption check
simonpj@microsoft.com**20060804214942
 
 This patch improves the subsumption check (in TcUnify.tc_sub) so that
 it does pre-subsumption first.  The key code is in the case with
 guard (isSigmaTy actual_ty); note the new call to preSubType.
 
 Shorn of details, the question is this.  Should this hold?
 
        forall a. a->a   <=   Int -> (forall b. Int)
 
 Really, it should; just instantiate 'a' to Int.  This is just what
 the pre-subsumption phase (which used in function applications),
 will do.
 
 I did a bit of refactoring to achieve this.
 
 Fixes Trac #821.  Test tc205 tests.
 
] 
[Make unification robust to a boxy type variable meeting itself
simonpj@microsoft.com**20060801214302
 
 Previously, the implicit assumption in unification is that a boxy
 type variable could never occur on both sides of the unification,
 so that we'd never find 
        bx5 :=: bx5
 
 But the pre-subsumption stuff really means that the same variable
 can occur on both sides.  Consider
        forall a. a->Int <= bx5->Int
 Then pre-subumption will find a->bx5; and the full subsumption step 
 will find bx5:=bx5.
 
 However, I think there is still no possiblity of a full occurs-check
 failure; that is, 
        bx5 :=: Tree bx5
 Although I can't quite see how to prove it!  So I've added a
 DEBUG test in uMetaVar to check for this case.
 
] 
[Added cabal-setup
sven.panne@aedion.de**20060804142149] 
[Don't include the package name in a cost centre's module name
Simon Marlow <simonmar@microsoft.com>**20060803093337
 This is mainly to restore the old behaviour, but also we shouldn't
 normally need the package name in a cost centre because only the
 "main" package normally has cost centres.
] 
[Add a new section "Getting the Source" to both HACKING and README. But what about win32 users?
shae@ScannedInAvian.com**20060720152929] 
[savingOldConfig: add Exception.block for extra paranoia
Simon Marlow <simonmar@microsoft.com>**20060801131027
 
] 
[Refactor ghc-pkg
Ian Lynagh <igloo@earth.li>**20060729192946
 This patch fixes a couple of issues with the
     Be lazier in user config creation, and don't fail on missing configs.
 patch. It puts the createDirectoryIfMissing back in and removes assumptions
 that the package.conf file already exists.
] 
[No functionality changes
Ian Lynagh <igloo@earth.li>**20060730105256
 Consistently used spaces rather than tabs.
 Removed trailing whitespace.
 Wrapped comments to fit in a standard terminal.
] 
[Add notes about unsafeCoerce
simonpj@microsoft.com**20060731080922] 
[.hi-boot-5 is obsolete; the earliest GHC we support uses .hi-boot-6
Simon Marlow <simonmar@microsoft.com>**20060728140809
 
 
] 
[update to match .lhs-boot
Simon Marlow <simonmar@microsoft.com>**20060728140607] 
[get ReadP from the right place.
Simon Marlow <simonmar@microsoft.com>**20060728140444
 
] 
[Improve error message for deriving
simonpj@microsoft.com**20060727160832] 
[Lazy patterns are like wild-cards for overlap warnings
simonpj@microsoft.com**20060727155009
 
        MERGE TO STABLE
 
 Fixes Trac #827
 Test is should_compiler/ds058
 
] 
[fix some problems with wired-in packages
Simon Marlow <simonmar@microsoft.com>**20060727153802] 
[oops, remove old packages when updating
Simon Marlow <simonmar@microsoft.com>**20060727150650] 
[fix symbols for GHC.PrimopWrappers
Simon Marlow <simonmar@microsoft.com>**20060727134755] 
[a couple more symbols need package names
Simon Marlow <simonmar@microsoft.com>**20060727102129] 
[Add missing import
simonpj@microsoft.com**20060727085605] 
[Make -fcontext-stack into a dynamic flag
simonpj@microsoft.com**20060727080422
 
   This allows you to put -fcontext-stack into an options pragma,
   as requested by Trac #829
   
   While I was at it, I added OptIntPrefix to the forms allowed
   in CmdLineParser.
 
] 
[Deal correctly with infix type constructors in GADT decls
simonpj@microsoft.com**20060726225304] 
[Improve pretty printing of ConDecl
simonpj@microsoft.com**20060726225223] 
[fix parse error (merge-o, I think)
Simon Marlow <simonmar@microsoft.com>**20060726103526] 
[fix DEBUG build
Simon Marlow <simonmar@microsoft.com>**20060726103433] 
[missed one symbol that needs a package name
Simon Marlow <simonmar@microsoft.com>**20060726085844] 
[change wired-in Haskell symbols to include the package name
Simon Marlow <simonmar@microsoft.com>**20060726084659] 
[Unbox the Unique stored in a Name
Simon Marlow <simonmar@microsoft.com>**20060725141747
 I measured that this makes the comiler allocate a bit more, but it
 might also make it faster and reduce residency.  The extra allocation
 is probably just because we're not inlining enough somewhere, so I
 think this change is a step in the right direction.
] 
[optimisations to newUnique
Simon Marlow <simonmar@microsoft.com>**20060725140816
 
 It turned out that newUnique was wasting one node of the splittable
 uniq supply per invocation: it took the current supply, split it, used
 the unique from one half and stored the other half in the monad.  In
 other words, the unique in the supply stored in the monad was never
 used.  
 
 This optimisation fixes that and adds a bit of strictness, which
 together lead to small reduction in allocations by the compiler, and
 possibly an improvement in residency (hard to tell for sure when GCs
 move around).
] 
[tiny bit of extra strictness
Simon Marlow <simonmar@microsoft.com>**20060725131201] 
[Make a SplitUniqSupply contain an Int# rather than an Int
Simon Marlow <simonmar@microsoft.com>**20060725120252
 The I# constructor is always removed when we make a unique later
 anyway, so this just saves a bit of time and allocation.
] 
[Use -package-name rather than -ignore-package
Simon Marlow <simonmar@microsoft.com>**20060725130913] 
[Remove most of the conflict checking and auto-hiding
Simon Marlow <simonmar@microsoft.com>**20060725130850
 Now that the module restriction has been lifted, the auto-hiding is
 mostly not required.  GHC itself automatically hides old versions of a
 package.
] 
[Generalise Package Support
Simon Marlow <simonmar@microsoft.com>**20060725130154
 
 This patch pushes through one fundamental change: a module is now
 identified by the pair of its package and module name, whereas
 previously it was identified by its module name alone.  This means
 that now a program can contain multiple modules with the same name, as
 long as they belong to different packages.
 
 This is a language change - the Haskell report says nothing about
 packages, but it is now necessary to understand packages in order to
 understand GHC's module system.  For example, a type T from module M
 in package P is different from a type T from module M in package Q.
 Previously this wasn't an issue because there could only be a single
 module M in the program.
 
 The "module restriction" on combining packages has therefore been
 lifted, and a program can contain multiple versions of the same
 package.
 
 Note that none of the proposed syntax changes have yet been
 implemented, but the architecture is geared towards supporting import
 declarations qualified by package name, and that is probably the next
 step.
 
 It is now necessary to specify the package name when compiling a
 package, using the -package-name flag (which has been un-deprecated).
 Fortunately Cabal still uses -package-name.
 
 Certain packages are "wired in".  Currently the wired-in packages are:
 base, haskell98, template-haskell and rts, and are always referred to
 by these versionless names.  Other packages are referred to with full
 package IDs (eg. "network-1.0").  This is because the compiler needs
 to refer to entities in the wired-in packages, and we didn't want to
 bake the version of these packages into the comiler.  It's conceivable
 that someone might want to upgrade the base package independently of
 GHC.
 
 Internal changes:
 
   - There are two module-related types:
 
         ModuleName      just a FastString, the name of a module
         Module          a pair of a PackageId and ModuleName
 
     A mapping from ModuleName can be a UniqFM, but a mapping from Module
     must be a FiniteMap (we provide it as ModuleEnv).
 
   - The "HomeModules" type that was passed around the compiler is now
     gone, replaced in most cases by the current package name which is
     contained in DynFlags.  We can tell whether a Module comes from the
     current package by comparing its package name against the current
     package.
 
   - While I was here, I changed PrintUnqual to be a little more useful:
     it now returns the ModuleName that the identifier should be qualified
     with according to the current scope, rather than its original
     module.  Also, PrintUnqual tells whether to qualify module names with
     package names (currently unused).
 
 Docs to follow.
] 
[comment formatting
Simon Marlow <simonmar@microsoft.com>**20060725110519
 
] 
[unused import
Simon Marlow <simonmar@microsoft.com>**20060706141349] 
[unused import
Simon Marlow <simonmar@microsoft.com>**20060706141205] 
[remove more Addr bits
Simon Marlow <simonmar@microsoft.com>**20060704151217] 
[unused import
Simon Marlow <simonmar@microsoft.com>**20060704141319] 
[add default cases
Simon Marlow <simonmar@microsoft.com>**20060704135444] 
[redundant import
Simon Marlow <simonmar@microsoft.com>**20060704135435] 
[unused imports
Simon Marlow <simonmar@microsoft.com>**20060704135117] 
[unused import
Simon Marlow <simonmar@microsoft.com>**20060704134557] 
[remove unused bits, mostly to do with the Addr type
Simon Marlow <simonmar@microsoft.com>**20060704124912] 
[In interface files, store FastStrings rather than OccNames where possible
Simon Marlow <simonmar@microsoft.com>**20060724154826
 In all cases the namespace is known from the context, so this saves 1
 byte per variable binding/occurrence (a few percent per iface file).
] 
[Add -fmono-pat-binds, and make it the default
simonpj@microsoft.com**20060722102245
 
 In Haskell 98, pattern bindings are generalised.  Thus in
        (f,g) = (\x->x, \y->y)
 both f and g will get polymorphic types.  I have become convinced
 that generalisation for pattern-bound variables is just a bridge
 toof far. It is (I claim) almost never needed, and it adds significant
 complication.  (All the more so if we add bang patterns.)
 
 So the flag -fmono-pat-binds switches off generalisation for pattern
 bindings.  (A single variable is treated as a degnerate funtction
 binding.)  
 
 Furthremore, as an experiment, I'm making it the default.  I want
 to see how many progarms fail with monomorphic pattern bindings.
 
 You can recover the standard behaviour with -fno-mono-pa-binds.
 
] 
[Fix RULES lossage
simonpj@microsoft.com**20060722101756
 
 Don Stewart and Duncan Coutts encountered the following situation.
        f = <rhs>
        {-# RULES f ... #-}
 where f is not exported, but appears in the inlinings of other
 functions that are exported.  Then what happened was that the desugarer
 produced this:
        M.f = f
        f = <rhs>
 where the rules get attached to the M.f. But since M.f's RHS is trivial
 (just f) it was unconditionally inlinined at all its call sites, 
 thereby losing the RULES attached to it.
 
 This *is* a fragile aspect of rules. However this fix solves the 
 problem by instead generating
        f = M.f
        M.f = <rhs>
 
 A pretty small chanage to the desugarer does the job.  It still feels
 a little fragile, bt it's certainly more robust than before.
 
] 
[Fix broken regex
Simon Marlow <simonmar@microsoft.com>**20060721111144
 Don't know how I managed to use this before... maybe a different regex
 library.
] 
[fix bug in sample code
Simon Marlow <simonmar@microsoft.com>**20060721083200] 
[fix eran error message by reordering a couple of tests
simonmar@microsoft.com**20060719111638] 
[Use a recursive error handler in case the exception causes more exceptions.
Lemmih <lemmih@gmail.com>**20060717232553] 
[Check for overlap-flag differences in hi files
simonpj@microsoft.com**20060714163843
 
        MERGE TO STABLE
 
 I'd forgotten to compare the per-instance overlap flag when 
 comparing interface files, and that meant that consequential
 recompilations weren't being triggered when the only change
 was to add -fallow-overlapping-instances
 
 Fixes Trac bug #824
 
 
] 
[Add a clarification about overlapping instances in the manual
simonpj@microsoft.com**20060714143220] 
[Comments and import trimming
simonpj@microsoft.com**20060712153306] 
[Experimental flag -fdicts-cheap
simonpj@microsoft.com**20060712153204
 
 This experimental flag, -fdicts-cheap, makes a let-binding that bind a
 value of dictionary type look cheap.  That in turn leads to more
 eta expansion.  Instead of
        f = /\a. \(d1:Ord a). let d2:Ord [a] = dfOrd a d1 in
                  \(x:a). <stuff>
 which has arity 1, you get
        f = /\a. \(d1:Ord a). \(x:a).
                 let d2:Ord [a] = dfOrd a d1 in <stuff>
 Now f has arity 2.
 
 This can cretainly waste dictionary-construction work, if f is
 partially applied to its dictionary argument.  However it has knock-on
 effects.  Because f has arity 2, we won't float (f Int d) out of
        \x. h (f Int d)
 Floating f out of this lambda makes it impossible for an h/f fusion
 rule to fire; and this unexpected loss of RULE application was the
 immediate reason for implementing this flag. (Roman Leshchinskiy came
 across this when working on array fusion.)
 
 
 I've implemented the change only in CoreUtils.arityType, which
 only affects eta expansion.  I thought of putting the change in
 exprIsCheap, which is a more systematic place (the former calls
 the latter) but
 
        a) I wanted this under flag control, and the flags 
        are not readily available to all callers of exprIsCheap
 
        b) I'm not 100% convinced that this change is a good
        idea, so it's reasonable to do the narrowest change
        that solves the immediate problem.
] 
[document that -fglasgow-exts is needed for RULES to work
Malcolm.Wallace@cs.york.ac.uk**20060712093907] 
[do a better job of ignoring unrecognised pragmas
Simon Marlow <simonmar@microsoft.com>**20060712083550] 
[Don't z-encode module names in external-core output
Jan Rochel <jan.rochel@stud.uka.de>**20060706131109] 
[re-add -fvia-C
Simon Marlow <simonmar@microsoft.com>**20060710081522
 There are still some fixes required to get the threaded RTS compilable
 with the NCG, and apparently there are problems on 32-bit archs too.
 
] 
[Be lazier in user config creation, and don't fail on missing configs.
Ian Lynagh <igloo@earth.li>**20060624230800] 
[Z-Encode external-core output
Jan Rochel <jan.rochel@stud.uka.de>**20060702214438
 
 HEAD doesn't z-encode external-core output (unlike 6.4). I suppose, that
 this is unwanted behaviour. It probably results from this patch:
 
 ========================================================================
 Fri Jan  6 17:30:19 CET 2006  simonmar
   * [project @ 2006-01-06 16:30:17 by simonmar]
   Add support for UTF-8 source files
 
 [...]    
 
 Z-encoding has been moved right to the back end.  Previously we
 used to Z-encode every identifier on the way in for simplicity,
 and only decode when we needed to show something to the user.
 Instead, we now keep every string in its UTF-8 encoding, and
 Z-encode right before printing it out.
 
 [...]
 ========================================================================
 
 Greetings
 Jan
] 
[Add %local-tag to external core output
Jan Rochel <jan.rochel@stud.uka.de>**20060702204559
 
 Hello, this is my first patch contributed to GHC. If there are any
 inadequacies about it (maybe like this introductory disclaimer), please
 let me know about it.
 
 So, the need for this patch arose, while I was involved with processing
 hcr files (external core output) and I noticed, that the output didn't
 fully conform to the specification [1].
 No %local-tags were used, which turned out to be a real nuisance as it
 was not possible to determine which VDEFs can be erased in a further
 optimization process and which ones are exported by the module.
 
 Since the specification does not define the meaning of the %local-tag, I
 assume, it makes sense, that it tags all functions, that are not
 exported by the module.
 
 The patch does not fully comply to the specification, as in my
 implementation a local tag may appear before a VDEF but not before a
 VDEFG.
 
 [1] An External Representation for the GHC Core Language
     (DRAFT for GHC5.02), page 3, line 1
 
 Greetings
 Jan
] 
[Remove bashisms from darcs-all
Alec Berryman <alec@thened.net>**20060703012911
 
 darcs-all may now be run with any POSIX-compatible /bin/sh.
] 
[Fix for warning message (bug #812)
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060704163413
 say "{-# SOURCE #-}" rather than "{- SOURCE -}" in warning message.
 Fixes http://hackage.haskell.org/trac/ghc/ticket/812
] 
[The dict-bindings in an IPBinds need not be in dependency order
simonpj@microsoft.com**20060703151517
 
 This appears to be a long-standing bug, discovered by BlueSpec 
 (ravi@bluespec.com), Trac bug #795
 
 The problem was that in an IP binding group, the dict bindings
 aren't necessarily in dependency order; and if they aren't 
 we get a core-lint error.
 
 Test tc203 checks this case.  (Though whether it shows up at
 all depends a bit on accidental factors of binding ordering.)
 
] 
[x86 needs -fno-unit-at-a-time too
Simon Marlow <simonmar@microsoft.com>**20060704083308
 Fixes #809
] 
[x86-64: fix a problem exposed by negative offsets in vector tables
Simon Marlow <simonmar@microsoft.com>**20060629140608
 static relative offsets (eg .long l1-l2) are restricted to 32 bits on
 x86-64 due to lack of support in the linker.  The codegen, NCG and
 runtime work around this, using 32-bit offsets instead of 64.
 However, we were missing a workaround for vector tables, and it
 happened to work by accident because the offsets were always positive
 and resolved by the assembler.  The bug was exposed by using the NCG
 to compile the RTS, where the offsets became negative, again by
 accident.
] 
[No longer force -fvia-C for the RTS, it can now be compiled with the NCG
Simon Marlow <simonmar@microsoft.com>**20060629135836] 
[Replace inline C functions with C-- macros in .cmm code
Simon Marlow <simonmar@microsoft.com>**20060629134726
 So that we can build the RTS with the NCG.
] 
[remove conditionals from definition of StgRegTable
Simon Marlow <simonmar@microsoft.com>**20060629134405
 so that we can calculate deterministic offsets to some of the fields
 of Capability.
] 
[mpz_foo() functions are really called __gmpz_foo() in GMP
Simon Marlow <simonmar@microsoft.com>**20060629122217
 gmp.h #defines mpz_foo to __gmpz_foo, so the real ABI is __gmpz_foo,
 so that is what we must invoke in order to be portable here.
 Similarly for mpn --> __gmpn.
] 
[use the new "prim %write_barrier()" in .cmm instead of calls to wb()
Simon Marlow <simonmar@microsoft.com>**20060629120526] 
[fix some problems with the fixup block code
Simon Marlow <simonmar@microsoft.com>**20060629120210
 We weren't handling InBoth properly.  InBoth needs to be expanded to
 appropriate InReg/InMem locations *before* building the interference
 graph, otherwise an InBoth will not be seen to conflict with other
 InReg/InMem locations.
] 
[small optimisation: eliminate more register-to-register moves
Simon Marlow <simonmar@microsoft.com>**20060629120029] 
[new syntax: "prim %OP (args)"  for using CallishMachOps in .cmm
Simon Marlow <simonmar@microsoft.com>**20060629115949
 
 
] 
[add MO_WriteBarrier to CallishMachOps
Simon Marlow <simonmar@microsoft.com>**20060629115837
 This will let us express write barriers in C--
] 
[Use -fno-strict-aliasing for *all* C files in the runtime
Simon Marlow <simonmar@microsoft.com>**20060629082902
 as a precautionary measure.  It is definitely required for GC.c,
 but it may well become necessary for other files in the future due to
 our (mis-)use of the C "type system".
] 
[the unlifted kind
Simon Marlow <simonmar@microsoft.com>**20060623152626] 
[fix a lint-o
Simon Marlow <simonmar@microsoft.com>**20060620151901] 
[fix sloppy conditionals
Simon Marlow <simonmar@microsoft.com>**20060620151758] 
[fix sloppy conditionals
Simon Marlow <simonmar@microsoft.com>**20060620151039] 
[fix a few sloppy conditionals caught by new test in CmmLint
Simon Marlow <simonmar@microsoft.com>**20060620150618] 
[flattenCgStmts: fix a case of empty code blocks being generated
Simon Marlow <simonmar@microsoft.com>**20060620150520] 
[improve a panic message
Simon Marlow <simonmar@microsoft.com>**20060620141219] 
[check that the argument to CmmCondBranch is really a conditional
Simon Marlow <simonmar@microsoft.com>**20060620141204] 
[Generate a new unique for each label
Simon Marlow <simonmar@microsoft.com>**20060620140106] 
[Remove long-redundant FieldLabel.lhs
simonpj@microsoft.com**20060629105321] 
[Add comments to SpecConstr
simonpj@microsoft.com**20060627161520] 
[fix up slop-overwriting for THUNK_SELECTORS in DEBUG mode
Simon Marlow <simonmar@microsoft.com>**20060627123951] 
[Make SpecConstr work better for nested functions
simonpj@microsoft.com**20060627094742
 
 In SpecConstr.scBind, we should pass the optimised body (body') to
 specialise, not the un-optimised one. In this way we'll benefit from
 specialising any nested functions inside body.
 
 Discovered by Roman.
 
] 
[More SpecConstr tuning
simonpj@microsoft.com**20060626201709
 
 For some reason, SpecConstr wasn't taking account of let-bound constructors:
        let v = Just 4
        in ...(f v)...
 
 Now it does.  An easy fix fortunately.
 
] 
[Improve consistency checking for derived instances
simonpj@microsoft.com**20060626100034
 
 This patch arranges that derived instances use the same instance-decl
 checking code as user-defined instances.  That gives greater consistency
 in error messages.
 
 Furthermore, the error description if this consistency check fails is now
 much more explicit.  For example, drvfail003 now says
      Variable occurs more often in a constraint than in the instance head
        in the constraint: Show (v (v a))
      (Use -fallow-undecidable-instances to permit this)
      In the derived instance
        instance (Show (v (v a))) => Show (Square_ v w a)
 
] 
[Slight improvement in TH error reporting
simonpj@microsoft.com**20060626095952] 
[Improve location info when typechecking interface fiels
simonpj@microsoft.com**20060614114813] 
[Fix a bug in the pretty printing of class declarations
davve@dtek.chalmers.se**20060625160826] 
[Improve RULE matching a bit more
simonpj@microsoft.com**20060624160421
 
 Consider this example (provided by Roman)
 
        foo :: Int -> Maybe Int -> Int
        foo 0 (Just n) = n
        foo m (Just n) = foo (m-n) (Just n)
 
 SpecConstr sees this fragment:
 
        case w_smT of wild_Xf [Just A] {
          Data.Maybe.Nothing -> lvl_smf;
          Data.Maybe.Just n_acT [Just S(L)] ->
            case n_acT of wild1_ams [Just A] { GHC.Base.I# y_amr [Just L] ->
            $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf
            }};
 
 and correctly generates the rule
 
        RULES: "SC:$wfoo1" [0] __forall {y_amr [Just L] :: GHC.Prim.Int#
                                          sc_snn :: GHC.Prim.Int#}
          $wfoo_smW sc_snn (Data.Maybe.Just @ GHC.Base.Int (GHC.Base.I# y_amr))
          = $s$wfoo_sno y_amr sc_snn ;]
 
 BUT we must ensure that this rule matches in the original function!
 Note that the call to $wfoo is
            $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf
 
 During matching we expand wild_Xf to (Just n_acT).  But then we must also
 expand n_acT to (I# y_amr).  And we can only do that if we look up n_acT
 in the in-scope set, because in wild_Xf's unfolding it won't have an unfolding
 at all. 
 
 Happily, fixing the bug is easy: add a call to 'lookupRnInScope' in the 
 (Var v2) case of 'match'.
 
] 
[--enable-src-tree-haddock and friends are no longer required
Simon Marlow <simonmar@microsoft.com>**20060623113303
 Happy, Alex and Haddock are built separately using Cabal now.
] 
[fix a couple of bugs in markSparkQueue (#799)
Simon Marlow <simonmar@microsoft.com>**20060623092044] 
[pull in STABLE(!) tweaks
sof@galois.com**20060622202734] 
[fix for when path to GHC contains spaces, from #695
Simon Marlow <simonmar@microsoft.com>**20060622131700] 
[Comment only
simonpj@microsoft.com**20060621223940] 
[Transfer INLINE to specialised functions
simonpj@microsoft.com**20060621223637
 
 When the Specialise pass generates a specialised copy of a function,
 it should transfer the INLINE information to the specialised function.
 Otherwise, whether or not the INLNE happens can depend on whether
 specialisation happens, which seems wrong.  See Note [Inline specialisation]
 in Specialise.lhs
 
 Here's the example Roman reported
 
     primWriteMU :: UAE e => MUArr e s -> Int -> e -> ST s ()
     {-# INLINE primWriteMU #-}
     primWriteMU = writeMBU . unMUAPrim
     ------
     
     The problem is that primWriteMU doesn't get inlined *sometimes*, which
     results in code like
     
     case Data.Array.Parallel.Unlifted.Flat.UArr.$sprimWriteMU
            @ s11_X1nJ
            marr_s25s
            (GHC.Base.I# sc_s27F)
            GHC.Base.False
            new_s_a1Db
            of wild3_a1Dd { (# new_s1_X1F9, r_a1Dc #) -> ...
 
 Note the fact that we have a call to the *specialised* $sprimWriteMU.
 
] 
[Arity and eta-expansion tuning
simonpj@microsoft.com**20060621205855
 
 Roman found that 
     loop :: STRef s a -> Int -> ST s Int
     loop ref n = case n of
                    0 -> return n
                    n -> loop ref (n-1)
 wasn't eta-expanding nicely, despite the 'state hack'
 (see Id.isStateHackType).  The reason was two-fold:
 
   a) a bug in CoreUtils.arityType (the Var case)
 
   b) the arity of a recursive function was not being
        exposed in its RHS (see commments with
        SimplEnv.addLetIdInfo
 
 The commit fixes both.  
 
] 
[documentation for TH w/ profiling
Simon Marlow <simonmar@microsoft.com>**20060621112523] 
[Allow Template Haskell to be used with -prof
Simon Marlow <simonmar@microsoft.com>**20060621110436
 
 In order for this to work, you need to build the program first in the
 normal way (without -prof), and then again with -prof and a suitable
 -osuf (eg. -osuf p_o).  The compiler will pick up the object files
 from the normal way for running TH expressions, when it sees -prof
 together with -osuf.  If you omit the -osuf, you get an error message:
 
 TH_genEx.hs:12:2:
     Dynamic linking required, but this is a non-standard build (eg. prof).
     You need to build the program twice: once the normal way, and then
     in the desired way using -osuf to set the object file suffix.
 
 If you use -osuf, but haven't built the program the normal way first,
 then you see:
 
 TH_genEx.hs:12:2:
     cannot find normal object file `TH_genExLib.o'
     while linking an interpreted expression
 
 Documentation to follow.
 
 Fixes: #651
] 
[add decl for stg_block_throwto_ret
Simon Marlow <simonmar@microsoft.com>**20060620083410] 
[comment out a non-true assertion
Simon Marlow <simonmar@microsoft.com>**20060616140750] 
[make compilation a little less noisy
Simon Marlow <simonmar@microsoft.com>**20060616140652] 
[allow the max number of workers to scale with +RTS -N
Simon Marlow <simonmar@microsoft.com>**20060616140633] 
[fix one-character error in stack check
Simon Marlow <simonmar@microsoft.com>**20060616135621] 
[add STM support to the new throwTo mechanism
Simon Marlow <simonmar@microsoft.com>**20060616111937] 
[remove duplicate way names (-debug -debug didn't work)
Simon Marlow <simonmar@microsoft.com>**20060616110258] 
[Asynchronous exception support for SMP
Simon Marlow <simonmar@microsoft.com>**20060616103342
 
 This patch makes throwTo work with -threaded, and also refactors large
 parts of the concurrency support in the RTS to clean things up.  We
 have some new files:
 
   RaiseAsync.{c,h}     asynchronous exception support
   Threads.{c,h}         general threading-related utils
 
 Some of the contents of these new files used to be in Schedule.c,
 which is smaller and cleaner as a result of the split.
 
 Asynchronous exception support in the presence of multiple running
 Haskell threads is rather tricky.  In fact, to my annoyance there are
 still one or two bugs to track down, but the majority of the tests run
 now.
] 
[make rmp_tmp_w an StgWord instead of StgInt
Simon Marlow <simonmar@microsoft.com>**20060616102311] 
[__compat_long_path_size(): have proto and defn agree on return type
sof@galois.com**20060614164650] 
[call wakeUpRts() in the correct place
Simon Marlow <simonmar@microsoft.com>**20060614134728] 
[readerProc: split up text output using host's line termination convention
sof@galois.com**20060613232605] 
[Improve pretty-printing for bags
simonpj@microsoft.com**20060612114020] 
[Make scoped type variables work for default methods
simonpj@microsoft.com**20060612113855
 
 Consider
   class C a where
     op :: forall b. a -> b -> b
     op = <rhs>
 
 Then 'b' should be in scope in <rhs>.  I had omitted this case.
 This patch fixes it.
 
] 
[And move 'Chasing ...' messages into verbosity 2 as well
Don Stewart <dons@cse.unsw.edu.au>**20060612084656] 
[Emit 'linking not required' messages only with -v 2 or above.
Don Stewart <dons@cse.unsw.edu.au>**20060611071041
 
 Similar in philosophy to the 'Skipping' patch, this is another case of
 printing noisy messages when no work is being done. This patch makes the
 building-when-nothing-to-do case smoother.
 
] 
[Don't emit 'Skipping' messages unless -v2 or higher is on
Don Stewart <dons@cse.unsw.edu.au>**20060610145713
 
 Following GNU make, this patch makes GHC not emit messages about modules
 its skipping. This makes builds much quieter, and its a lot easier to
 work out what effects a change had on the code.
 
 The current behaviour can be recovered with -v2
 
] 
[fix the stage3 build
Simon Marlow <simonmar@microsoft.com>**20060612084114] 
[oops, undo accidental commit of version number
Simon Marlow <simonmar@microsoft.com>**20060612083520] 
[Move readline configuration into the readline package
Simon Marlow <simonmar@microsoft.com>**20060609135840] 
[fix possible ^C problems
Simon Marlow <simonmar@microsoft.com>**20060608144457
 Calling prodAllCapabilities() from interruptStgRts() was wrong, for
 the same reasons that we stopped doing it in handle_tick().  We now
 use the same mechanism (send a byte down the pipe to the IO manager
 thread), but abstract it in a wakeUpRts() function in the scheduler.
] 
[New tracing interface
Simon Marlow <simonmar@microsoft.com>**20060608144210
 A simple interface for generating trace messages with timestamps and
 thread IDs attached to them.  Most debugging output goes through this
 interface now, so it is straightforward to get timestamped debugging
 traces with +RTS -vt.  Also, we plan to use this to generate
 parallelism profiles from the trace output.
] 
[fix warnings
Simon Marlow <simonmar@microsoft.com>**20060608143635] 
[fix warnings
Simon Marlow <simonmar@microsoft.com>**20060608143520] 
[Make it so that StgWord/StgInt are longs
Simon Marlow <simonmar@microsoft.com>**20060608143438
 This means we can use a %ld format specifier for StgWord/StgInt with
 printf and not get shouted at by gcc.
] 
[more warning fixage
Simon Marlow <simonmar@microsoft.com>**20060608142844] 
[fix a warning
Simon Marlow <simonmar@microsoft.com>**20060608141903] 
[fix some warnings
Simon Marlow <simonmar@microsoft.com>**20060608140201] 
[Add new RTS flags for tracing:
Simon Marlow <simonmar@microsoft.com>**20060608130101
 
   -vs       Trace scheduler events (see also -Ds with -debug)
   -vt       Time-stamp trace messages
 
 the intention is that we will pipe the -vs output into a
 profile-generating tool.  This commit includes the flags only,
 functionality to follow.
] 
[codegen debug flag (+RTS -Dc) was unused; remove it
Simon Marlow <simonmar@microsoft.com>**20060607145848] 
[add 'const' modifiers to types where appropriate
Simon Marlow <simonmar@microsoft.com>**20060607145800] 
[rearrange casts to avoid gcc warnings
Simon Marlow <simonmar@microsoft.com>**20060607145626] 
[warning fix
Simon Marlow <simonmar@microsoft.com>**20060607141013] 
[remove //@ stuff
Simon Marlow <simonmar@microsoft.com>**20060607134553] 
[Gather timing stats for a Task when it completes.
Simon Marlow <simonmar@microsoft.com>**20060607124407
 Previously we did this just for workers, now we do it for the main
 thread and for forkOS threads too.
] 
[Remove unnecessary SCHED_INTERRUPTED scheduler state
Simon Marlow <simonmar@microsoft.com>**20060607115105
 
] 
[fix a warning
Simon Marlow <simonmar@microsoft.com>**20060427130048] 
[re-enable time package on Windows
simonmar@microsoft.com**20060606124656] 
[fix a case of "naughty I386 byte reg"
Simon Marlow <simonmar@microsoft.com>**20060606112357
 The fix is a little hacky, because we don't have support for register
 classes in general, but it's an improvement.
] 
[A better icon for GHCi
Neil Mitchell <http://www.cs.york.ac.uk/~ndm/>**20060602145913] 
[markSignalHandlers(): implementation was unnecessary, and had a bug
simonmar@microsoft.com**20060606085805
 
 There's no need to mark the signal handler here, because it is stored
 in a StablePtr and hence is a root anyway.  Furthermore, the call to
 evac() was passing the address of a local variable, which turned out
 to be harmless for copying GC, but fatal for compacting GC: compacting
 GC assumes that the addresses of the roots are the same each time.
 
 Fixes: possibly #783, possibly #776, definitely #787
] 
[disable time package on mingw to unblock builds.
sof@galois.com**20060605165125] 
[Remove one more IfaceInlineCall
simonpj@microsoft.com**20060605154305] 
[Remove InlinePlease and add inline function and RULE
simonpj@microsoft.com**20060605114900
 
 For a long time GHC has had some internal mechanism designed to support
 a call-site inline directive, thus
        inline f xs
 makes f be inlined at the call site even if f is big.
 
 However, the surface syntax seems to have gone, and in any case it
 can be done more neatly using a RULE.
 
 This commit:
   * Removes the InlineCall constructor for Note
     and InlinePlease for SimplCont
 
   * Adds a new known-key Id called 'inline', whose definition in
     GHC.Base is just the identity function
 
   * Adds a built-in RULE in PrelRules that rewrites (inline f) to
     the body of f, if possible
 
   * Adds documentation
 
 NOTE: I have not tested this (aeroplane work).  Give it a try!
 
] 
[Fix typo
simonpj@microsoft.com**20060605114719] 
[fix type of allocateExec
Simon Marlow <simonmar@microsoft.com>**20060601125406] 
[stgMallocBytesRWX --> allocateExec
Simon Marlow <simonmar@microsoft.com>**20060601123314] 
[fix non-Windows build
Simon Marlow <simonmar@microsoft.com>**20060601121435] 
[Win32: set up the console code pages
simonmar@microsoft.com**20060601115423
 This may help with entering non-ASCII characters at the GHCi prompt,
 but as usual with Unicode there's no simple solution that just works.
 See commentary in InteractiveUI.hs for more details.
] 
[add a type signature
simonmar@microsoft.com**20060601115335] 
[improvements to lexical error reporting
simonmar@microsoft.com**20060601115306] 
[commented-out debugging code
simonmar@microsoft.com**20060601115247] 
[understand Latin-1 symbols
simonmar@microsoft.com**20060601115149] 
[stgMallocBytesRWX --> allocateExec
Simon Marlow <simonmar@microsoft.com>**20060531091202
 Not sure how I left this out of the previous patch, oh well.
] 
['time' depends on 'Win32' when Windows=YES; mirror that
sof@galois.com**20060530223009
 when setting up SUBDIRS.
] 
[Win32: add _imp__tzname
simonmar@microsoft.com**20060530101452] 
[fix Win32 build
simonmar@microsoft.com**20060530101418] 
[replace stgMallocBytesRWX() with our own allocator
Simon Marlow <simonmar@microsoft.com>**20060530100211
 
 See bug #738
 
 Allocating executable memory is getting more difficult these days.  In
 particular, the default SELinux policy on Fedora Core 5 disallows
 making the heap (i.e. malloc()'d memory) executable, although it does
 apparently allow mmap()'ing anonymous executable memory by default.
 
 Previously, stgMallocBytesRWX() used malloc() underneath, and then
 tried to make the page holding the memory executable.  This was rather
 hacky and fails with Fedora Core 5.  
 
 This patch adds a mini-allocator for executable memory, based on the
 block allocator.  We grab page-sized blocks and make them executable,
 then allocate small objects from the page.  There's a simple free
 function, that will free whole pages back to the system when they are
 empty.
 
] 
[add time subdir
Simon Marlow <simonmar@microsoft.com>**20060530070721] 
[Make rule-matching robust to lets
simonpj@microsoft.com**20060525154447
 
 Consider a RULE like
        forall arr. splitD (joinD arr) = arr
 
 Until now, this rule would not match code of form
        splitD (let { d = ... } in joinD (...d...))
 because the 'let' got in the way.
 
 This patch makes the rule-matcher robust to lets.  See comments with
 the Let case of Rules.match.
 
 This improvement is highly desirable in the fusion rules for NDP
 stuff that Roman is working on, where we are doing fusion of *overloaded*
 functions (which may look lazy).  The let expression that Roman tripped
 up on was a dictioary binding.
 
] 
[Improve error reporting in interface typechecking
simonpj@microsoft.com**20060525094545] 
[Fix egregious and long-standing tidying bug
simonpj@microsoft.com**20060525094300
 
 A typo in tidyAlt meant that we could get shadowing of occurrence names
 in the output of tidying.  (Specifically, of existentially bound type 
 variables.)  That in turn meant that an IfaceExpr could have shadowing, so
 when the IfaceExpr was read in, it meant something different.
 That in turn led to an obscure crash like:
        Panic: tcIfaceTyVar
 
 Anyway, this fixes it.  MERGE into 6.4.3.
 
 
] 
[Prune imports
simonpj@microsoft.com**20060525094251] 
[performGC_(): don't use the existing Task, always grab a new one
Simon Marlow <simonmar@microsoft.com>**20060525090035] 
[Better control of the IO manager thread; improvements to deadlock checking
Simon Marlow <simonmar@microsoft.com>**20060524122839
     
 In the threaded RTS on *nix platforms:
     
  - we now start the IO manager thread eagerly at startup time
    (previously was started on demand).
 
  - we now ask the IO manager thread to stop at shutdown
     
  - In Timer.c:handle_tick, if it looks like we might be in a
    deadlock, instead of calling prodOneCapability() which was known to be
    wrong, we now send a byte down the IO manager's pipe to wake it up.
   
 This also avoids a case of double-acquisition of a mutex, which
 happened if prodOneCapability() was called while the current thread
 was holding a mutex.
] 
[TARGET_OS ==> HOST_OS
Simon Marlow <simonmar@microsoft.com>**20060524122103] 
[fix a _TARGET_ARCH that should be _HOST_ARCH
Simon Marlow <simonmar@microsoft.com>**20060524122022] 
[we don't need OutOfHeapHook(), and the version in the RTS has a better message
Simon Marlow <simonmar@microsoft.com>**20060524112007] 
[Bug-fix to patch "Run simplifier before SpecConstr"
simonpj@microsoft.com**20060523130022] 
[Run simplifier before SpecConstr
simonpj@microsoft.com**20060523085546
 
 Arrange to run the simplifier before SpecConstr, to (almost entirely) 
 eliminate shadowing.
 
 Reason: otherwise SpecConstr can generate a RULE that never
 files; and LiberateCase specifically *does* generate lots of shadowing.
 
 See Note [Shadowing] in SpecConstr.lhs
 
 
] 
[Prune imports
simonpj@microsoft.com**20060522192532] 
[Add deShadowBinds
simonpj@microsoft.com**20060522192404
 
 Add CoreSubst.deShadowBinds, which removes shadowing from 
 a Core term.  I thought we wanted it for SpecConstr, but in 
 fact decided not to use it. Nevertheless, it's a useful sort
 of function to have around, and it has a particularly simple
 definition!
 
] 
[Inline in a call argument if the caller has RULES
simonpj@microsoft.com**20060522163255
 
 This is an experimental change suggested by Roman.  Consider
        
        {-# INLINE f #-}
        f x y = ...
 
        ....(g (f a b))...
 
 where g has RULES.  Then we'd like to inline f, even though the context of
 the call is otherwise 100% boring -- g is lazy and we know nothing about
 x and y. 
 
 This patch just records in the continuation that f has rules.  And does so
 somewhat recursively...e.g.
 
        ...(g (h (f a b)))...
 
 where g has rules.  
 
 
] 
[Add idHasRules
simonpj@microsoft.com**20060522163109
 
 Add Id.idHasRules :: Id -> Bool, with the obvious semantics.
 This patch makes sense by itself, but it's just a tidy-up.
 
 
] 
[Transmit inline pragmas faithfully
simonpj@microsoft.com**20060522110256
 
 *** WARNING: you will need to recompile your libraries 
 ***         when you pull this patch (make clean; make)
 
 The inline pragma on wrapper-functions was being lost; this patch 
 makes it be transmitted faithfully.
 
 The reason is that we don't write the full inlining for a wrapper into
 an interface file, because it's generated algorithmically from its strictness
 info.  But previously the inline pragma as being written out only when we
 wrote out an unfolding, and hence it was lost for a wrapper.
 
 This makes a particular difference when a function has a NOINLINE[k] pragma.
 Then it may be w/w'd, and we must retain the pragma.  It's the only consistent
 thing to do really.
 
 The change does change the binary format of interface files, slightly.
 So you need to recompile all your libraries.
 
] 
[Improved RULE lhs typechecking; less dictionary sharing
simonpj@microsoft.com**20060519103433
 
 See long comment with Simplify.tcSimplifyRuleLhs.
 
 Here's the key example:
 
   RULE "g"  forall x y z. g (x == y) (y == z) = ...
 
 Here, the two dictionaries are *identical*, but we do NOT WANT to
 generate the rule
 
 RULE   forall x::a, y::a, z::a, d1::Eq a
          f ((==) d1 x y) ((>) d1 y z) = ...
 
 Instead we want
 
 RULE   forall x::a, y::a, z::a, d1::Eq a, d2:Eq a
          f ((==) d1 x y) ((>) d2 y z) = ...
 
] 
[Bug-fix for infix function definitions (parse/rename)
simonpj@microsoft.com**20060519095022
   
 Fix a crash provoked by
 
        x `op` y = x
        op       = True
 
 The trouble was that there is currently a single 'infix' flag for the
 whole group; and RnTypes.checkPrecMatch was therefore expecting the
 second eqn to have two args.
 
 This fixes the crash, and also or-s the infix flags for the various
 eqns together; previously it was just taken from the first eqn, which
 was wrong.
 
 
] 
[Remove misleading comments
simonpj@microsoft.com**20060519094936] 
[Fix a nasty continuation-duplication bug
simonpj@microsoft.com**20060518163617
 
 For a long-time mkDupableCont has had a bug that allows it to duplicate
 an arbitrary continuation, which it should not do, of course.
 
 The bug was that in the Select case of mkDupableCont we were calling
 prepareCaseCont, which did not duplicate the continuation if there is
 but a single alternative.  This is quite right in the case of the call
 in rebuildCase, but quite wrong in mkDupableCont.
 
 The bug manifest as follows. In the expression
        f (case ... of { ..several alts.. })
 (when f is strict), we should transform to
        f (...transformed arg...)
 The application of f should not be pushed down (see notes with the
 ArgOf case of mkDupableCont.  But that was not happening in an example
 like this (see how the call to f is pushed inwards).
 
 f (a `div` abs (b::Int))
        --->
     case b_afT of wild_aHa { GHC.Base.I# x_aHc ->
     let {
       $j_sIe :: GHC.Prim.Int# -> GHC.Base.Int
       []
       $j_sIe =
        \ (ds1_aHr [Nothing OneShot] :: GHC.Prim.Int#) ->
          Foo7.f
            (case ds1_aHr of ds2_aHq {
               __DEFAULT ->
                 case a_afS of wild1_aHM { GHC.Base.I# x_aHO ->
                 GHC.Base.I# (GHC.Base.divInt# x_aHO ds2_aHq)
                 };
               0 -> GHC.Err.divZeroError @ GHC.Base.Int
             })
     } in 
       case GHC.Prim.>=# x_aHc 0 of wild1_aHe [Dead Nothing] {
        GHC.Base.False ->
          let {
            ds1_aHr :: GHC.Prim.Int#
            []
            ds1_aHr = GHC.Prim.negateInt# x_aHc
          } in  $j_sIe ds1_aHr;
        GHC.Base.True -> $j_sIe x_aHc
       }
     }
 
 
] 
[Make simplifier report which phase it is doing in -ddump output
simonpj@microsoft.com**20060518163448] 
[Comments only
simonpj@microsoft.com**20060518163425] 
[take parsec out of $(GhcBootLibs)
Simon Marlow <simonmar@microsoft.com>**20060518131506] 
[Improve documentation of INLINE pragmas
simonpj@microsoft.com**20060518113212] 
[a couple of additions
Simon Marlow <simonmar@microsoft.com>**20060518104025] 
[#define _REENTRANT 1   (needed to get the right errno on some OSs)
Simon Marlow <simonmar@microsoft.com>**20060518103715
 Partial fix for hanging problems on Solaris and possibly *BSD.
 A similar fix is also required to libraries/base/includes/HsBase.h.
] 
[Declare this file to be POSIX
Simon Marlow <simonmar@microsoft.com>**20060518102858
 This is simpler than using _POSIX_THREAD_SEMANTICS on Solaris to get
 the right version of ctime_r().
] 
[somewhere to keep track of release notes for 6.6
Simon Marlow <simonmar@microsoft.com>**20060518074415] 
[Newtype data constructors get a compulsory unfolding
simonpj@microsoft.com**20060517155009
 
 With this change, newtype data constructors get a "compulsory" unfolding,
 which means that they *must* be inlined, and no top-level definition of
 the constructor is provided at all.  Since these constructors are no-ops,
 I'm not sure why this wasn't the case all along.
 
] 
[White space only
simonpj@microsoft.com**20060517154936] 
[Retain InlinePragInfo on wrappers
simonpj@microsoft.com**20060517154725
 
 For some reason, when doing the worker/wrapper split, we transferred the
 InlinePragInfo from the original function, but expunging it from the wrapper.
 This meant, for example, that a NOINLINE function would have its wrapper
 inlined, which isn't sensible.
 
 For a change, fixing a bug involves only deleting code!
 
] 
[Spelling correction
simonpj@microsoft.com**20060517154710] 
[Retain INLINE pragma information during indirection-shorting
simonpj@microsoft.com**20060517154449
 
 During indirection-shorting, we were dropping the InlinePragInfo,
 although were were carefully retaining strictness info etc.  
 I think this is a long-standing bug.
 
] 
[Improve pretty-printing
simonpj@microsoft.com**20060517154349] 
[Comments only
simonpj@microsoft.com**20060517154304] 
[Improve pretty-printing slightly
simonpj@microsoft.com**20060517154204] 
[Let GHCi work with with Sparc32+/V8+ .o files
Duncan Coutts <duncan.coutts@worc.ox.ac.uk>**20060516090430
 Currently the GHCi linker looks exclusively for V7 ABI .o files.
 
 You can generate V8+ ABI .o files using flags to gcc such as:
  -optc-mcpu=ultrasparc -opta-mcpu=ultrasparc
 
 Note that this allows gcc to generate hardware integer division and
 hardware floating point instructions rather than using software emulation.
 All recent sparc hardware is V8+ or later. Perhaps we should check for the
 cpu generation in configure and use the later ABI if possible.
 
 Tested briefly on a SunBlade 100 (TI UltraSparc IIe) sparc-unknown-linux
] 
[match up more closely with compiler/main/DynFlags.hs:machdepCCOpts
Simon Marlow <simonmar@microsoft.com>**20060515090031
 In particular, add -fno-builtin to x86 and x86_64, which was missing.
] 
[set $(GhcVersion) and $(GhcPatchLevel) correctly when $(UseStage1)==YES
Simon Marlow <simonmar@microsoft.com>**20060510124621] 
[.raw_s and .s live in $(odir), not the source dir
Simon Marlow <simonmar@microsoft.com>**20060510121524] 
[additions from Reilly Hayes
Simon Marlow <simonmar@microsoft.com>**20060510120000] 
[some tweaks to the HC bootstrapping instructions
Simon Marlow <simonmar@microsoft.com>**20060510115236] 
[Ignore unboxed values in breakpoints.
Lemmih <lemmih@gmail.com>**20060510072722] 
[Don't read ~/.ghci on breakpoints.
Lemmih <lemmih@gmail.com>**20060509223455] 
[make it possible to define an alias for :quit
Simon Marlow <simonmar@microsoft.com>**20060509083124] 
[Do not put wired-in things in interface files
simonpj@microsoft.com**20060508142946
 
 There is no need for wired-in things to go into interface files; the compiler
 knows about them anyway.  Worse, it turns ou that if they are in an interface
 file, they may get read in with not-quite-right type info (e.g. GHC.Err.error),
 and the not-quite-right thing gets into the type envt.  Than it gets used 
 instead of the wired in thing.
 
 Best all round never to put them into interface files.  This is the way
 it used to be, but it looks as if it rotted away some time ago.
 
 (I noticed this when fixing unsafePerformIO stuff, becuase 'lazy' was getting
 an unfolding when it shouldn't.)
 
] 
[Remove NOINLINE strictness hack
simonpj@microsoft.com**20060508142834
 
 The stricteness analyser used to have a HACK which ensured that NOINLNE things
 were not strictness-analysed.  The reason was unsafePerformIO. Left to itself,
 the strictness analyser would discover this strictness for unsafePerformIO:
        unsafePerformIO:  C(U(AV))
 But then consider this sub-expression
        unsafePerformIO (\s -> let r = f x in 
                               case writeIORef v r s of (# s1, _ #) ->
                               (# s1, r #)
 The strictness analyser will now find that r is sure to be eval'd,
 and may then hoist it out.  This makes tests/lib/should_run/memo002
 deadlock.
 
 Solving this by making all NOINLINE things have no strictness info is overkill.
 In particular, it's overkill for runST, which is perfectly respectable.
 Consider
        f x = runST (return x)
 This should be strict in x.
 
 So the new plan is to define unsafePerformIO using the 'lazy' combinator:
 
        unsafePerformIO (IO m) = lazy (case m realWorld# of (# _, r #) -> r)
 
 Remember, 'lazy' is a wired-in identity-function Id, of type a->a, which is 
 magically NON-STRICT, and is inlined after strictness analysis.  So
 unsafePerformIO will look non-strict, and that's what we want.
 
 Now we don't need the hack in the strictness analyser.
 
] 
[Trim imports
simonpj@microsoft.com**20060508141804] 
[Trim imports
simonpj@microsoft.com**20060508141713] 
[GHC_MANGLER-->MANGLER
Simon Marlow <simonmar@microsoft.com>**20060508111206] 
[Fix bug #763: Breakpoint mechanism crashes when there's a type error.
Lemmih <lemmih@gmail.com>**20060505232158] 
[breakpointCond
Lemmih <lemmih@gmail.com>**20060502174340] 
[Preserve type variable names during type inference
simonpj@microsoft.com**20060505153753
 
 During unification we attempt to preserve the print-names of type variables,
 so that type error messages tend to mention type variables using the 
 programmer's vocabulary.  
 
 This had bit-rotted a bit when I added impredicative polymorphism; especially
 when unBoxing a boxy type variable we should not gratuitously lose its name.
 
] 
[Trim imports
simonpj@microsoft.com**20060505150506] 
[fixup for new source tree layout
Simon Marlow <simonmar@microsoft.com>**20060505114100] 
[FPTOOLS_TOP-->GHC_TOP, and remove some references to "fptools"
Simon Marlow <simonmar@microsoft.com>**20060505110520] 
[$(FPTOOLS_TOP) is now known as $(GHC_TOP)
Simon Marlow <simonmar@microsoft.com>**20060505110127
 I kept $(FPTOOLS_TOP) as an alias for $(GHC_TOP) while we switch
] 
[update the build system documentation
Simon Marlow <simonmar@microsoft.com>**20060505105843] 
[update for new source tree layout
Simon Marlow <simonmar@microsoft.com>**20060505102903] 
[partial update for new source tree layout
Simon Marlow <simonmar@microsoft.com>**20060505030218] 
[update for new source tree layout (untested)
Simon Marlow <simonmar@microsoft.com>**20060505081549] 
[Print a more helpful error for find_thing
simonpj@microsoft.com**20060504153337] 
[Fix a bug in rule matching
simonpj@microsoft.com**20060504112430
 
 The rule matcher uses a "rough-match" pre-filter, which was being too 
 aggressive.  The case looked like this:
 
        rule:   f True
        expr:   case e of x { True -> f x }
 
 Jues because x doesn't immediately look like True, we shouldn't say
 "can't match", but that is exactly what ruleCantMatch was doing.
 
 
] 
[Fix constructor-specialisation bug
simonpj@microsoft.com**20060504112131
 
 The constructor-specialisation optimisation was not dealing with the case
 of 
        (letrec ... in f) a1 a2
 
 We need to apply constructor specialisation in the letrec; previously
 we were leaving it untouched on the grounds that the function part of
 an application is almost always a variable.
 
 But in fact, float-in immediately precedes SpecConstr, so we can get
 these odd-looking applications.
 
 
] 
[Fix precedence for records in derived Read
simonpj@microsoft.com**20060504111804
 
 The derived instance for Read of records wasn't quite right.
 Consider
        data T = T1 T | T2 { x::Int }
 
 The string "T1 T2 { x=2 }" should parse correctly as 
        T1 (T2 {x=2})
 because of Haskell's odd precedence rules (record construction binds
 even more tightly than application), but the derived Read didn't take
 account of that.
 
 drvrun020 is the regression test
 
 
] 
[Make rules available in RHS
simonpj@microsoft.com**20060504111500
 
 After some earlier re-factoring, the code that was carefully trying
 to make RULES available in a function's own RHS was plain wrong.
 
 This commit fixes it.  Some programs should go faster!
 
] 
[Pretty printing instance for Unfolding
simonpj@microsoft.com**20060504111429] 
[small clarification
Simon Marlow <simonmar@microsoft.com>**20060504103414] 
[small fix to booting instructions from #762
Simon Marlow <simonmar@microsoft.com>**20060504083104] 
[$(ProjectNameShort) => ghc
Simon Marlow <simonmar@microsoft.com>**20060503102419] 
[only pass -fno-unit-at-a-time to gcc if it is supported
Simon Marlow <simonmar@microsoft.com>**20060503093614] 
[Arrange that -fth is no longer implied by -fglasgow-exts
simonpj@microsoft.com**20060426182114
 
 Messages involving Template Haskell are deeply puzzling
 if you don't know about TH, so it seems better to make
 -fth an explicit flag.  It is no longer switched on
 by -fglasgow-exts.
 
] 
[remove code not required in the new source tree layout
Simon Marlow <simonmar@microsoft.com>**20060502114235] 
[move "compat" earlier in the build for .hc bootstrapping
Simon Marlow <simonmar@microsoft.com>**20060502112001] 
[fix ctime_r problem on Solaris (I hope)
Simon Marlow <simonmar@microsoft.com>**20060502111231] 
[fix whitespace problem that shows up on Solaris (x86)
Simon Marlow <simonmar@microsoft.com>**20060502110001] 
[libraries/time is boring
Simon Marlow <simonmar@microsoft.com>**20060502105524] 
[add time package to libraries Makefile
Ashley Yakeley <ashley@semantic.org>**20060501092241] 
[add time package to default-packages
Ashley Yakeley <ashley@semantic.org>**20060426070445] 
[Fix stage2 segfault on openbsd.
dons@cse.unsw.edu.au**20060428074811
 
 Somewhere along the 6.5 branch, gcc started compiling the rts such that
 it triggers the stack smash handler, causing stage2 to by kill'd
 immediately. This turns off the stack protector, which will do for now.
 
] 
[fix quoting around ${FPTOOLS_TOP_ABS} (fixes #749)
Simon Marlow <simonmar@microsoft.com>**20060428085252] 
[Fix bug shown in the mod77 test.
Lemmih <lemmih@gmail.com>**20060427113313] 
[Don't init root pointers if they aren't gonna be used.
Lemmih <lemmih@gmail.com>**20060426111143] 
[Fix recompilation checking.
Simon Marlow <simonmar@microsoft.com>**20060425140932
 One-shot compilation was throwing away the old iface read by
 checkOldIface, with the result that version numbers were never being
 incremented.  Fixes the recomp001 test too.
] 
[Solaris needs -lrt for the threaded RTS
Simon Marlow <simonmar@microsoft.com>**20060425082823] 
[fix problem with binary-dist docs
Simon Marlow <simonmar@microsoft.com>**20060424090159] 
[Enable breakpoint support.
Lemmih <lemmih@gmail.com>**20060421113112] 
[Fixing some lexer errors with extcore
Josef Svenningsson <josef.svenningsson@gmail.com>**20060420222625] 
[Extcore can now handle data types without constructors
Josef Svenningsson <josef.svenningsson@gmail.com>**20060420213622] 
[Comments only
Josef Svenningsson <josef.svenningsson@gmail.com>**20060420213555] 
[Resurrect ProjectName
sven.panne@aedion.de**20060421085125] 
[Remove the section on platform support, link to the wiki page
Simon Marlow <simonmar@microsoft.com>**20060420125555
 The section in the building guide was becoming out of date, a wiki
 page is much more likely to be kept fresh.
] 
[Fix workaround for a GHC 6.4 bug
rl@cse.unsw.edu.au**20060420044223] 
[hslibs is dead, Jim...
sven.panne@aedion.de**20060419144609] 
[Synched .spec file with reality
sven.panne@aedion.de**20060419143138] 
[Add .spec file to source distribution
sven.panne@aedion.de**20060419103725] 
[remove paragraph about mutable objects that doesn't apply now
Simon Marlow <simonmar@microsoft.com>**20060419082038] 
[HsBool should be HsInt, not StgBool
Simon Marlow <simonmar@microsoft.com>**20060418144214
 StgBool is mapped to C's int type.  GHC doesn't currently know the
 size of a C int on the target arch, it's easier to use StgInt instead.
 I guess nobody ever uses Bool arguments to foreign imports/exports.
] 
[handle Bool arg to foreign import "wrapper"
Simon Marlow <simonmar@microsoft.com>**20060418143936
 Fixes #746
] 
[update commentry for foreign import "wrapper" handling
Simon Marlow <simonmar@microsoft.com>**20060418143714] 
[remove vestiges of ByteArray and MutableByteArray, which are no more
Simon Marlow <simonmar@microsoft.com>**20060418143641] 
[Comment only
simonpj@microsoft.com**20060418125624] 
[Fix rank-validity testing
simonpj@microsoft.com**20060418125350
 
 GHC does not now do "hoisting" as it used to.  Instead, it allows
 foralls to the right of fuction arrows, as well as to the left.
 
 But the type-validity tester hadn't caught up.  This commit fixes 
 it. The test is tc203.
 
 Incidentally, GHC still doesn't let you write
        forall a. Eq a => forall b. b -> b
 because we get a zillion reduce/reduce errors if we allow that.  I'm
 sure it's fixable.  But meanwhile you have to use an auxiliary type
 synonym, which is a bit stupid.
 
 
] 
[Make the initial rdr and type scope available in the ghc-api.
Lemmih <lemmih@gmail.com>**20060418023606] 
[Fix minor bug in Linker.withExtendedLinkEnv
Lemmih <lemmih@gmail.com>**20060418023518] 
[Export 'insertSymbol' and 'insertStableSymbol'.
Lemmih <lemmih@gmail.com>**20060418021806
 
 'insertStableSymbol' is used for exporting closures that are affected by the GC.
 
] 
[Allow $x, as well as $(x), at top level in TH
simonpj@microsoft.com**20060414121907
 
 Bulat pointed out that in Template Haskell
    $x
 is allowed instead of 
    $(x)
 in expressions, but not at the top level of modules.
 
 This commit fixes the omission.  Now you can say
 
        f x = x
        $h
        data T = T
 
 and the $h will run Template Haskell just as you'd expect.
 
] 
[Fix TH erorr recovery (test is TH_recover)
simonpj@microsoft.com**20060414120411] 
[Comments only
simonpj@microsoft.com**20060414120359] 
[Recover gracefully from a Template Haskell programmers error
simonpj@microsoft.com**20060414115831
 
 If a TH programmer uses a type constructor as a data constructor,
 GHC simply crashed.  This commit makes it report the error in a
 graceful way.
 
] 
[Document newtype-unwrapping for IO in FFI
simonpj@microsoft.com**20060414105212] 
[Cosmetics in SpecConstr
simonpj@microsoft.com**20060412152721
 
 SpecConstr currently uses substExpr for tiresome reasons to do with
 GADTs.  Unfortunately the substExpr generates some WARNINGS (when DEBUG)
 is on, because we aren't adding all the in-scope Ids to the in-scope
 set of the substitution.
 
 When we move to FC these substExprs will go away, so I'm not going to
 worry about this now.
 
] 
[Improve pruning of case alternatives to account for GADTs
simonpj@microsoft.com**20060412152327
 
 Consider
 
   data T a where
     T1 :: T Int
     T2 :: T Bool
     T3 :: T Char
 
   f :: T Bool -> Int
   f x = case x of
          DEFAULT -> ...
          T2 -> 3
 
 Here the DEFAULT case covers multiple constructors (T1,T3), but none 
 of them can match a scrutinee of type (T Bool).  So we can prune away
 the default case altogether.
 
 In implementing this, I re-factored this bit of the simplifier, elminiating
 prepareAlts from SimplUtils, and putting all the work into simplAlts in
 Simplify
 
 The proximate cause was a program written by Manuel using PArrays
 
] 
[Fix a bug in optimising division to shift right
Simon Marlow <simonmar@microsoft.com>**20060412144247
 Division by an integral log2 can't be directly optimised to a shift
 right, because shift right behaves like a division that rounds to
 negative infinity, whereas we want one that rounds to zero.  Fix this
 by adding (divisor-1) to the dividend when it is negative before
 shifting.  We do this without jumps, generating very slightly worse
 code than gcc, which uses conditional moves on CPUs that support it.
] 
[Omit lndir on Windows, as it used to be
simonpj@microsoft.com**20060411135334] 
[remove a trace
Simon Marlow <simonmar@microsoft.com>**20060411131531] 
[Allow IO to be wrapped in a newtype in foreign import/export
simonpj@microsoft.com**20060411120441
 
 Up to now, the silent unwrapping of newtypes in foreign import/export
 has been limited to data values.  But it's useful for the IO monad
 itself:
 
        newtype MyIO a = MIO (IO a)
 
        foreign import foo :: Int -> MyIO Int
 
 This patch allows the IO monad to be
 wrapped too. This applies to foreign import "dynamic" and "wrapper", 
 thus
    foreign import "wrapper" foo :: MyIO () -> HisIO (FunPtr (MyIO ())) 
 
 Warning: I did on the plane, and I'm no longer sure if its 100% 
 complete, so needs more testing.  In particular the wrapper/dynamic bit.
 
] 
[Improve newtype deriving
simonpj@microsoft.com**20060402215911
 
 Ross Paterson pointed out a useful generalisation of GHC's 
 newtype-deriving mechanism.  This implements it.  The idea
 is to allow
        newtype Wrap m a = Wrap (m a) deriving (Monad, Eq)
 where the representation type doesn't start with a type
 constructor.
 
 Actually GHC already *did* implement this, but the eta-ok
 check in TcDeriv missed a case, so there was a lurking bug.
 
 This patches fixes the documentation too.  drvrun019 tests.
 
 
] 
[add take to the list of functions deforestable
Simon Marlow <simonmar@microsoft.com>**20060411090131] 
[avoid versionitis in Numeric.showHex (should fix tcrun007)
Simon Marlow <simonmar@microsoft.com>**20060411085009] 
[add a note about full-laziness
Simon Marlow <simonmar@microsoft.com>**20060410093824] 
[robustify the test for the top of the tree a little
Simon Marlow <simonmar@microsoft.com>**20060410082224] 
[Make darcs-all work without a ghc toplevel directory
Josef Svenningsson <josef.svenningsson@gmail.com>**20060407161738] 
[Fix typo in darcsall warning
Josef Svenningsson <josef.svenningsson@gmail.com>**20060407161335] 
[fix source dists
Simon Marlow <simonmar@microsoft.com>**20060407150045] 
[add a README for binary dists
Simon Marlow <simonmar@microsoft.com>**20060407143832] 
[fix binary dists
Simon Marlow <simonmar@microsoft.com>**20060407143822] 
[remove the last bits of the ghc/ subdir
Simon Marlow <simonmar@microsoft.com>**20060407085219] 
[TAG 07.04.06
Lemmih <lemmih@gmail.com>**20060407130411] 
Patch bundle hash:
777313de1f992c22d4d3508095ba0cb233ad670b