docs/users_guide/using.xml

@@ -1042,7 +1042,7 @@ test.hs:(5,4)-(6,7):
             At compile time you get a warning (instead of an error).  At 
             runtime, if you use a value that depends on a type error, you 
             get a runtime error; but you can run any type-correct parts of your code 
-            just fine.</para>
+            just fine.  See <xref linkend="defer-type-errors"/></para>
         </listitem>
       </varlistentry>
 

ghc.mk

@@ -389,6 +389,9 @@ endif
 endif
 endef
 
+# Add all the packages. Note that we need to add them in dependency
+# order, as this is the order that they get configured in.
+
 $(eval $(call addPackage,ghc-prim))
 ifeq "$(CLEANING)" "YES"
 $(eval $(call addPackage,integer-gmp))
@@ -404,9 +407,9 @@ $(eval $(call addPackage,bytestring))
 $(eval $(call addPackage,containers))
 $(eval $(call addPackage,old-locale))
 $(eval $(call addPackage,old-time))
-$(eval $(call addPackage,time))
 
 $(eval $(call addPackage,Win32,($$(Windows),YES)))
+$(eval $(call addPackage,time))
 $(eval $(call addPackage,unix,($$(Windows),NO)))
 
 $(eval $(call addPackage,directory))

ghc/InteractiveUI.hs

@@ -33,7 +33,7 @@ import GHC ( LoadHowMuch(..), Target(..),  TargetId(..), InteractiveImport(..),
              TyThing(..), Phase, BreakIndex, Resume, SingleStep, Ghc,
              handleSourceError )
 import HsImpExp
-import HscTypes ( tyThingParent_maybe, handleFlagWarnings, getSafeMode, dep_pkgs, hsc_IC, 
+import HscTypes ( tyThingParent_maybe, handleFlagWarnings, getSafeMode, hsc_IC, 
                   setInteractivePrintName )
 import Module
 import Name
@@ -1487,48 +1487,34 @@ isSafeModule m = do
          (ghcError $ CmdLineError $ "can't load interface file for module: " ++
                                     (GHC.moduleNameString $ GHC.moduleName m))
 
-    let iface' = fromJust iface
-
-        trust = showPpr dflags $ getSafeMode $ GHC.mi_trust iface'
-        pkgT  = packageTrusted dflags m
-        pkg   = if pkgT then "trusted" else "untrusted"
-        (good', bad') = tallyPkgs dflags $
-                            map fst $ filter snd $ dep_pkgs $ GHC.mi_deps iface'
-        (good, bad) = case GHC.mi_trust_pkg iface' of
-                          True | pkgT -> (modulePackageId m:good', bad')
-                          True        -> (good', modulePackageId m:bad')
-                          False       -> (good', bad')
+    (msafe, pkgs) <- GHC.moduleTrustReqs m
+    let trust  = showPpr dflags $ getSafeMode $ GHC.mi_trust $ fromJust iface
+        pkg    = if packageTrusted dflags m then "trusted" else "untrusted"
+        (good, bad) = tallyPkgs dflags pkgs
 
+    -- print info to user...
     liftIO $ putStrLn $ "Trust type is (Module: " ++ trust ++ ", Package: " ++ pkg ++ ")"
-    liftIO $ putStrLn $ "Package Trust: "
-                            ++ (if packageTrustOn dflags then "On" else "Off")
-
-    when (packageTrustOn dflags && not (null good))
+    liftIO $ putStrLn $ "Package Trust: " ++ (if packageTrustOn dflags then "On" else "Off")
+    when (not $ null good)
          (liftIO $ putStrLn $ "Trusted package dependencies (trusted): " ++
                         (intercalate ", " $ map packageIdString good))
-
-    case goodTrust (getSafeMode $ GHC.mi_trust iface') of
-        True | (null bad || not (packageTrustOn dflags)) ->
-            liftIO $ putStrLn $ mname ++ " is trusted!"
-
-        True -> do
-            liftIO $ putStrLn $ "Trusted package dependencies (untrusted): "
-                        ++ (intercalate ", " $ map packageIdString bad)
+    case msafe && null bad of
+        True -> liftIO $ putStrLn $ mname ++ " is trusted!"
+        False -> do
+            when (not $ null bad)
+                 (liftIO $ putStrLn $ "Trusted package dependencies (untrusted): "
+                            ++ (intercalate ", " $ map packageIdString bad))
             liftIO $ putStrLn $ mname ++ " is NOT trusted!"
 
-        False -> liftIO $ putStrLn $ mname ++ " is NOT trusted!"
-
   where
-    goodTrust t = t `elem` [Sf_Safe, Sf_SafeInferred, Sf_Trustworthy]
-
     mname = GHC.moduleNameString $ GHC.moduleName m
 
     packageTrusted dflags md
         | thisPackage dflags == modulePackageId md = True
-        | otherwise = trusted $ getPackageDetails (pkgState dflags)
-                                                  (modulePackageId md)
+        | otherwise = trusted $ getPackageDetails (pkgState dflags) (modulePackageId md)
 
-    tallyPkgs dflags deps = partition part deps
+    tallyPkgs dflags deps | not (packageTrustOn dflags) = ([], [])
+                          | otherwise = partition part deps
         where state = pkgState dflags
               part pkg = trusted $ getPackageDetails state pkg
 
@@ -1761,11 +1747,7 @@ checkAdd ii = do
        m <- GHC.lookupModule modname pkgqual
        when safe $ do
            t <- GHC.isModuleTrusted m
-           when (not t) $
-                ghcError $ CmdLineError $
-                 "can't import " ++ moduleNameString modname
-                                 ++ " as it isn't trusted."
-
+           when (not t) $ ghcError $ ProgramError $ ""
 
 -- -----------------------------------------------------------------------------
 -- Update the GHC API's view of the context

ghc/ghc-bin.cabal.in

@@ -28,7 +28,7 @@ Executable ghc
     Build-Depends: base       >= 3   && < 5,
                    array      >= 0.1 && < 0.5,
                    bytestring >= 0.9 && < 0.11,
-                   directory  >= 1   && < 1.2,
+                   directory  >= 1   && < 1.3,
                    process    >= 1   && < 1.2,
                    filepath   >= 1   && < 1.4,
                    ghc

ghc/hschooks.c

@@ -32,7 +32,7 @@ defaultsHook (void)
 }
 
 void
-StackOverflowHook (lnat stack_size)    /* in bytes */
+StackOverflowHook (StgWord stack_size)    /* in bytes */
 {
     fprintf(stderr, "GHC stack-space overflow: current limit is %zu bytes.\nUse the `-K<size>' option to increase it.\n", (size_t)stack_size);
 }

includes/Rts.h

@@ -156,6 +156,8 @@ void _assertFail(const char *filename, unsigned int linenum)
 #define TIME_RESOLUTION 1000000000
 typedef StgInt64 Time;
 
+#define TIME_MAX HS_INT64_MAX
+
 #if TIME_RESOLUTION == 1000000000
 // I'm being lazy, but it's awkward to define fully general versions of these
 #define TimeToUS(t)      ((t) / 1000)

includes/mkDerivedConstants.c

@@ -200,7 +200,7 @@ main(int argc, char *argv[])
 
     printf("#define BLOCK_SIZE   %u\n", BLOCK_SIZE);
     printf("#define MBLOCK_SIZE   %u\n", MBLOCK_SIZE);
-    printf("#define BLOCKS_PER_MBLOCK  %" FMT_SizeT "\n", (lnat)BLOCKS_PER_MBLOCK);
+    printf("#define BLOCKS_PER_MBLOCK  %" FMT_Word "\n", (W_)BLOCKS_PER_MBLOCK);
     // could be derived, but better to save doing the calculation twice
 
     printf("\n\n");

includes/rts/Flags.h

@@ -53,6 +53,7 @@ struct GC_FLAGS {
     rtsBool frontpanel;
 
     Time    idleGCDelayTime;    /* units: TIME_RESOLUTION */
+    rtsBool doIdleGC;
 
     StgWord heapBase;           /* address to ask the OS for memory */
 };

includes/rts/Hooks.h

@@ -18,9 +18,9 @@ extern char *ghc_rts_opts;
 
 extern void OnExitHook (void);
 extern int  NoRunnableThreadsHook (void);
-extern void StackOverflowHook (lnat stack_size);
-extern void OutOfHeapHook (lnat request_size, lnat heap_size);
-extern void MallocFailHook (lnat request_size /* in bytes */, char *msg);
+extern void StackOverflowHook (W_ stack_size);
+extern void OutOfHeapHook (W_ request_size, W_ heap_size);
+extern void MallocFailHook (W_ request_size /* in bytes */, char *msg);
 extern void defaultsHook (void);
 
 #endif /* RTS_HOOKS_H */

includes/rts/SpinLock.h

@@ -34,7 +34,7 @@ typedef struct SpinLock_
 typedef StgWord SpinLock;
 #endif
 
-typedef lnat SpinLockCount;
+typedef StgWord SpinLockCount;
 
 #if defined(PROF_SPIN)
 

includes/rts/Threads.h

@@ -22,17 +22,17 @@
 // 
 // Creating threads
 //
-StgTSO *createThread (Capability *cap, nat stack_size);
+StgTSO *createThread (Capability *cap, W_ stack_size);
 
 void scheduleWaitThread (/* in    */ StgTSO *tso,
                          /* out   */ HaskellObj* ret,
                          /* inout */ Capability **cap);
 
-StgTSO *createGenThread       (Capability *cap, nat stack_size,  
+StgTSO *createGenThread       (Capability *cap, W_ stack_size,
 			       StgClosure *closure);
-StgTSO *createIOThread        (Capability *cap, nat stack_size,  
+StgTSO *createIOThread        (Capability *cap, W_ stack_size,
 			       StgClosure *closure);
-StgTSO *createStrictIOThread  (Capability *cap, nat stack_size,  
+StgTSO *createStrictIOThread  (Capability *cap, W_ stack_size,
 			       StgClosure *closure);
 
 // Suspending/resuming threads around foreign calls

includes/rts/Types.h

@@ -16,8 +16,10 @@
 
 #include <stddef.h>
 
-typedef unsigned int    nat;           /* at least 32 bits (like int) */
-typedef          size_t lnat;          /* at least 32 bits            */
+typedef unsigned int     nat;           /* at least 32 bits (like int) */
+
+// Deprecated; just use StgWord instead
+typedef StgWord lnat;
 
 /* ullong (64|128-bit) type: only include if needed (not ANSI) */
 #if defined(__GNUC__) 

includes/rts/storage/Block.h

@@ -244,11 +244,11 @@ extern void initBlockAllocator(void);
 
 /* Allocation -------------------------------------------------------------- */
 
-bdescr *allocGroup(nat n);
+bdescr *allocGroup(W_ n);
 bdescr *allocBlock(void);
 
 // versions that take the storage manager lock for you:
-bdescr *allocGroup_lock(nat n);
+bdescr *allocGroup_lock(W_ n);
 bdescr *allocBlock_lock(void);
 
 /* De-Allocation ----------------------------------------------------------- */

includes/rts/storage/ClosureMacros.h

@@ -419,20 +419,20 @@ EXTERN_INLINE StgWord stack_frame_sizeW( StgClosure *frame )
    -------------------------------------------------------------------------- */
 
 // The number of card bytes needed
-INLINE_HEADER lnat mutArrPtrsCards (lnat elems)
+INLINE_HEADER W_ mutArrPtrsCards (W_ elems)
 {
-    return (lnat)((elems + (1 << MUT_ARR_PTRS_CARD_BITS) - 1)
+    return (W_)((elems + (1 << MUT_ARR_PTRS_CARD_BITS) - 1)
                            >> MUT_ARR_PTRS_CARD_BITS);
 }
 
 // The number of words in the card table
-INLINE_HEADER lnat mutArrPtrsCardTableSize (lnat elems)
+INLINE_HEADER W_ mutArrPtrsCardTableSize (W_ elems)
 {
     return ROUNDUP_BYTES_TO_WDS(mutArrPtrsCards(elems));
 }
 
 // The address of the card for a particular card number
-INLINE_HEADER StgWord8 *mutArrPtrsCard (StgMutArrPtrs *a, lnat n)
+INLINE_HEADER StgWord8 *mutArrPtrsCard (StgMutArrPtrs *a, W_ n)
 {
     return ((StgWord8 *)&(a->payload[a->ptrs]) + n);
 }

includes/rts/storage/GC.h

@@ -75,6 +75,7 @@ typedef struct generation_ {
 
     bdescr *       large_objects;	// large objects (doubly linked)
     memcount       n_large_blocks;      // no. of blocks used by large objs
+    memcount       n_large_words;       // no. of words used by large objs
     memcount       n_new_large_words;   // words of new large objects
                                         // (for allocation stats)
 
@@ -124,13 +125,13 @@ extern generation * oldest_gen;
 /* -----------------------------------------------------------------------------
    Generic allocation
 
-   StgPtr allocate(Capability *cap, nat n)
+   StgPtr allocate(Capability *cap, W_ n)
                                 Allocates memory from the nursery in
 				the current Capability.  This can be
 				done without taking a global lock,
                                 unlike allocate().
 
-   StgPtr allocatePinned(Capability *cap, nat n) 
+   StgPtr allocatePinned(Capability *cap, W_ n)
                                 Allocates a chunk of contiguous store
    				n words long, which is at a fixed
 				address (won't be moved by GC).  
@@ -149,15 +150,15 @@ extern generation * oldest_gen;
 
    -------------------------------------------------------------------------- */
 
-StgPtr  allocate        ( Capability *cap, lnat n );
-StgPtr  allocatePinned  ( Capability *cap, lnat n );
+StgPtr  allocate        ( Capability *cap, W_ n );
+StgPtr  allocatePinned  ( Capability *cap, W_ n );
 
 /* memory allocator for executable memory */
-void * allocateExec(unsigned int len, void **exec_addr);
+void * allocateExec(W_ len, void **exec_addr);
 void   freeExec (void *p);
 
 // Used by GC checks in external .cmm code:
-extern nat large_alloc_lim;
+extern W_ large_alloc_lim;
 
 /* -----------------------------------------------------------------------------
    Performing Garbage Collection

includes/rts/storage/MBlock.h

@@ -12,8 +12,8 @@
 #ifndef RTS_STORAGE_MBLOCK_H
 #define RTS_STORAGE_MBLOCK_H
 
-extern lnat peak_mblocks_allocated;
-extern lnat mblocks_allocated;
+extern W_ peak_mblocks_allocated;
+extern W_ mblocks_allocated;
 
 extern void initMBlocks(void);
 extern void * getMBlock(void);
@@ -156,7 +156,7 @@ typedef struct {
     MBlockMapLine lines[MBLOCK_MAP_ENTRIES];
 } MBlockMap;
 
-extern lnat mpc_misses;
+extern W_ mpc_misses;
 
 StgBool HEAP_ALLOCED_miss(StgWord mblock, void *p);
 

mk/config.mk.in

@@ -393,7 +393,7 @@ BIN_DIST_PREP_TAR_BZ2 = $(BIN_DIST_PREP_TAR).bz2
 BIN_DIST_TAR_BZ2      = $(BIN_DIST_NAME)-$(TARGETPLATFORM).tar.bz2
 BIN_DIST_LIST         = bindist-list
 
-WINDOWS_INSTALLER_BASE = ghc-$(ProjectVersion)-i386-windows
+WINDOWS_INSTALLER_BASE = ghc-$(ProjectVersion)-$(TargetArch_CPP)-windows
 WINDOWS_INSTALLER = $(WINDOWS_INSTALLER_BASE)$(exeext)
 
 # -----------------------------------------------------------------------------

rts/Arena.c

@@ -80,7 +80,7 @@ arenaAlloc( Arena *arena, size_t size )
 	return p;
     } else {
 	// allocate a fresh block...
-	req_blocks =  (lnat)BLOCK_ROUND_UP(size) / BLOCK_SIZE;
+	req_blocks =  (W_)BLOCK_ROUND_UP(size) / BLOCK_SIZE;
 	bd = allocGroup_lock(req_blocks);
 	arena_blocks += req_blocks;
 

rts/Capability.h

@@ -123,7 +123,7 @@ struct Capability_ {
     SparkCounters spark_stats;
 #endif
     // Total words allocated by this cap since rts start
-    lnat total_allocated;
+    W_ total_allocated;
 
     // Per-capability STM-related data
     StgTVarWatchQueue *free_tvar_watch_queues;

rts/Disassembler.c

@@ -80,7 +80,7 @@ disInstr ( StgBCO *bco, int pc )
          pc += 1; break;
      case bci_STKCHECK:  {
          StgWord stk_words_reqd = BCO_GET_LARGE_ARG + 1;
-         debugBelch("STKCHECK %" FMT_SizeT "\n", (lnat)stk_words_reqd );
+         debugBelch("STKCHECK %" FMT_Word "\n", (W_)stk_words_reqd );
          break;
      }
       case bci_PUSH_L: