[project @ 1996-05-17 16:02:43 by partain]

Sansom 1.3 changes through 960507

7 files changed, 373 insertions, 240 deletions

diff --git a/ghc/compiler/prelude/PrelInfo.lhs b/ghc/compiler/prelude/PrelInfo.lhs
index c6b04a2790..dee0852bb4 100644
--- a/ghc/compiler/prelude/PrelInfo.lhs
+++ b/ghc/compiler/prelude/PrelInfo.lhs
@@ -8,88 +8,11 @@
 
 module PrelInfo (
 
-	pRELUDE, pRELUDE_BUILTIN, pRELUDE_CORE, pRELUDE_RATIO,
-	pRELUDE_LIST, pRELUDE_TEXT,
-	pRELUDE_PRIMIO, pRELUDE_IO, pRELUDE_PS,
-	gLASGOW_ST, gLASGOW_MISC,
-
 	-- finite maps for built-in things (for the renamer and typechecker):
 	builtinNameInfo, BuiltinNames(..),
 	BuiltinKeys(..), BuiltinIdInfos(..),
 
-	-- *odd* values that need to be reached out and grabbed:
-	eRROR_ID,
-	pAT_ERROR_ID,
-	rEC_CON_ERROR_ID,
-	rEC_UPD_ERROR_ID,
-	iRREFUT_PAT_ERROR_ID,
-	nON_EXHAUSTIVE_GUARDS_ERROR_ID,
-	aBSENT_ERROR_ID,
-	packStringForCId,
-	unpackCStringId, unpackCString2Id,
-	unpackCStringAppendId, unpackCStringFoldrId,
-	integerZeroId, integerPlusOneId,
-	integerPlusTwoId, integerMinusOneId,
-
-	-----------------------------------------------------
-	-- the rest of the export list is organised by *type*
-	-----------------------------------------------------
-
-	-- type: Bool
-	boolTyCon, boolTy, falseDataCon, trueDataCon,
-
-	-- types: Char#, Char, String (= [Char])
-	charPrimTy, charTy, stringTy,
-	charPrimTyCon, charTyCon, charDataCon,
-
-	-- type: Ordering (used in deriving)
-	orderingTy, ltDataCon, eqDataCon, gtDataCon,
-
-	-- types: Double#, Double
-	doublePrimTy, doubleTy,
-	doublePrimTyCon, doubleTyCon, doubleDataCon,
-
-	-- types: Float#, Float
-	floatPrimTy, floatTy,
-	floatPrimTyCon, floatTyCon, floatDataCon,
-
-	-- types: Glasgow *primitive* arrays, sequencing and I/O
-	mkPrimIoTy, -- to typecheck "mainPrimIO" & for _ccall_s
-	realWorldStatePrimTy, realWorldStateTy{-boxed-},
-	realWorldTy, realWorldTyCon, realWorldPrimId,
-	statePrimTyCon, stateDataCon, getStatePairingConInfo,
-
-	byteArrayPrimTy,
-
-	-- types: Void# (only used within the compiler)
-	voidPrimTy, voidPrimId,
-
-	-- types: Addr#, Int#, Word#, Int
-	intPrimTy, intTy, intPrimTyCon, intTyCon, intDataCon,
-	wordPrimTyCon, wordPrimTy, wordTy, wordTyCon, wordDataCon,
-	addrPrimTyCon, addrPrimTy, addrTy, addrTyCon, addrDataCon,
-	maybeIntLikeTyCon, maybeCharLikeTyCon,
-
-	-- types: Integer, Rational (= Ratio Integer)
-	integerTy, rationalTy,
-	integerTyCon, integerDataCon,
-	rationalTyCon, ratioDataCon,
-
-	-- type: Lift
-	liftTyCon, liftDataCon, mkLiftTy,
-
-	-- type: List
-	listTyCon, mkListTy, nilDataCon, consDataCon,
-
-	-- type: tuples
-	mkTupleTy, unitTy,
-
-	-- for compilation of List Comprehensions and foldr
-	foldlId, foldrId,
-	mkBuild, buildId, augmentId, appendId
-
-	-- and, finally, we must put in some (abstract) data types,
-	-- to make the interface self-sufficient
+	maybeCharLikeTyCon, maybeIntLikeTyCon
     ) where
 
 import Ubiq
@@ -231,7 +154,7 @@ prim_tycons
     , doublePrimTyCon
     , floatPrimTyCon
     , intPrimTyCon
-    , mallocPtrPrimTyCon
+    , foreignObjPrimTyCon
     , mutableArrayPrimTyCon
     , mutableByteArrayPrimTyCon
     , synchVarPrimTyCon
@@ -272,7 +195,7 @@ data_tycons
     , intTyCon
     , integerTyCon
     , liftTyCon
-    , mallocPtrTyCon
+    , foreignObjTyCon
     , ratioTyCon
     , return2GMPsTyCon
     , returnIntAndGMPTyCon
@@ -284,7 +207,7 @@ data_tycons
     , stateAndDoublePrimTyCon
     , stateAndFloatPrimTyCon
     , stateAndIntPrimTyCon
-    , stateAndMallocPtrPrimTyCon
+    , stateAndForeignObjPrimTyCon
     , stateAndMutableArrayPrimTyCon
     , stateAndMutableByteArrayPrimTyCon
     , stateAndSynchVarPrimTyCon
@@ -338,15 +261,14 @@ parallel_ids
     else
         [ parId
         , forkId
-#ifdef GRAN
-    	, parLocalId
+	, copyableId
+	, noFollowId
+	, parAtAbsId
+	, parAtForNowId
+	, parAtId
+	, parAtRelId
 	, parGlobalId
-	    -- Add later:
-	    -- ,parAtId
-	    -- ,parAtForNowId
-	    -- ,copyableId
-	    -- ,noFollowId
-#endif {-GRAN-}
+    	, parLocalId
 	]
 
 pcIdWiredInInfo :: Id -> (FAST_STRING, RnName)
@@ -405,6 +327,7 @@ tysyn_keys
 class_keys
   = [ (s, (k, RnImplicitClass)) | (s,k) <-
     [ (SLIT("Eq"),		eqClassKey)		-- mentioned, derivable
+    , (SLIT("Eval"),		evalClassKey)		-- mentioned
     , (SLIT("Ord"),		ordClassKey)		-- derivable
     , (SLIT("Num"),		numClassKey)		-- mentioned, numeric
     , (SLIT("Real"),		realClassKey)		-- numeric
@@ -414,6 +337,7 @@ class_keys
     , (SLIT("RealFrac"),	realFracClassKey)	-- numeric
     , (SLIT("RealFloat"),	realFloatClassKey)	-- numeric
 --  , (SLIT("Ix"),		ixClassKey)		-- derivable (but it isn't Prelude.Ix; hmmm)
+	-- see *hack* in Rename
     , (SLIT("Bounded"),		boundedClassKey)	-- derivable
     , (SLIT("Enum"),		enumClassKey)		-- derivable
     , (SLIT("Show"),		showClassKey)		-- derivable
diff --git a/ghc/compiler/prelude/PrelMods.lhs b/ghc/compiler/prelude/PrelMods.lhs
index 08bcc1a099..02fd9f6fef 100644
--- a/ghc/compiler/prelude/PrelMods.lhs
+++ b/ghc/compiler/prelude/PrelMods.lhs
@@ -9,11 +9,14 @@ defined here so as to avod
 #include "HsVersions.h"
 
 module PrelMods (
-	pRELUDE, pRELUDE_BUILTIN, pRELUDE_CORE, pRELUDE_RATIO,
+	pRELUDE, pRELUDE_BUILTIN,
 	pRELUDE_LIST, pRELUDE_TEXT,
 	pRELUDE_PRIMIO, pRELUDE_IO, pRELUDE_PS,
 	gLASGOW_ST, gLASGOW_MISC,
-	pRELUDE_FB, fromPrelude
+	pRELUDE_FB,
+	rATIO,
+	
+	fromPrelude
   ) where
 
 CHK_Ubiq() -- debugging consistency check
@@ -25,15 +28,15 @@ gLASGOW_MISC	= SLIT("PreludeGlaMisc")
 gLASGOW_ST	= SLIT("PreludeGlaST")
 pRELUDE		= SLIT("Prelude")
 pRELUDE_BUILTIN = SLIT("PreludeBuiltin")
-pRELUDE_CORE	= SLIT("PreludeCore")
 pRELUDE_FB	= SLIT("PreludeFoldrBuild")
 pRELUDE_IO	= SLIT("PreludeIO")
 pRELUDE_LIST	= SLIT("PreludeList")
 pRELUDE_PRIMIO	= SLIT("PreludePrimIO")
 pRELUDE_PS	= SLIT("PreludePS")
-pRELUDE_RATIO	= SLIT("PreludeRatio")
 pRELUDE_TEXT	= SLIT("PreludeText")
 
+rATIO = SLIT("Ratio")
+
 fromPrelude :: FAST_STRING -> Bool
 fromPrelude s = (_SUBSTR_ s 0 6 == SLIT("Prelude"))
 \end{code}
diff --git a/ghc/compiler/prelude/PrelVals.lhs b/ghc/compiler/prelude/PrelVals.lhs
index 506b50e8d6..0ce975e5ef 100644
--- a/ghc/compiler/prelude/PrelVals.lhs
+++ b/ghc/compiler/prelude/PrelVals.lhs
@@ -24,7 +24,7 @@ import IdInfo		-- quite a bit
 import Literal		( mkMachInt )
 import PrimOp		( PrimOp(..) )
 import SpecEnv		( SpecEnv(..), nullSpecEnv )
-import TyVar		( alphaTyVar, betaTyVar )
+import TyVar		( alphaTyVar, betaTyVar, gammaTyVar )
 import Unique		-- lots of *Keys
 import Util		( panic )
 \end{code}
@@ -164,13 +164,13 @@ OK, this is Will's idea: we should have magic values for Integers 0,
 +1, +2, and -1 (go ahead, fire me):
 \begin{code}
 integerZeroId
-  = pcMiscPrelId integerZeroIdKey     pRELUDE_CORE SLIT("__integer0")  integerTy noIdInfo
+  = pcMiscPrelId integerZeroIdKey     pRELUDE SLIT("__integer0")  integerTy noIdInfo
 integerPlusOneId
-  = pcMiscPrelId integerPlusOneIdKey  pRELUDE_CORE SLIT("__integer1")  integerTy noIdInfo
+  = pcMiscPrelId integerPlusOneIdKey  pRELUDE SLIT("__integer1")  integerTy noIdInfo
 integerPlusTwoId
-  = pcMiscPrelId integerPlusTwoIdKey  pRELUDE_CORE SLIT("__integer2")  integerTy noIdInfo
+  = pcMiscPrelId integerPlusTwoIdKey  pRELUDE SLIT("__integer2")  integerTy noIdInfo
 integerMinusOneId
-  = pcMiscPrelId integerMinusOneIdKey pRELUDE_CORE SLIT("__integerm1") integerTy noIdInfo
+  = pcMiscPrelId integerMinusOneIdKey pRELUDE SLIT("__integerm1") integerTy noIdInfo
 \end{code}
 
 %************************************************************************
@@ -274,50 +274,191 @@ forkId = pcMiscPrelId forkIdKey pRELUDE_BUILTIN SLIT("_fork_")
 
 \end{code}
 
+GranSim ones:
 \begin{code}
-#ifdef GRAN
-
 parLocalId = pcMiscPrelId parLocalIdKey pRELUDE_BUILTIN SLIT("_parLocal_")
 		  (mkSigmaTy [alphaTyVar, betaTyVar] []
-		    (mkFunTys [intPrimTy, alphaTy, betaTy] betaTy))
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy, alphaTy, betaTy] betaTy))
 		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parLocal_template))
   where
-    [w, x, y, z]
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, x, y, z]
       = mkTemplateLocals [
 	{-w-} intPrimTy,
+	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
     	{-x-} alphaTy,
     	{-y-} betaTy,
-	{-z-} betaTy
+	{-z-} intPrimTy
     	]
 
     parLocal_template
-      = mkLam [alphaTyVar, betaTyVar] [w, x, y] (
-		Case (Prim ParLocalOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg w, VarArg y]) (
-		  AlgAlts
-		    [(liftDataCon, [z], Var z)]
-		    (NoDefault)))
+      = mkLam [alphaTyVar, betaTyVar] [w, g, s, p, x, y] (
+		Case (Prim ParLocalOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
 
 parGlobalId = pcMiscPrelId parGlobalIdKey pRELUDE_BUILTIN SLIT("_parGlobal_")
 		  (mkSigmaTy [alphaTyVar, betaTyVar] []
-		    (mkFunTys [intPrimTy,alphaTy,betaTy] betaTy))
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy, alphaTy, betaTy] betaTy))
 		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parGlobal_template))
   where
-    [w, x, y, z]
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, x, y, z]
       = mkTemplateLocals [
     	{-w-} intPrimTy,
+	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
     	{-x-} alphaTy,
     	{-y-} betaTy,
-	{-z-} betaTy
+	{-z-} intPrimTy
     	]
 
     parGlobal_template
-      = mkLam [alphaTyVar, betaTyVar] [w, x, y] (
-		Case (Prim ParGlobalOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg w, VarArg y]) (
-		  AlgAlts
-		    [(liftDataCon, [z], Var z)]
-		    (NoDefault)))
+      = mkLam [alphaTyVar, betaTyVar] [w, g, s, p, x, y] (
+		Case (Prim ParGlobalOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
+
+
+parAtId = pcMiscPrelId parAtIdKey pRELUDE_BUILTIN SLIT("_parAt_")
+		  (mkSigmaTy [alphaTyVar, betaTyVar] []
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy,
+		               alphaTy, betaTy, gammaTy] gammaTy))
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parAt_template))
+  where
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, v, x, y, z]
+      = mkTemplateLocals [
+    	{-w-} intPrimTy,
+    	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
+    	{-v-} alphaTy,
+    	{-x-} betaTy,
+    	{-y-} gammaTy,
+	{-z-} intPrimTy
+    	]
+
+    parAt_template
+      = mkLam [alphaTyVar, betaTyVar, gammaTyVar] [w, g, s, p, v, x, y] (
+		Case (Prim ParAtOp [TyArg alphaTy, TyArg betaTy, TyArg gammaTy, VarArg x, VarArg v, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
+
+parAtAbsId = pcMiscPrelId parAtAbsIdKey pRELUDE_BUILTIN SLIT("_parAtAbs_")
+		  (mkSigmaTy [alphaTyVar, betaTyVar] []
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy, intPrimTy, alphaTy, betaTy] betaTy))
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parAtAbs_template))
+  where
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, v, x, y, z]
+      = mkTemplateLocals [
+    	{-w-} intPrimTy,
+    	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
+	{-v-} intPrimTy,
+    	{-x-} alphaTy,
+    	{-y-} betaTy,
+    	{-z-} intPrimTy
+    	]
+
+    parAtAbs_template
+      = mkLam [alphaTyVar, betaTyVar] [w, g, s, p, v, x, y] (
+		Case (Prim ParAtAbsOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg v, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
+
+parAtRelId = pcMiscPrelId parAtRelIdKey pRELUDE_BUILTIN SLIT("_parAtRel_")
+		  (mkSigmaTy [alphaTyVar, betaTyVar] []
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy, intPrimTy, alphaTy, betaTy] betaTy))
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parAtRel_template))
+  where
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, v, x, y, z]
+      = mkTemplateLocals [
+    	{-w-} intPrimTy,
+    	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
+	{-v-} intPrimTy,
+    	{-x-} alphaTy,
+    	{-y-} betaTy,
+    	{-z-} intPrimTy
+    	]
+
+    parAtRel_template
+      = mkLam [alphaTyVar, betaTyVar] [w, g, s, p, v, x, y] (
+		Case (Prim ParAtRelOp [TyArg alphaTy, TyArg betaTy, VarArg x, VarArg v, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
+
+parAtForNowId = pcMiscPrelId parAtForNowIdKey pRELUDE_BUILTIN SLIT("_parAtForNow_")
+		  (mkSigmaTy [alphaTyVar, betaTyVar] []
+		    (mkFunTys [intPrimTy, intPrimTy, intPrimTy, intPrimTy,
+				alphaTy, betaTy, gammaTy] gammaTy))
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding parAtForNow_template))
+  where
+    -- Annotations: w: name, g: gran. info, s: size info, p: par info  -- HWL
+    [w, g, s, p, v, x, y, z]
+      = mkTemplateLocals [
+    	{-w-} intPrimTy,
+    	{-g-} intPrimTy,
+	{-s-} intPrimTy,
+	{-p-} intPrimTy,
+    	{-v-} alphaTy,
+    	{-x-} betaTy,
+    	{-y-} gammaTy,
+	{-z-} intPrimTy
+    	]
+
+    parAtForNow_template
+      = mkLam [alphaTyVar, betaTyVar, gammaTyVar] [w, g, s, p, v, x, y] (
+		Case (Prim ParAtForNowOp [TyArg alphaTy, TyArg betaTy, TyArg gammaTy, VarArg x, VarArg v, VarArg w, VarArg g, VarArg s, VarArg p, VarArg y]) (
+		  PrimAlts
+		    [(mkMachInt 0, mkTyApp (Var pAR_ERROR_ID) [betaTy])]
+		    (BindDefault z (Var y))))
+
+-- copyable and noFollow are currently merely hooks: they are translated into
+-- calls to the macros COPYABLE and NOFOLLOW                            -- HWL 
+
+copyableId = pcMiscPrelId copyableIdKey pRELUDE_BUILTIN SLIT("_copyable_")
+		  (mkSigmaTy [alphaTyVar] []
+		    alphaTy)
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding copyable_template))
+  where
+    -- Annotations: x: closure that's tagged to by copyable
+    [x, z]
+      = mkTemplateLocals [
+    	{-x-} alphaTy,
+    	{-z-} alphaTy
+    	]
+
+    copyable_template
+      = mkLam [alphaTyVar] [x] ( Prim CopyableOp [TyArg alphaTy, VarArg x] )
+
+noFollowId = pcMiscPrelId noFollowIdKey pRELUDE_BUILTIN SLIT("_noFollow_")
+		  (mkSigmaTy [alphaTyVar] []
+		    alphaTy)
+		  (noIdInfo `addInfo_UF` (mkUnfolding EssentialUnfolding noFollow_template))
+  where
+    -- Annotations: x: closure that's tagged to not follow
+    [x, z]
+      = mkTemplateLocals [
+    	{-x-} alphaTy,
+    	{-z-} alphaTy
+    	]
 
-#endif {-GRAN-}
+    noFollow_template
+      = mkLam [alphaTyVar] [x] ( Prim NoFollowOp [TyArg alphaTy, VarArg x] )
 \end{code}
 
 %************************************************************************
@@ -453,7 +594,7 @@ realWorldPrimId
 
 \begin{code}
 buildId
-  = pcMiscPrelId buildIdKey pRELUDE_CORE SLIT("_build") buildTy
+  = pcMiscPrelId buildIdKey pRELUDE_BUILTIN SLIT("_build") buildTy
 	((((noIdInfo
 		{-LATER:`addInfo_UF` mkMagicUnfolding buildIdKey-})
 		`addInfo` mkStrictnessInfo [WwStrict] Nothing)
@@ -498,7 +639,7 @@ mkBuild ty tv c n g expr
 
 \begin{code}
 augmentId
-  = pcMiscPrelId augmentIdKey pRELUDE_CORE SLIT("_augment") augmentTy
+  = pcMiscPrelId augmentIdKey pRELUDE_BUILTIN SLIT("_augment") augmentTy
 	(((noIdInfo
 		{-LATER:`addInfo_UF` mkMagicUnfolding augmentIdKey-})
 		`addInfo` mkStrictnessInfo [WwStrict,WwLazy False] Nothing)
diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index 1874d83a4f..d02f5e19a7 100644
--- a/ghc/compiler/prelude/PrimOp.lhs
+++ b/ghc/compiler/prelude/PrimOp.lhs
@@ -20,6 +20,7 @@ module PrimOp (
 	primOpOkForSpeculation, primOpIsCheap,
 	fragilePrimOp,
 	HeapRequirement(..), primOpHeapReq,
+	StackRequirement(..), primOpStackRequired,	
 
        -- export for the Native Code Generator
 	primOpInfo, -- needed for primOpNameInfo
@@ -45,7 +46,7 @@ import TyCon		( TyCon{-instances-} )
 import Type		( getAppDataTyConExpandingDicts, maybeAppDataTyConExpandingDicts,
 			  mkForAllTys, mkFunTys, applyTyCon, typePrimRep
 			)
-import TyVar		( alphaTyVar, betaTyVar, GenTyVar{-instance Eq-} )
+import TyVar		( alphaTyVar, betaTyVar, gammaTyVar, GenTyVar{-instance Eq-} )
 import Unique		( Unique{-instance Eq-} )
 import Util		( panic#, assoc, panic{-ToDo:rm-} )
 \end{code}
@@ -144,8 +145,8 @@ data PrimOp
     | IndexOffAddrOp	PrimRep
 	-- PrimRep can be one of {Char,Int,Addr,Float,Double}Kind.
 	-- This is just a cheesy encoding of a bunch of ops.
-	-- Note that MallocPtrRep is not included -- the only way of
-	-- creating a MallocPtr is with a ccall or casm.
+	-- Note that ForeignObjRep is not included -- the only way of
+	-- creating a ForeignObj is with a ccall or casm.
 
     | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp
 
@@ -153,6 +154,7 @@ data PrimOp
     | TakeMVarOp | PutMVarOp
     | ReadIVarOp | WriteIVarOp
 
+    | MakeForeignObjOp -- foreign objects (malloc pointers or any old URL)
     | MakeStablePtrOp | DeRefStablePtrOp
 \end{code}
 
@@ -239,18 +241,19 @@ about using it this way?? ADR)
     | ParOp
     | ForkOp
 
-    -- two for concurrency
+    -- three for concurrency
     | DelayOp
-    | WaitOp
+    | WaitReadOp
+    | WaitWriteOp
 
-#ifdef GRAN
     | ParGlobalOp	-- named global par
     | ParLocalOp	-- named local par
     | ParAtOp		-- specifies destination of local par
+    | ParAtAbsOp	-- specifies destination of local par (abs processor)
+    | ParAtRelOp	-- specifies destination of local par (rel processor)
     | ParAtForNowOp	-- specifies initial destination of global par
     | CopyableOp	-- marks copyable code
     | NoFollowOp	-- marks non-followup expression
-#endif {-GRAN-}
 \end{code}
 
 Deriving Ix is what we really want! ToDo
@@ -409,25 +412,27 @@ tagOf_PrimOp TakeMVarOp		    	    = ILIT(151)
 tagOf_PrimOp PutMVarOp		    	    = ILIT(152)
 tagOf_PrimOp ReadIVarOp		    	    = ILIT(153)
 tagOf_PrimOp WriteIVarOp		    = ILIT(154)
-tagOf_PrimOp MakeStablePtrOp		    = ILIT(155)
-tagOf_PrimOp DeRefStablePtrOp		    = ILIT(156)
-tagOf_PrimOp (CCallOp _ _ _ _ _)	    = ILIT(157)
-tagOf_PrimOp ErrorIOPrimOp		    = ILIT(158)
-tagOf_PrimOp ReallyUnsafePtrEqualityOp	    = ILIT(159)
-tagOf_PrimOp SeqOp			    = ILIT(160)
-tagOf_PrimOp ParOp			    = ILIT(161)
-tagOf_PrimOp ForkOp			    = ILIT(162)
-tagOf_PrimOp DelayOp			    = ILIT(163)
-tagOf_PrimOp WaitOp			    = ILIT(164)
-
-#ifdef GRAN
-tagOf_PrimOp ParGlobalOp		    = ILIT(165)
-tagOf_PrimOp ParLocalOp			    = ILIT(166)
-tagOf_PrimOp ParAtOp			    = ILIT(167)
-tagOf_PrimOp ParAtForNowOp		    = ILIT(168)
-tagOf_PrimOp CopyableOp			    = ILIT(169)
-tagOf_PrimOp NoFollowOp			    = ILIT(170)
-#endif {-GRAN-}
+tagOf_PrimOp MakeForeignObjOp		    = ILIT(155)
+tagOf_PrimOp MakeStablePtrOp		    = ILIT(156)
+tagOf_PrimOp DeRefStablePtrOp		    = ILIT(157)
+tagOf_PrimOp (CCallOp _ _ _ _ _)	    = ILIT(158)
+tagOf_PrimOp ErrorIOPrimOp		    = ILIT(159)
+tagOf_PrimOp ReallyUnsafePtrEqualityOp	    = ILIT(160)
+tagOf_PrimOp SeqOp			    = ILIT(161)
+tagOf_PrimOp ParOp			    = ILIT(162)
+tagOf_PrimOp ForkOp			    = ILIT(163)
+tagOf_PrimOp DelayOp			    = ILIT(164)
+tagOf_PrimOp WaitReadOp			    = ILIT(165)
+tagOf_PrimOp WaitWriteOp		    = ILIT(166)
+
+tagOf_PrimOp ParGlobalOp		    = ILIT(167)
+tagOf_PrimOp ParLocalOp			    = ILIT(168)
+tagOf_PrimOp ParAtOp			    = ILIT(169)
+tagOf_PrimOp ParAtAbsOp			    = ILIT(170)
+tagOf_PrimOp ParAtRelOp			    = ILIT(171)
+tagOf_PrimOp ParAtForNowOp		    = ILIT(172)
+tagOf_PrimOp CopyableOp			    = ILIT(173)
+tagOf_PrimOp NoFollowOp			    = ILIT(174)
 
 tagOf_PrimOp _ = panic# "tagOf_PrimOp: pattern-match"
 
@@ -591,19 +596,25 @@ allThePrimOps
 	PutMVarOp,
 	ReadIVarOp,
 	WriteIVarOp,
+	MakeForeignObjOp,
 	MakeStablePtrOp,
 	DeRefStablePtrOp,
 	ReallyUnsafePtrEqualityOp,
 	ErrorIOPrimOp,
-#ifdef GRAN
 	ParGlobalOp,
 	ParLocalOp,
-#endif {-GRAN-}
+	ParAtOp,
+	ParAtAbsOp,
+	ParAtRelOp,
+	ParAtForNowOp,
+	CopyableOp,
+	NoFollowOp,
 	SeqOp,
     	ParOp,
     	ForkOp,
 	DelayOp,
-	WaitOp
+	WaitReadOp,
+	WaitWriteOp
     ]
 \end{code}
 
@@ -1117,16 +1128,56 @@ primOpInfo DelayOp
 	[intPrimTy, mkStatePrimTy s]
 	statePrimTyCon VoidRep [s]
 
-primOpInfo WaitOp
+primOpInfo WaitReadOp
   = let {
 	s = alphaTy; s_tv = alphaTyVar
     } in
-    PrimResult SLIT("wait#") [s_tv]
+    PrimResult SLIT("waitRead#") [s_tv]
 	[intPrimTy, mkStatePrimTy s]
 	statePrimTyCon VoidRep [s]
 
+primOpInfo WaitWriteOp
+  = let {
+	s = alphaTy; s_tv = alphaTyVar
+    } in
+    PrimResult SLIT("waitWrite#") [s_tv]
+	[intPrimTy, mkStatePrimTy s]
+	statePrimTyCon VoidRep [s]
 \end{code}
 
+%************************************************************************
+%*									*
+\subsubsection[PrimOps-makeForeignObj]{PrimOpInfo for Foreign Objects}
+%*									*
+%************************************************************************
+
+Not everything should/can be in the Haskell heap. As an example, in an
+image processing application written in Haskell, you really would like
+to avoid heaving huge images between different space or generations of
+a garbage collector. Instead use @ForeignObj@ (formerly known as @MallocPtr@),
+which refer to some externally allocated structure/value. Using @ForeignObj@,
+just a reference to an image is present in the heap, the image could then
+be stored outside the Haskell heap, i.e., as a malloc'ed structure or in
+a completely separate address space alltogether. 
+
+When a @ForeignObj@ becomes garbage, a user-defined finalisation routine
+associated with the object is invoked (currently, each ForeignObj has a
+direct reference to its finaliser).  -- SOF
+
+The only function defined over @ForeignObj@s is:
+
+\begin{pseudocode}
+makeForeignObj# :: Addr#  -- foreign object
+                -> Addr#  -- ptr to its finaliser routine
+		-> StateAndForeignObj# _RealWorld# ForeignObj#
+\end{pseudocode}
+
+\begin{code}
+primOpInfo MakeForeignObjOp
+  = AlgResult SLIT("makeForeignObj#") [] 
+	[addrPrimTy, addrPrimTy, realWorldStatePrimTy] 
+	stateAndForeignObjPrimTyCon [realWorldTy]
+\end{code}
 
 %************************************************************************
 %*									*
@@ -1239,27 +1290,26 @@ primOpInfo ForkOp	-- fork# :: a -> Int#
 \end{code}
 
 \begin{code}
-#ifdef GRAN
-
-primOpInfo ParGlobalOp	-- parGlobal# :: Int -> a -> b -> b
-  = AlgResult SLIT("parGlobal#")	[alphaTyVar,betaTyVar] [intPrimTy,alphaTy,betaTy] liftTyCon [betaTy]
+-- HWL: The first 4 Int# in all par... annotations denote:
+--   name, granularity info, size of result, degree of parallelism
 
-primOpInfo ParLocalOp	-- parLocal# :: Int -> a -> b -> b
-  = AlgResult SLIT("parLocal#")	[alphaTyVar,betaTyVar] [intPrimTy,alphaTy,betaTy] liftTyCon [betaTy]
+primOpInfo ParGlobalOp	-- parGlobal# :: Int# -> Int# -> Int# -> Int# -> a -> b -> b
+  = AlgResult SLIT("parGlobal#")	[alphaTyVar,betaTyVar] [alphaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,betaTy] liftTyCon [betaTy]
 
-primOpInfo ParAtOp	-- parAt# :: Int -> a -> b -> c -> c
-  = AlgResult SLIT("parAt#")	[alphaTyVar,betaTyVar,gammaTyVar] [intPrimTy,alphaTy,betaTy,gammaTy] liftTyCon [gammaTy]
+primOpInfo ParLocalOp	-- parLocal# :: Int# -> Int# -> Int# -> Int# -> a -> b -> b
+  = AlgResult SLIT("parLocal#")	[alphaTyVar,betaTyVar] [alphaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,betaTy] liftTyCon [betaTy]
 
-primOpInfo ParAtForNowOp	-- parAtForNow# :: Int -> a -> b -> c -> c
-  = AlgResult SLIT("parAtForNow#")	[alphaTyVar,betaTyVar,gammaTyVar] [intPrimTy,alphaTy,betaTy,gammaTy] liftTyCon [gammaTy]
+primOpInfo ParAtOp	-- parAt# :: Int# -> Int# -> Int# -> Int# -> a -> b -> c -> c
+  = AlgResult SLIT("parAt#")	[alphaTyVar,betaTyVar,gammaTyVar] [alphaTy,betaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,gammaTy] liftTyCon [gammaTy]
 
-primOpInfo CopyableOp	-- copyable# :: a -> a
-  = AlgResult SLIT("copyable#")	[alphaTyVar] [alphaTy] liftTyCon [alphaTy]
+primOpInfo ParAtAbsOp	-- parAtAbs# :: Int# -> Int# -> Int# -> Int# -> Int# -> a -> b -> b
+  = AlgResult SLIT("parAtAbs#")	[alphaTyVar,betaTyVar] [alphaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,betaTy] liftTyCon [betaTy]
 
-primOpInfo NoFollowOp	-- noFollow# :: a -> a
-  = AlgResult SLIT("noFollow#")	[alphaTyVar] [alphaTy] liftTyCon [alphaTy]
+primOpInfo ParAtRelOp	-- parAtRel# :: Int# -> Int# -> Int# -> Int# -> Int# -> a -> b -> b
+  = AlgResult SLIT("parAtRel#")	[alphaTyVar,betaTyVar] [alphaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,betaTy] liftTyCon [betaTy]
 
-#endif {-GRAN-}
+primOpInfo ParAtForNowOp	-- parAtForNow# :: Int# -> Int# -> Int# -> Int# -> a -> b -> c -> c
+  = AlgResult SLIT("parAtForNow#")	[alphaTyVar,betaTyVar,gammaTyVar] [alphaTy,betaTy,intPrimTy,intPrimTy,intPrimTy,intPrimTy,gammaTy] liftTyCon [gammaTy]
 \end{code}
 
 %************************************************************************
@@ -1337,18 +1387,12 @@ primOpHeapReq DoubleDecodeOp	= FixedHeapRequired
     	    	    	    	    	  (intOff mIN_MP_INT_SIZE)))
 
 -- ccall may allocate heap if it is explicitly allowed to (_ccall_gc_)
--- or if it returns a MallocPtr.
+-- or if it returns a ForeignObj.
 
-primOpHeapReq (CCallOp _ _ mayGC@True _ _) = VariableHeapRequired
-primOpHeapReq (CCallOp _ _ mayGC@False _ return_ty)
-   = if returnsMallocPtr
-     then VariableHeapRequired
-     else NoHeapRequired
-  where
-   returnsMallocPtr
-     = case (maybeAppDataTyConExpandingDicts return_ty) of
-	 Nothing            -> False
-	 Just (tycon, _, _) -> tycon == stateAndMallocPtrPrimTyCon
+primOpHeapReq (CCallOp _ _ mayGC@True  _ _) = VariableHeapRequired
+primOpHeapReq (CCallOp _ _ mayGC@False _ _) = NoHeapRequired
+
+primOpHeapReq MakeForeignObjOp	= VariableHeapRequired
 
 -- this occasionally has to expand the Stable Pointer table
 primOpHeapReq MakeStablePtrOp	= VariableHeapRequired
@@ -1375,24 +1419,31 @@ primOpHeapReq ForkOp	    	= VariableHeapRequired
 -- A SeqOp requires unknown space to evaluate its argument
 primOpHeapReq SeqOp	    	= VariableHeapRequired
 
-#ifdef GRAN
-
--- a ParGlobalOp creates a single 4-tuple in the heap.  ToDo: verify this!
-primOpHeapReq ParGlobalOp	= trace "primOpHeapReq:ParGlobalOp:verify!" (
-				  FixedHeapRequired
-    	    	    	    	  (addOff (totHdrSize (MuTupleRep 4)) (intOff 4))
-				  )
+-- GranSim sparks are stgMalloced i.e. no heap required
+primOpHeapReq ParGlobalOp	= NoHeapRequired
+primOpHeapReq ParLocalOp	= NoHeapRequired
+primOpHeapReq ParAtOp	        = NoHeapRequired
+primOpHeapReq ParAtAbsOp	= NoHeapRequired
+primOpHeapReq ParAtRelOp	= NoHeapRequired
+primOpHeapReq ParAtForNowOp	= NoHeapRequired
+-- CopyableOp and NoFolowOp don't require heap; don't rely on default
+primOpHeapReq CopyableOp	= NoHeapRequired
+primOpHeapReq NoFollowOp	= NoHeapRequired
 
--- a ParLocalOp creates a single 4-tuple in the heap.  ToDo: verify this!
-primOpHeapReq ParLocalOp	= trace "primOpHeapReq:ParLocalOp:verify!" (
-				  FixedHeapRequired
-    	    	    	    	  (addOff (totHdrSize (MuTupleRep 4)) (intOff 4))
-				  )
+primOpHeapReq other_op	    	= NoHeapRequired
+\end{code}
 
--- ToDo: parAt, parAtForNow, copyable, noFollow !!  (HWL)
-#endif {-GRAN-}
+The amount of stack required by primops.
 
-primOpHeapReq other_op	    	= NoHeapRequired
+\begin{code}
+data StackRequirement
+  = NoStackRequired 
+  | FixedStackRequired Int {-AStack-} Int {-BStack-}
+  | VariableStackRequired
+     
+primOpStackRequired SeqOp = FixedStackRequired 0 {-AStack-} 2 {-BStack-}
+primOpStackRequired _     = VariableStackRequired 
+-- ToDo: be more specific for certain primops (currently only used for seq)
 \end{code}
 
 Primops which can trigger GC have to be called carefully.
@@ -1405,7 +1456,8 @@ primOpCanTriggerGC op
     	TakeMVarOp  -> True
     	ReadIVarOp  -> True
 	DelayOp     -> True
-	WaitOp      -> True
+	WaitReadOp  -> True
+	WaitWriteOp -> True
 	_           ->
 	    case primOpHeapReq op of
     	    	VariableHeapRequired -> True
@@ -1457,10 +1509,14 @@ primOpOkForSpeculation ParOp		= False	    	-- Could be expensive!
 primOpOkForSpeculation ForkOp	    	= False	    	-- Likewise
 primOpOkForSpeculation SeqOp	    	= False	    	-- Likewise
 
-#ifdef GRAN
 primOpOkForSpeculation ParGlobalOp	= False	    	-- Could be expensive!
 primOpOkForSpeculation ParLocalOp	= False	    	-- Could be expensive!
-#endif {-GRAN-}
+primOpOkForSpeculation ParAtOp		= False	    	-- Could be expensive!
+primOpOkForSpeculation ParAtAbsOp	= False	    	-- Could be expensive!
+primOpOkForSpeculation ParAtRelOp	= False	    	-- Could be expensive!
+primOpOkForSpeculation ParAtForNowOp	= False	    	-- Could be expensive!
+primOpOkForSpeculation CopyableOp	= False	    	-- only tags closure
+primOpOkForSpeculation NoFollowOp	= False	    	-- only tags closure
 
 -- The default is "yes it's ok for speculation"
 primOpOkForSpeculation other_op		= True
@@ -1483,15 +1539,18 @@ fragilePrimOp :: PrimOp -> Bool
 fragilePrimOp ParOp = True
 fragilePrimOp ForkOp = True
 fragilePrimOp SeqOp = True
-fragilePrimOp MakeStablePtrOp = True
+fragilePrimOp MakeForeignObjOp = True  -- SOF
+fragilePrimOp MakeStablePtrOp  = True
 fragilePrimOp DeRefStablePtrOp = True  -- ??? JSM & ADR
 
-#ifdef GRAN
 fragilePrimOp ParGlobalOp = True
 fragilePrimOp ParLocalOp = True
-fragilePrimOp CopyableOp = trace "fragilePrimOp:CopyableOp" True  -- Possibly not.  ASP
-fragilePrimOp NoFollowOp = trace "fragilePrimOp:NoFollowOp" True  -- Possibly not.  ASP
-#endif {-GRAN-}
+fragilePrimOp ParAtOp = True
+fragilePrimOp ParAtAbsOp = True
+fragilePrimOp ParAtRelOp = True
+fragilePrimOp ParAtForNowOp = True
+fragilePrimOp CopyableOp = True  -- Possibly not.  ASP 
+fragilePrimOp NoFollowOp = True  -- Possibly not.  ASP
 
 fragilePrimOp other = False
 \end{code}
@@ -1551,6 +1610,7 @@ primOpNeedsWrapper DoublePowerOp    	= True
 primOpNeedsWrapper DoubleEncodeOp   	= True
 primOpNeedsWrapper DoubleDecodeOp	= True
 
+primOpNeedsWrapper MakeForeignObjOp	= True
 primOpNeedsWrapper MakeStablePtrOp	= True
 primOpNeedsWrapper DeRefStablePtrOp	= True
 
@@ -1559,7 +1619,8 @@ primOpNeedsWrapper PutMVarOp		= True
 primOpNeedsWrapper ReadIVarOp	    	= True
 
 primOpNeedsWrapper DelayOp	    	= True
-primOpNeedsWrapper WaitOp		= True
+primOpNeedsWrapper WaitReadOp		= True
+primOpNeedsWrapper WaitWriteOp		= True
 
 primOpNeedsWrapper other_op 	    	= False
 \end{code}
diff --git a/ghc/compiler/prelude/PrimRep.lhs b/ghc/compiler/prelude/PrimRep.lhs
index b4fbf55e9f..1a6d45e5e1 100644
--- a/ghc/compiler/prelude/PrimRep.lhs
+++ b/ghc/compiler/prelude/PrimRep.lhs
@@ -50,7 +50,7 @@ data PrimRep
   | FloatRep		--	   floats
   | DoubleRep		--	   doubles
 
-  | MallocPtrRep	-- This has to be a special kind because ccall
+  | ForeignObjRep	-- This has to be a special kind because ccall
 			-- generates special code when passing/returning
 			-- one of these. [ADR]
 
@@ -86,7 +86,8 @@ isFollowableRep :: PrimRep -> Bool
 isFollowableRep PtrRep        = True
 isFollowableRep ArrayRep      = True
 isFollowableRep ByteArrayRep  = True
-isFollowableRep MallocPtrRep  = True
+-- why is a MallocPtr followable? 4/96 SOF
+-- isFollowableRep ForeignObjRep  = True
 
 isFollowableRep StablePtrRep  = False
 -- StablePtrs aren't followable because they are just indices into a
@@ -166,7 +167,7 @@ showPrimRep DoubleRep	  = "StgDouble"
 showPrimRep ArrayRep	  = "StgArray" -- see comment below
 showPrimRep ByteArrayRep  = "StgByteArray"
 showPrimRep StablePtrRep  = "StgStablePtr"
-showPrimRep MallocPtrRep  = "StgPtr" -- see comment below
+showPrimRep ForeignObjRep  = "StgPtr" -- see comment below
 showPrimRep VoidRep	  = "!!VOID_KIND!!"
 
 guessPrimRep "D_"	     = DataPtrRep
@@ -186,15 +187,17 @@ All local C variables of @ArrayRep@ are declared in C as type
 @StgArray@.  The coercion to a more precise C type is done just before
 indexing (by the relevant C primitive-op macro).
 
-Nota Bene. There are three types associated with Malloc Pointers:
+Nota Bene. There are three types associated with @ForeignObj@ (MallocPtr++): 
 \begin{itemize}
 \item
-@StgMallocClosure@ is the type of the thing the C world gives us.
+@StgForeignObjClosure@ is the type of the thing the prim. op @mkForeignObj@ returns.
+{- old comment for MallocPtr
 (This typename is hardwired into @ppr_casm_results@ in
 @PprAbsC.lhs@.)
+-}
 
 \item
-@StgMallocPtr@ is the type of the thing we give the C world.
+@StgForeignObj@ is the type of the thing we give the C world.
 
 \item
 @StgPtr@ is the type of the (pointer to the) heap object which we
diff --git a/ghc/compiler/prelude/TysPrim.lhs b/ghc/compiler/prelude/TysPrim.lhs
index a64821db44..28b4571219 100644
--- a/ghc/compiler/prelude/TysPrim.lhs
+++ b/ghc/compiler/prelude/TysPrim.lhs
@@ -182,25 +182,26 @@ mkStablePtrPrimTy ty = applyTyCon stablePtrPrimTyCon [ty]
 
 %************************************************************************
 %*									*
-\subsection[TysPrim-malloc-ptrs]{The ``malloc''-pointer type}
+\subsection[TysPrim-foreign-objs]{The ``foreign object'' type}
 %*									*
 %************************************************************************
 
-``Malloc'' pointers provide a mechanism which will let Haskell's
-garbage collector communicate with a {\em simple\/} garbage collector
-in the IO world (probably \tr{malloc}, hence the name).We want Haskell
-to be able to hold onto references to objects in the IO world and for
-Haskell's garbage collector to tell the IO world when these references
-become garbage.  We are not aiming to provide a mechanism that could
+Foreign objects (formerly ``Malloc'' pointers) provide a mechanism which
+will let Haskell's garbage collector communicate with a {\em simple\/}
+garbage collector in the IO world. We want Haskell to be able to hold
+onto references to objects in the IO world and for Haskell's garbage
+collector to tell the IO world when these references become garbage.
+We are not aiming to provide a mechanism that could
 talk to a sophisticated garbage collector such as that provided by a
 LISP system (with a correspondingly complex interface); in particular,
 we shall ignore the danger of circular structures spread across the
 two systems.
 
-There are no primitive operations on @CHeapPtr#@s (although equality
+There are no primitive operations on @ForeignObj#@s (although equality
 could possibly be added?)
 
 \begin{code}
-mallocPtrPrimTyCon = pcPrimTyCon mallocPtrPrimTyConKey SLIT("MallocPtr#") 0
-			(\ [] -> MallocPtrRep)
+foreignObjPrimTy    = applyTyCon foreignObjPrimTyCon []
+foreignObjPrimTyCon = pcPrimTyCon foreignObjPrimTyConKey SLIT("ForeignObj#") 0
+			(\ [] -> ForeignObjRep)
 \end{code}
diff --git a/ghc/compiler/prelude/TysWiredIn.lhs b/ghc/compiler/prelude/TysWiredIn.lhs
index 2efbb8494a..a4623c2fd2 100644
--- a/ghc/compiler/prelude/TysWiredIn.lhs
+++ b/ghc/compiler/prelude/TysWiredIn.lhs
@@ -42,7 +42,7 @@ module TysWiredIn (
 	liftTyCon,
 	listTyCon,
 	ltDataCon,
-	mallocPtrTyCon,
+	foreignObjTyCon,
 	mkLiftTy,
 	mkListTy,
 	mkPrimIoTy,
@@ -68,7 +68,7 @@ module TysWiredIn (
 	stateAndDoublePrimTyCon,
 	stateAndFloatPrimTyCon,
 	stateAndIntPrimTyCon,
-	stateAndMallocPtrPrimTyCon,
+	stateAndForeignObjPrimTyCon,
 	stateAndMutableArrayPrimTyCon,
 	stateAndMutableByteArrayPrimTyCon,
 	stateAndPtrPrimTyCon,
@@ -219,17 +219,17 @@ stablePtrTyCon
   where
     stablePtrDataCon
       = pcDataCon stablePtrDataConKey gLASGOW_MISC SLIT("_StablePtr")
-	    [alphaTyVar] [] [applyTyCon stablePtrPrimTyCon [alphaTy]] stablePtrTyCon nullSpecEnv
+	    [alphaTyVar] [] [mkStablePtrPrimTy alphaTy] stablePtrTyCon nullSpecEnv
 \end{code}
 
 \begin{code}
-mallocPtrTyCon
-  = pcDataTyCon mallocPtrTyConKey gLASGOW_MISC SLIT("_MallocPtr")
-	[] [mallocPtrDataCon]
+foreignObjTyCon
+  = pcDataTyCon foreignObjTyConKey gLASGOW_MISC SLIT("_ForeignObj")
+	[] [foreignObjDataCon]
   where
-    mallocPtrDataCon
-      = pcDataCon mallocPtrDataConKey gLASGOW_MISC SLIT("_MallocPtr")
-	    [] [] [applyTyCon mallocPtrPrimTyCon []] mallocPtrTyCon nullSpecEnv
+    foreignObjDataCon
+      = pcDataCon foreignObjDataConKey gLASGOW_MISC SLIT("_ForeignObj")
+	    [] [] [foreignObjPrimTy] foreignObjTyCon nullSpecEnv
 \end{code}
 
 %************************************************************************
@@ -330,14 +330,14 @@ stateAndStablePtrPrimDataCon
 		[mkStatePrimTy alphaTy, applyTyCon stablePtrPrimTyCon [betaTy]]
 		stateAndStablePtrPrimTyCon nullSpecEnv
 
-stateAndMallocPtrPrimTyCon
-  = pcDataTyCon stateAndMallocPtrPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndMallocPtr#")
-		[alphaTyVar] [stateAndMallocPtrPrimDataCon]
-stateAndMallocPtrPrimDataCon
-  = pcDataCon stateAndMallocPtrPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndMallocPtr#")
+stateAndForeignObjPrimTyCon
+  = pcDataTyCon stateAndForeignObjPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndForeignObj#")
+		[alphaTyVar] [stateAndForeignObjPrimDataCon]
+stateAndForeignObjPrimDataCon
+  = pcDataCon stateAndForeignObjPrimDataConKey pRELUDE_BUILTIN SLIT("StateAndForeignObj#")
 		[alphaTyVar] []
-		[mkStatePrimTy alphaTy, applyTyCon mallocPtrPrimTyCon []]
-		stateAndMallocPtrPrimTyCon nullSpecEnv
+		[mkStatePrimTy alphaTy, applyTyCon foreignObjPrimTyCon []]
+		stateAndForeignObjPrimTyCon nullSpecEnv
 
 stateAndFloatPrimTyCon
   = pcDataTyCon stateAndFloatPrimTyConKey pRELUDE_BUILTIN SLIT("StateAndFloat#")
@@ -424,7 +424,7 @@ getStatePairingConInfo prim_ty
 	(wordPrimTyCon, (stateAndWordPrimDataCon, stateAndWordPrimTyCon, 0)),
 	(addrPrimTyCon, (stateAndAddrPrimDataCon, stateAndAddrPrimTyCon, 0)),
 	(stablePtrPrimTyCon, (stateAndStablePtrPrimDataCon, stateAndStablePtrPrimTyCon, 0)),
-	(mallocPtrPrimTyCon, (stateAndMallocPtrPrimDataCon, stateAndMallocPtrPrimTyCon, 0)),
+	(foreignObjPrimTyCon, (stateAndForeignObjPrimDataCon, stateAndForeignObjPrimTyCon, 0)),
 	(floatPrimTyCon, (stateAndFloatPrimDataCon, stateAndFloatPrimTyCon, 0)),
 	(doublePrimTyCon, (stateAndDoublePrimDataCon, stateAndDoublePrimTyCon, 0)),
 	(arrayPrimTyCon, (stateAndArrayPrimDataCon, stateAndArrayPrimTyCon, 0)),
@@ -531,10 +531,10 @@ primitive counterpart.
 \begin{code}
 boolTy = mkTyConTy boolTyCon
 
-boolTyCon = pcDataTyCon boolTyConKey pRELUDE_CORE SLIT("Bool") [] [falseDataCon, trueDataCon]
+boolTyCon = pcDataTyCon boolTyConKey pRELUDE SLIT("Bool") [] [falseDataCon, trueDataCon]
 
-falseDataCon = pcDataCon falseDataConKey pRELUDE_CORE SLIT("False") [] [] [] boolTyCon nullSpecEnv
-trueDataCon  = pcDataCon trueDataConKey	 pRELUDE_CORE SLIT("True")  [] [] [] boolTyCon nullSpecEnv
+falseDataCon = pcDataCon falseDataConKey pRELUDE SLIT("False") [] [] [] boolTyCon nullSpecEnv
+trueDataCon  = pcDataCon trueDataConKey	 pRELUDE SLIT("True")  [] [] [] boolTyCon nullSpecEnv
 \end{code}
 
 %************************************************************************
@@ -660,15 +660,15 @@ rationalTy :: GenType t u
 mkRatioTy ty = applyTyCon ratioTyCon [ty]
 rationalTy   = mkRatioTy integerTy
 
-ratioTyCon = pcDataTyCon ratioTyConKey pRELUDE_RATIO SLIT("Ratio") [alphaTyVar] [ratioDataCon]
+ratioTyCon = pcDataTyCon ratioTyConKey rATIO SLIT("Ratio") [alphaTyVar] [ratioDataCon]
 
-ratioDataCon = pcDataCon ratioDataConKey pRELUDE_RATIO SLIT(":%")
+ratioDataCon = pcDataCon ratioDataConKey rATIO SLIT(":%")
 		[alphaTyVar] [{-(integralClass,alphaTy)-}] [alphaTy, alphaTy] ratioTyCon nullSpecEnv
 	-- context omitted to match lib/prelude/ defn of "data Ratio ..."
 
 rationalTyCon
   = mkSynTyCon
-      (mkBuiltinName rationalTyConKey pRELUDE_RATIO SLIT("Rational"))
+      (mkBuiltinName rationalTyConKey rATIO SLIT("Rational"))
       mkBoxedTypeKind
       0	[] rationalTy -- == mkRatioTy integerTy
 \end{code}
@@ -725,7 +725,7 @@ stringTy = mkListTy charTy
 
 stringTyCon
  = mkSynTyCon
-     (mkBuiltinName stringTyConKey pRELUDE_CORE SLIT("String"))
+     (mkBuiltinName stringTyConKey pRELUDE SLIT("String"))
      mkBoxedTypeKind
      0 [] stringTy
 \end{code}