Formatting fixes

4 files changed, 508 insertions, 526 deletions

diff --git a/compiler/codeGen/CgCallConv.hs b/compiler/codeGen/CgCallConv.hs
index 0a3911ea82..c65194b62f 100644
--- a/compiler/codeGen/CgCallConv.hs
+++ b/compiler/codeGen/CgCallConv.hs
@@ -4,34 +4,27 @@
 --
 -- CgCallConv
 --
--- The datatypes and functions here encapsulate the 
+-- The datatypes and functions here encapsulate the
 -- calling and return conventions used by the code generator.
 --
 -----------------------------------------------------------------------------
 
-{-# OPTIONS -fno-warn-tabs #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and
--- detab the module (please do the detabbing in a separate patch). See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
--- for details
-
 module CgCallConv (
-	-- Argument descriptors
-	mkArgDescr, 
+        -- Argument descriptors
+        mkArgDescr,
 
-	-- Liveness
-	mkRegLiveness, 
+        -- Liveness
+        mkRegLiveness,
 
-	-- Register assignment
-	assignCallRegs, assignReturnRegs, assignPrimOpCallRegs,
+        -- Register assignment
+        assignCallRegs, assignReturnRegs, assignPrimOpCallRegs,
 
-	-- Calls
-	constructSlowCall, slowArgs, slowCallPattern,
+        -- Calls
+        constructSlowCall, slowArgs, slowCallPattern,
 
-	-- Returns
-	dataReturnConvPrim,
-	getSequelAmode
+        -- Returns
+        dataReturnConvPrim,
+        getSequelAmode
     ) where
 
 import CgMonad
@@ -57,11 +50,11 @@ import Data.Bits
 
 -------------------------------------------------------------------------
 --
---	Making argument descriptors
+--      Making argument descriptors
 --
 --  An argument descriptor describes the layout of args on the stack,
---  both for 	* GC (stack-layout) purposes, and 
---		* saving/restoring registers when a heap-check fails
+--  both for    * GC (stack-layout) purposes, and
+--              * saving/restoring registers when a heap-check fails
 --
 -- Void arguments aren't important, therefore (contrast constructSlowCall)
 --
@@ -72,29 +65,29 @@ import Data.Bits
 
 -------------------------
 mkArgDescr :: Name -> [Id] -> FCode ArgDescr
-mkArgDescr _nm args 
+mkArgDescr _nm args
   = case stdPattern arg_reps of
-	Just spec_id -> return (ArgSpec spec_id)
-	Nothing      -> return (ArgGen arg_bits)
+        Just spec_id -> return (ArgSpec spec_id)
+        Nothing      -> return (ArgGen arg_bits)
   where
     arg_bits = argBits arg_reps
     arg_reps = filter nonVoidArg (map idCgRep args)
-	-- Getting rid of voids eases matching of standard patterns
+        -- Getting rid of voids eases matching of standard patterns
 
-argBits :: [CgRep] -> [Bool]	-- True for non-ptr, False for ptr
-argBits [] 		= []
+argBits :: [CgRep] -> [Bool]    -- True for non-ptr, False for ptr
+argBits []              = []
 argBits (PtrArg : args) = False : argBits args
 argBits (arg    : args) = take (cgRepSizeW arg) (repeat True) ++ argBits args
 
 stdPattern :: [CgRep] -> Maybe StgHalfWord
-stdPattern []          = Just ARG_NONE	-- just void args, probably
+stdPattern []          = Just ARG_NONE  -- just void args, probably
 
 stdPattern [PtrArg]    = Just ARG_P
 stdPattern [FloatArg]  = Just ARG_F
 stdPattern [DoubleArg] = Just ARG_D
 stdPattern [LongArg]   = Just ARG_L
 stdPattern [NonPtrArg] = Just ARG_N
-	 
+
 stdPattern [NonPtrArg,NonPtrArg] = Just ARG_NN
 stdPattern [NonPtrArg,PtrArg]    = Just ARG_NP
 stdPattern [PtrArg,NonPtrArg]    = Just ARG_PN
@@ -103,13 +96,13 @@ stdPattern [PtrArg,PtrArg]       = Just ARG_PP
 stdPattern [NonPtrArg,NonPtrArg,NonPtrArg] = Just ARG_NNN
 stdPattern [NonPtrArg,NonPtrArg,PtrArg]    = Just ARG_NNP
 stdPattern [NonPtrArg,PtrArg,NonPtrArg]    = Just ARG_NPN
-stdPattern [NonPtrArg,PtrArg,PtrArg]	   = Just ARG_NPP
+stdPattern [NonPtrArg,PtrArg,PtrArg]       = Just ARG_NPP
 stdPattern [PtrArg,NonPtrArg,NonPtrArg]    = Just ARG_PNN
-stdPattern [PtrArg,NonPtrArg,PtrArg]	   = Just ARG_PNP
-stdPattern [PtrArg,PtrArg,NonPtrArg]	   = Just ARG_PPN
-stdPattern [PtrArg,PtrArg,PtrArg]	   = Just ARG_PPP
-	 
-stdPattern [PtrArg,PtrArg,PtrArg,PtrArg]	       = Just ARG_PPPP
+stdPattern [PtrArg,NonPtrArg,PtrArg]       = Just ARG_PNP
+stdPattern [PtrArg,PtrArg,NonPtrArg]       = Just ARG_PPN
+stdPattern [PtrArg,PtrArg,PtrArg]          = Just ARG_PPP
+
+stdPattern [PtrArg,PtrArg,PtrArg,PtrArg]               = Just ARG_PPPP
 stdPattern [PtrArg,PtrArg,PtrArg,PtrArg,PtrArg]        = Just ARG_PPPPP
 stdPattern [PtrArg,PtrArg,PtrArg,PtrArg,PtrArg,PtrArg] = Just ARG_PPPPPP
 stdPattern _ = Nothing
@@ -117,17 +110,17 @@ stdPattern _ = Nothing
 
 -------------------------------------------------------------------------
 --
---		Bitmap describing register liveness
---		across GC when doing a "generic" heap check
---		(a RET_DYN stack frame).
+--              Bitmap describing register liveness
+--              across GC when doing a "generic" heap check
+--              (a RET_DYN stack frame).
 --
--- NB. Must agree with these macros (currently in StgMacros.h): 
+-- NB. Must agree with these macros (currently in StgMacros.h):
 -- GET_NON_PTRS(), GET_PTRS(), GET_LIVENESS().
 -------------------------------------------------------------------------
 
 mkRegLiveness :: [(Id, GlobalReg)] -> Int -> Int -> StgWord
 mkRegLiveness regs ptrs nptrs
-  = (fromIntegral nptrs `shiftL` 16) .|. 
+  = (fromIntegral nptrs `shiftL` 16) .|.
     (fromIntegral ptrs  `shiftL` 24) .|.
     all_non_ptrs `xor` reg_bits regs
   where
@@ -135,31 +128,31 @@ mkRegLiveness regs ptrs nptrs
 
     reg_bits [] = 0
     reg_bits ((id, VanillaReg i _) : regs) | isFollowableArg (idCgRep id)
-  	= (1 `shiftL` (i - 1)) .|. reg_bits regs
+        = (1 `shiftL` (i - 1)) .|. reg_bits regs
     reg_bits (_ : regs)
-	= reg_bits regs
-  
+        = reg_bits regs
+
 -------------------------------------------------------------------------
 --
---		Pushing the arguments for a slow call
+--              Pushing the arguments for a slow call
 --
 -------------------------------------------------------------------------
 
 -- For a slow call, we must take a bunch of arguments and intersperse
 -- some stg_ap_<pattern>_ret_info return addresses.
 constructSlowCall
-	:: [(CgRep,CmmExpr)]
-	-> (CLabel,		-- RTS entry point for call
-	   [(CgRep,CmmExpr)],	-- args to pass to the entry point
-	   [(CgRep,CmmExpr)])	-- stuff to save on the stack
+        :: [(CgRep,CmmExpr)]
+        -> (CLabel,             -- RTS entry point for call
+           [(CgRep,CmmExpr)],   -- args to pass to the entry point
+           [(CgRep,CmmExpr)])   -- stuff to save on the stack
 
    -- don't forget the zero case
-constructSlowCall [] 
+constructSlowCall []
   = (mkRtsApFastLabel (fsLit "stg_ap_0"), [], [])
 
 constructSlowCall amodes
   = (stg_ap_pat, these, rest)
-  where 
+  where
     stg_ap_pat = mkRtsApFastLabel arg_pat
     (arg_pat, these, rest) = matchSlowPattern amodes
 
@@ -178,33 +171,33 @@ slowArgs amodes
     save_cccs  = [(NonPtrArg, mkLblExpr save_cccs_lbl), (NonPtrArg, curCCS)]
     save_cccs_lbl = mkCmmRetInfoLabel rtsPackageId (fsLit "stg_restore_cccs")
 
-matchSlowPattern :: [(CgRep,CmmExpr)] 
-		 -> (FastString, [(CgRep,CmmExpr)], [(CgRep,CmmExpr)])
+matchSlowPattern :: [(CgRep,CmmExpr)]
+                 -> (FastString, [(CgRep,CmmExpr)], [(CgRep,CmmExpr)])
 matchSlowPattern amodes = (arg_pat, these, rest)
   where (arg_pat, n)  = slowCallPattern (map fst amodes)
-	(these, rest) = splitAt n amodes
+        (these, rest) = splitAt n amodes
 
 -- These cases were found to cover about 99% of all slow calls:
 slowCallPattern :: [CgRep] -> (FastString, Int)
 slowCallPattern (PtrArg: PtrArg: PtrArg: PtrArg: PtrArg: PtrArg: _) = (fsLit "stg_ap_pppppp", 6)
-slowCallPattern (PtrArg: PtrArg: PtrArg: PtrArg: PtrArg: _) 	    = (fsLit "stg_ap_ppppp", 5)
-slowCallPattern (PtrArg: PtrArg: PtrArg: PtrArg: _) 	= (fsLit "stg_ap_pppp", 4)
-slowCallPattern (PtrArg: PtrArg: PtrArg: VoidArg: _) 	= (fsLit "stg_ap_pppv", 4)
-slowCallPattern (PtrArg: PtrArg: PtrArg: _)       	= (fsLit "stg_ap_ppp", 3)
-slowCallPattern (PtrArg: PtrArg: VoidArg: _)       	= (fsLit "stg_ap_ppv", 3)
-slowCallPattern (PtrArg: PtrArg: _)			= (fsLit "stg_ap_pp", 2)
-slowCallPattern (PtrArg: VoidArg: _)			= (fsLit "stg_ap_pv", 2)
-slowCallPattern (PtrArg: _)				= (fsLit "stg_ap_p", 1)
-slowCallPattern (VoidArg: _)				= (fsLit "stg_ap_v", 1)
-slowCallPattern (NonPtrArg: _)				= (fsLit "stg_ap_n", 1)
-slowCallPattern (FloatArg: _)				= (fsLit "stg_ap_f", 1)
-slowCallPattern (DoubleArg: _)				= (fsLit "stg_ap_d", 1)
-slowCallPattern (LongArg: _)				= (fsLit "stg_ap_l", 1)
-slowCallPattern _ 					= panic "CgStackery.slowCallPattern"
+slowCallPattern (PtrArg: PtrArg: PtrArg: PtrArg: PtrArg: _)         = (fsLit "stg_ap_ppppp", 5)
+slowCallPattern (PtrArg: PtrArg: PtrArg: PtrArg: _)     = (fsLit "stg_ap_pppp", 4)
+slowCallPattern (PtrArg: PtrArg: PtrArg: VoidArg: _)    = (fsLit "stg_ap_pppv", 4)
+slowCallPattern (PtrArg: PtrArg: PtrArg: _)             = (fsLit "stg_ap_ppp", 3)
+slowCallPattern (PtrArg: PtrArg: VoidArg: _)            = (fsLit "stg_ap_ppv", 3)
+slowCallPattern (PtrArg: PtrArg: _)                     = (fsLit "stg_ap_pp", 2)
+slowCallPattern (PtrArg: VoidArg: _)                    = (fsLit "stg_ap_pv", 2)
+slowCallPattern (PtrArg: _)                             = (fsLit "stg_ap_p", 1)
+slowCallPattern (VoidArg: _)                            = (fsLit "stg_ap_v", 1)
+slowCallPattern (NonPtrArg: _)                          = (fsLit "stg_ap_n", 1)
+slowCallPattern (FloatArg: _)                           = (fsLit "stg_ap_f", 1)
+slowCallPattern (DoubleArg: _)                          = (fsLit "stg_ap_d", 1)
+slowCallPattern (LongArg: _)                            = (fsLit "stg_ap_l", 1)
+slowCallPattern _                                       = panic "CgStackery.slowCallPattern"
 
 -------------------------------------------------------------------------
 --
---		Return conventions
+--              Return conventions
 --
 -------------------------------------------------------------------------
 
@@ -219,7 +212,7 @@ dataReturnConvPrim VoidArg   = panic "dataReturnConvPrim: void"
 
 -- getSequelAmode returns an amode which refers to an info table.  The info
 -- table will always be of the RET_(BIG|SMALL) kind.  We're careful
--- not to handle real code pointers, just in case we're compiling for 
+-- not to handle real code pointers, just in case we're compiling for
 -- an unregisterised/untailcallish architecture, where info pointers and
 -- code pointers aren't the same.
 -- DIRE WARNING.
@@ -230,60 +223,60 @@ dataReturnConvPrim VoidArg   = panic "dataReturnConvPrim: void"
 
 getSequelAmode :: FCode CmmExpr
 getSequelAmode
-  = do	{ EndOfBlockInfo virt_sp sequel <- getEndOfBlockInfo
-	; case sequel of
-	    OnStack -> do { sp_rel <- getSpRelOffset virt_sp
-			  ; returnFC (CmmLoad sp_rel bWord) }
+  = do  { EndOfBlockInfo virt_sp sequel <- getEndOfBlockInfo
+        ; case sequel of
+            OnStack -> do { sp_rel <- getSpRelOffset virt_sp
+                          ; returnFC (CmmLoad sp_rel bWord) }
 
-	    CaseAlts lbl _ _  -> returnFC (CmmLit (CmmLabel lbl))
-	}
+            CaseAlts lbl _ _  -> returnFC (CmmLit (CmmLabel lbl))
+        }
 
 -------------------------------------------------------------------------
 --
---		Register assignment
+--              Register assignment
 --
 -------------------------------------------------------------------------
 
---  How to assign registers for 
+--  How to assign registers for
 --
---	1) Calling a fast entry point.
---	2) Returning an unboxed tuple.
---	3) Invoking an out-of-line PrimOp.
+--      1) Calling a fast entry point.
+--      2) Returning an unboxed tuple.
+--      3) Invoking an out-of-line PrimOp.
 --
 -- Registers are assigned in order.
--- 
+--
 -- If we run out, we don't attempt to assign any further registers (even
 -- though we might have run out of only one kind of register); we just
 -- return immediately with the left-overs specified.
--- 
+--
 -- The alternative version @assignAllRegs@ uses the complete set of
 -- registers, including those that aren't mapped to real machine
 -- registers.  This is used for calling special RTS functions and PrimOps
 -- which expect their arguments to always be in the same registers.
 
 assignCallRegs, assignPrimOpCallRegs, assignReturnRegs
-	:: [(CgRep,a)]		-- Arg or result values to assign
-	-> ([(a, GlobalReg)],	-- Register assignment in same order
-				-- for *initial segment of* input list
-				--   (but reversed; doesn't matter)
-				-- VoidRep args do not appear here
-	    [(CgRep,a)])	-- Leftover arg or result values
+        :: [(CgRep,a)]          -- Arg or result values to assign
+        -> ([(a, GlobalReg)],   -- Register assignment in same order
+                                -- for *initial segment of* input list
+                                --   (but reversed; doesn't matter)
+                                -- VoidRep args do not appear here
+            [(CgRep,a)])        -- Leftover arg or result values
 
 assignCallRegs args
   = assign_regs args (mkRegTbl [node])
-	-- The entry convention for a function closure
-	-- never uses Node for argument passing; instead
-	-- Node points to the function closure itself
+        -- The entry convention for a function closure
+        -- never uses Node for argument passing; instead
+        -- Node points to the function closure itself
 
 assignPrimOpCallRegs args
  = assign_regs args (mkRegTbl_allRegs [])
-	-- For primops, *all* arguments must be passed in registers
+        -- For primops, *all* arguments must be passed in registers
 
 assignReturnRegs args
  -- when we have a single non-void component to return, use the normal
  -- unpointed return convention.  This make various things simpler: it
  -- means we can assume a consistent convention for IO, which is useful
- -- when writing code that relies on knowing the IO return convention in 
+ -- when writing code that relies on knowing the IO return convention in
  -- the RTS (primops, especially exception-related primops).
  -- Also, the bytecode compiler assumes this when compiling
  -- case expressions and ccalls, so it only needs to know one set of
@@ -292,24 +285,24 @@ assignReturnRegs args
     = ([(arg, r)], [])
  | otherwise
     = assign_regs args (mkRegTbl [])
-	-- For returning unboxed tuples etc, 
-	-- we use all regs
- where 
+        -- For returning unboxed tuples etc,
+        -- we use all regs
+ where
        non_void_args = filter ((/= VoidArg).fst) args
 
-assign_regs :: [(CgRep,a)]     	-- Arg or result values to assign
-	    -> AvailRegs	-- Regs still avail: Vanilla, Float, Double, Longs
-	    -> ([(a, GlobalReg)], [(CgRep, a)])
+assign_regs :: [(CgRep,a)]      -- Arg or result values to assign
+            -> AvailRegs        -- Regs still avail: Vanilla, Float, Double, Longs
+            -> ([(a, GlobalReg)], [(CgRep, a)])
 assign_regs args supply
   = go args [] supply
   where
-    go [] acc _ = (acc, [])	-- Return the results reversed (doesn't matter)
-    go ((VoidArg,_) : args) acc supply 	-- Skip void arguments; they aren't passed, and
-	= go args acc supply		-- there's nothing to bind them to
-    go ((rep,arg) : args) acc supply 
-	= case assign_reg rep supply of
-		Just (reg, supply') -> go args ((arg,reg):acc) supply'
-		Nothing	   	    -> (acc, (rep,arg):args) 	-- No more regs
+    go [] acc _ = (acc, [])     -- Return the results reversed (doesn't matter)
+    go ((VoidArg,_) : args) acc supply  -- Skip void arguments; they aren't passed, and
+        = go args acc supply            -- there's nothing to bind them to
+    go ((rep,arg) : args) acc supply
+        = case assign_reg rep supply of
+                Just (reg, supply') -> go args ((arg,reg):acc) supply'
+                Nothing             -> (acc, (rep,arg):args)    -- No more regs
 
 assign_reg :: CgRep -> AvailRegs -> Maybe (GlobalReg, AvailRegs)
 assign_reg FloatArg  (vs, f:fs, ds, ls) = Just (FloatReg f,   (vs, fs, ds, ls))
@@ -323,7 +316,7 @@ assign_reg _         _                  = Nothing
 
 -------------------------------------------------------------------------
 --
---		Register supplies
+--              Register supplies
 --
 -------------------------------------------------------------------------
 
@@ -335,37 +328,37 @@ assign_reg _         _                  = Nothing
 
 useVanillaRegs :: Int
 useVanillaRegs | opt_Unregisterised = 0
-	       | otherwise          = mAX_Real_Vanilla_REG
+               | otherwise          = mAX_Real_Vanilla_REG
 useFloatRegs :: Int
 useFloatRegs   | opt_Unregisterised = 0
-	       | otherwise          = mAX_Real_Float_REG
+               | otherwise          = mAX_Real_Float_REG
 useDoubleRegs :: Int
 useDoubleRegs  | opt_Unregisterised = 0
-	       | otherwise          = mAX_Real_Double_REG
+               | otherwise          = mAX_Real_Double_REG
 useLongRegs :: Int
 useLongRegs    | opt_Unregisterised = 0
-	       | otherwise          = mAX_Real_Long_REG
+               | otherwise          = mAX_Real_Long_REG
 
 vanillaRegNos, floatRegNos, doubleRegNos, longRegNos :: [Int]
-vanillaRegNos	 = regList useVanillaRegs
-floatRegNos	 = regList useFloatRegs
-doubleRegNos	 = regList useDoubleRegs
+vanillaRegNos    = regList useVanillaRegs
+floatRegNos      = regList useFloatRegs
+doubleRegNos     = regList useDoubleRegs
 longRegNos       = regList useLongRegs
 
 allVanillaRegNos, allFloatRegNos, allDoubleRegNos, allLongRegNos :: [Int]
 allVanillaRegNos = regList mAX_Vanilla_REG
-allFloatRegNos	 = regList mAX_Float_REG
-allDoubleRegNos	 = regList mAX_Double_REG
-allLongRegNos	 = regList mAX_Long_REG
+allFloatRegNos   = regList mAX_Float_REG
+allDoubleRegNos  = regList mAX_Double_REG
+allLongRegNos    = regList mAX_Long_REG
 
 regList :: Int -> [Int]
 regList n = [1 .. n]
 
 type AvailRegs = ( [Int]   -- available vanilla regs.
-		 , [Int]   -- floats
-		 , [Int]   -- doubles
-		 , [Int]   -- longs (int64 and word64)
-		 )
+                 , [Int]   -- floats
+                 , [Int]   -- doubles
+                 , [Int]   -- longs (int64 and word64)
+                 )
 
 mkRegTbl :: [GlobalReg] -> AvailRegs
 mkRegTbl regs_in_use
@@ -381,23 +374,23 @@ mkRegTbl' regs_in_use vanillas floats doubles longs
   = (ok_vanilla, ok_float, ok_double, ok_long)
   where
     ok_vanilla = mapCatMaybes (select (\i -> VanillaReg i VNonGcPtr)) vanillas
-		    -- ptrhood isn't looked at, hence we can use any old rep.
-    ok_float   = mapCatMaybes (select FloatReg)	  floats
+                    -- ptrhood isn't looked at, hence we can use any old rep.
+    ok_float   = mapCatMaybes (select FloatReg)   floats
     ok_double  = mapCatMaybes (select DoubleReg)  doubles
-    ok_long    = mapCatMaybes (select LongReg)    longs   
+    ok_long    = mapCatMaybes (select LongReg)    longs
 
     select :: (Int -> GlobalReg) -> Int{-cand-} -> Maybe Int
-	-- one we've unboxed the Int, we make a GlobalReg
-	-- and see if it is already in use; if not, return its number.
+        -- one we've unboxed the Int, we make a GlobalReg
+        -- and see if it is already in use; if not, return its number.
 
     select mk_reg_fun cand
       = let
-	    reg = mk_reg_fun cand
-	in
-	if reg `not_elem` regs_in_use
-	then Just cand
-	else Nothing
+            reg = mk_reg_fun cand
+        in
+        if reg `not_elem` regs_in_use
+        then Just cand
+        else Nothing
       where
-	not_elem = isn'tIn "mkRegTbl"
+        not_elem = isn'tIn "mkRegTbl"
 
 
diff --git a/compiler/codeGen/CgCase.lhs b/compiler/codeGen/CgCase.lhs
index a36621bdaf..dd607de1fc 100644
--- a/compiler/codeGen/CgCase.lhs
+++ b/compiler/codeGen/CgCase.lhs
@@ -4,20 +4,16 @@
 %
 
 \begin{code}
-{-# OPTIONS -fno-warn-tabs #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and
--- detab the module (please do the detabbing in a separate patch). See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
--- for details
 
-module CgCase (	cgCase, saveVolatileVarsAndRegs, 
-		restoreCurrentCostCentre
-	) where
+module CgCase (
+        cgCase,
+        saveVolatileVarsAndRegs,
+        restoreCurrentCostCentre
+    ) where
 
 #include "HsVersions.h"
 
-import {-# SOURCE #-} CgExpr  ( cgExpr )
+import {-# SOURCE #-} CgExpr ( cgExpr )
 
 import CgMonad
 import CgBindery
@@ -54,12 +50,12 @@ import Control.Monad (when)
 
 \begin{code}
 data GCFlag
-  = GCMayHappen	-- The scrutinee may involve GC, so everything must be
-		-- tidy before the code for the scrutinee.
+  = GCMayHappen -- The scrutinee may involve GC, so everything must be
+                -- tidy before the code for the scrutinee.
 
-  | NoGC	-- The scrutinee is a primitive value, or a call to a
-		-- primitive op which does no GC.  Hence the case can
-		-- be done inline, without tidying up first.
+  | NoGC        -- The scrutinee is a primitive value, or a call to a
+                -- primitive op which does no GC.  Hence the case can
+                -- be done inline, without tidying up first.
 \end{code}
 
 It is quite interesting to decide whether to put a heap-check
@@ -70,11 +66,11 @@ op which can trigger GC.
 A more interesting situation is this:
 
  \begin{verbatim}
-	!A!;
-	...A...
-	case x# of
-	  0#      -> !B!; ...B...
-	  default -> !C!; ...C...
+        !A!;
+        ...A...
+        case x# of
+          0#      -> !B!; ...B...
+          default -> !C!; ...C...
  \end{verbatim}
 
 where \tr{!x!} indicates a possible heap-check point. The heap checks
@@ -84,29 +80,29 @@ heapcheck will take their worst case into account.
 In favour of omitting \tr{!B!}, \tr{!C!}:
 
  - {\em May} save a heap overflow test,
-	if ...A... allocates anything.  The other advantage
-	of this is that we can use relative addressing
-	from a single Hp to get at all the closures so allocated.
+        if ...A... allocates anything.  The other advantage
+        of this is that we can use relative addressing
+        from a single Hp to get at all the closures so allocated.
 
  - No need to save volatile vars etc across the case
 
 Against:
 
   - May do more allocation than reqd.  This sometimes bites us
-	badly.  For example, nfib (ha!)  allocates about 30\% more space if the
-	worst-casing is done, because many many calls to nfib are leaf calls
-	which don't need to allocate anything.
+        badly.  For example, nfib (ha!)  allocates about 30\% more space if the
+        worst-casing is done, because many many calls to nfib are leaf calls
+        which don't need to allocate anything.
 
-	This never hurts us if there is only one alternative.
+        This never hurts us if there is only one alternative.
 
 \begin{code}
-cgCase	:: StgExpr
-	-> StgLiveVars
-	-> StgLiveVars
-	-> Id
-	-> AltType
-	-> [StgAlt]
-	-> Code
+cgCase  :: StgExpr
+        -> StgLiveVars
+        -> StgLiveVars
+        -> Id
+        -> AltType
+        -> [StgAlt]
+        -> Code
 \end{code}
 
 Special case #1: case of literal.
@@ -114,15 +110,15 @@ Special case #1: case of literal.
 \begin{code}
 cgCase (StgLit lit) _live_in_whole_case _live_in_alts bndr
        alt_type@(PrimAlt _) alts
-  = do	{ tmp_reg <- bindNewToTemp bndr
-	; cm_lit <- cgLit lit
-	; stmtC (CmmAssign (CmmLocal tmp_reg) (CmmLit cm_lit))
-	; cgPrimAlts NoGC alt_type (CmmLocal tmp_reg) alts }
+  = do  { tmp_reg <- bindNewToTemp bndr
+        ; cm_lit <- cgLit lit
+        ; stmtC (CmmAssign (CmmLocal tmp_reg) (CmmLit cm_lit))
+        ; cgPrimAlts NoGC alt_type (CmmLocal tmp_reg) alts }
 \end{code}
 
-Special case #2: scrutinising a primitive-typed variable.	No
+Special case #2: scrutinising a primitive-typed variable.       No
 evaluation required.  We don't save volatile variables, nor do we do a
-heap-check in the alternatives.	 Instead, the heap usage of the
+heap-check in the alternatives.  Instead, the heap usage of the
 alternatives is worst-cased and passed upstream.  This can result in
 allocating more heap than strictly necessary, but it will sometimes
 eliminate a heap check altogether.
@@ -159,15 +155,15 @@ cgCase (StgApp v []) _live_in_whole_case _live_in_alts bndr
             panic "cgCase: reps do not match, perhaps a dodgy unsafeCoerce?"
 
           -- Careful! we can't just bind the default binder to the same thing
-	  -- as the scrutinee, since it might be a stack location, and having
-	  -- two bindings pointing at the same stack locn doesn't work (it
-	  -- confuses nukeDeadBindings).  Hence, use a new temp.
-	; v_info <- getCgIdInfo v
-	; amode <- idInfoToAmode v_info
-	; tmp_reg <- bindNewToTemp bndr
-	; stmtC (CmmAssign (CmmLocal tmp_reg) amode)
-
-	; cgPrimAlts NoGC alt_type (CmmLocal tmp_reg) alts }
+          -- as the scrutinee, since it might be a stack location, and having
+          -- two bindings pointing at the same stack locn doesn't work (it
+          -- confuses nukeDeadBindings).  Hence, use a new temp.
+        ; v_info <- getCgIdInfo v
+        ; amode <- idInfoToAmode v_info
+        ; tmp_reg <- bindNewToTemp bndr
+        ; stmtC (CmmAssign (CmmLocal tmp_reg) amode)
+
+        ; cgPrimAlts NoGC alt_type (CmmLocal tmp_reg) alts }
   where
     reps_compatible = idCgRep v == idCgRep bndr
 \end{code}
@@ -194,7 +190,7 @@ cgCase (StgOpApp (StgPrimOp SeqOp) [StgVarArg a, _] _)
 Special case #3: inline PrimOps and foreign calls.
 
 \begin{code}
-cgCase (StgOpApp (StgPrimOp primop) args _) 
+cgCase (StgOpApp (StgPrimOp primop) args _)
        _live_in_whole_case live_in_alts bndr alt_type alts
   | not (primOpOutOfLine primop)
   = cgInlinePrimOp primop args bndr alt_type live_in_alts alts
@@ -209,23 +205,23 @@ Special case #4: inline foreign calls: an unsafe foreign call can be done
 right here, just like an inline primop.
 
 \begin{code}
-cgCase (StgOpApp (StgFCallOp fcall _) args _) 
+cgCase (StgOpApp (StgFCallOp fcall _) args _)
        _live_in_whole_case live_in_alts _bndr _alt_type alts
   | unsafe_foreign_call
   = ASSERT( isSingleton alts )
-    do	--  *must* be an unboxed tuple alt.
-	-- exactly like the cgInlinePrimOp case for unboxed tuple alts..
-	{ res_tmps <- mapFCs bindNewToTemp non_void_res_ids
-	; let res_hints = map (typeForeignHint.idType) non_void_res_ids
-	; cgForeignCall (zipWith CmmHinted res_tmps res_hints) fcall args live_in_alts
-	; cgExpr rhs }
+    do  --  *must* be an unboxed tuple alt.
+        -- exactly like the cgInlinePrimOp case for unboxed tuple alts..
+        { res_tmps <- mapFCs bindNewToTemp non_void_res_ids
+        ; let res_hints = map (typeForeignHint.idType) non_void_res_ids
+        ; cgForeignCall (zipWith CmmHinted res_tmps res_hints) fcall args live_in_alts
+        ; cgExpr rhs }
   where
    (_, res_ids, _, rhs) = head alts
    non_void_res_ids = filter (nonVoidArg . idCgRep) res_ids
 
    unsafe_foreign_call
-	 = case fcall of
-	 	CCall (CCallSpec _ _ s) -> not (playSafe s)
+         = case fcall of
+                CCall (CCallSpec _ _ s) -> not (playSafe s)
 \end{code}
 
 Special case: scrutinising a non-primitive variable.
@@ -234,28 +230,28 @@ we can reuse/trim the stack slot holding the variable (if it is in one).
 
 \begin{code}
 cgCase (StgApp fun args)
-	_live_in_whole_case live_in_alts bndr alt_type alts
-  = do	{ fun_info <- getCgIdInfo fun
-	; arg_amodes <- getArgAmodes args
-
-	-- Nuking dead bindings *before* calculating the saves is the
-	-- value-add here.  We might end up freeing up some slots currently
-	-- occupied by variables only required for the call.
-	-- NOTE: we need to look up the variables used in the call before
-	-- doing this, because some of them may not be in the environment
-	-- afterward.
-	; nukeDeadBindings live_in_alts	
-	; (save_assts, alts_eob_info, maybe_cc_slot)
-		<- saveVolatileVarsAndRegs live_in_alts
-
-	; scrut_eob_info
-	    <- forkEval alts_eob_info 
-			(allocStackTop retAddrSizeW >> nopC)
-			(do { deAllocStackTop retAddrSizeW
-			    ; cgEvalAlts maybe_cc_slot bndr alt_type alts })
-
-	; setEndOfBlockInfo scrut_eob_info
-			    (performTailCall fun_info arg_amodes save_assts) }
+        _live_in_whole_case live_in_alts bndr alt_type alts
+  = do  { fun_info <- getCgIdInfo fun
+        ; arg_amodes <- getArgAmodes args
+
+        -- Nuking dead bindings *before* calculating the saves is the
+        -- value-add here.  We might end up freeing up some slots currently
+        -- occupied by variables only required for the call.
+        -- NOTE: we need to look up the variables used in the call before
+        -- doing this, because some of them may not be in the environment
+        -- afterward.
+        ; nukeDeadBindings live_in_alts
+        ; (save_assts, alts_eob_info, maybe_cc_slot)
+            <- saveVolatileVarsAndRegs live_in_alts
+
+        ; scrut_eob_info
+            <- forkEval alts_eob_info
+                        (allocStackTop retAddrSizeW >> nopC)
+                        (do { deAllocStackTop retAddrSizeW
+                            ; cgEvalAlts maybe_cc_slot bndr alt_type alts })
+
+        ; setEndOfBlockInfo scrut_eob_info
+                            (performTailCall fun_info arg_amodes save_assts) }
 \end{code}
 
 Note about return addresses: we *always* push a return address, even
@@ -273,25 +269,25 @@ Finally, here is the general case.
 
 \begin{code}
 cgCase expr live_in_whole_case live_in_alts bndr alt_type alts
-  = do	{	-- Figure out what volatile variables to save
-	  nukeDeadBindings live_in_whole_case
-    
-	; (save_assts, alts_eob_info, maybe_cc_slot)
-		<- saveVolatileVarsAndRegs live_in_alts
-
-	     -- Save those variables right now!
-	; emitStmts save_assts
-
-	    -- generate code for the alts
-	; scrut_eob_info
-	       <- forkEval alts_eob_info
-		      	   (do 	{ nukeDeadBindings live_in_alts
-				; allocStackTop retAddrSizeW   -- space for retn address 
-				; nopC })
-			   (do	{ deAllocStackTop retAddrSizeW
-				; cgEvalAlts maybe_cc_slot bndr alt_type alts })
-
-	; setEndOfBlockInfo scrut_eob_info (cgExpr expr)
+  = do  {       -- Figure out what volatile variables to save
+          nukeDeadBindings live_in_whole_case
+
+        ; (save_assts, alts_eob_info, maybe_cc_slot)
+                <- saveVolatileVarsAndRegs live_in_alts
+
+             -- Save those variables right now!
+        ; emitStmts save_assts
+
+            -- generate code for the alts
+        ; scrut_eob_info
+               <- forkEval alts_eob_info
+                           (do  { nukeDeadBindings live_in_alts
+                                ; allocStackTop retAddrSizeW   -- space for retn address
+                                ; nopC })
+                           (do  { deAllocStackTop retAddrSizeW
+                                ; cgEvalAlts maybe_cc_slot bndr alt_type alts })
+
+        ; setEndOfBlockInfo scrut_eob_info (cgExpr expr)
     }
 \end{code}
 
@@ -300,15 +296,15 @@ stack pointer here.  forkEval takes the virtual Sp and free list from
 the first argument, and turns that into the *real* Sp for the second
 argument.  It also uses this virtual Sp as the args-Sp in the EOB info
 returned, so that the scrutinee will trim the real Sp back to the
-right place before doing whatever it does.  
-  --SDM (who just spent an hour figuring this out, and didn't want to 
-	 forget it).
+right place before doing whatever it does.
+  --SDM (who just spent an hour figuring this out, and didn't want to
+         forget it).
 
 Why don't we push the return address just before evaluating the
 scrutinee?  Because the slot reserved for the return address might
 contain something useful, so we wait until performing a tail call or
 return before pushing the return address (see
-CgTailCall.pushReturnAddress).  
+CgTailCall.pushReturnAddress).
 
 This also means that the environment doesn't need to know about the
 free stack slot for the return address (for generating bitmaps),
@@ -322,9 +318,9 @@ follow the layout of closures when we're profiling.  The CCS could be
 anywhere within the record).
 
 %************************************************************************
-%*									*
-		Inline primops
-%*									*
+%*                                                                      *
+                Inline primops
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -334,78 +330,78 @@ cgInlinePrimOp :: PrimOp -> [StgArg] -> Id -> AltType -> StgLiveVars
 cgInlinePrimOp primop args bndr (PrimAlt _) live_in_alts alts
   | isVoidArg (idCgRep bndr)
   = ASSERT( con == DEFAULT && isSingleton alts && null bs )
-    do	{ 	-- VOID RESULT; just sequencing, 
-		-- so get in there and do it
-		-- The bndr should not occur, so no need to bind it
-	  cgPrimOp [] primop args live_in_alts
-	; cgExpr rhs }
+    do  {       -- VOID RESULT; just sequencing,
+                -- so get in there and do it
+                -- The bndr should not occur, so no need to bind it
+          cgPrimOp [] primop args live_in_alts
+        ; cgExpr rhs }
   where
     (con,bs,_,rhs) = head alts
 
 cgInlinePrimOp primop args bndr (PrimAlt tycon) live_in_alts alts
-  = do	{ 	-- PRIMITIVE ALTS, with non-void result
-	  tmp_reg <- bindNewToTemp bndr
-	; cgPrimOp [tmp_reg] primop args live_in_alts
-	; cgPrimAlts NoGC (PrimAlt tycon) (CmmLocal tmp_reg) alts }
+  = do  {       -- PRIMITIVE ALTS, with non-void result
+          tmp_reg <- bindNewToTemp bndr
+        ; cgPrimOp [tmp_reg] primop args live_in_alts
+        ; cgPrimAlts NoGC (PrimAlt tycon) (CmmLocal tmp_reg) alts }
 
 cgInlinePrimOp primop args _ (UbxTupAlt _) live_in_alts alts
   = ASSERT( isSingleton alts )
-    do	{  	-- UNBOXED TUPLE ALTS
-	 	-- No heap check, no yield, just get in there and do it.
-		-- NB: the case binder isn't bound to anything; 
-		--     it has a unboxed tuple type
-	  
-	  res_tmps <- mapFCs bindNewToTemp non_void_res_ids
-	; cgPrimOp res_tmps primop args live_in_alts
-	; cgExpr rhs }
+    do  {       -- UNBOXED TUPLE ALTS
+                -- No heap check, no yield, just get in there and do it.
+                -- NB: the case binder isn't bound to anything;
+                --     it has a unboxed tuple type
+
+          res_tmps <- mapFCs bindNewToTemp non_void_res_ids
+        ; cgPrimOp res_tmps primop args live_in_alts
+        ; cgExpr rhs }
   where
    (_, res_ids, _, rhs) = head alts
    non_void_res_ids = filter (nonVoidArg . idCgRep) res_ids
 
 cgInlinePrimOp primop args bndr (AlgAlt tycon) live_in_alts alts
-  = do 	{ 	-- ENUMERATION TYPE RETURN
-		-- Typical: case a ># b of { True -> ..; False -> .. }
-		-- The primop itself returns an index into the table of
-		-- closures for the enumeration type.
-	   tag_amode <- ASSERT( isEnumerationTyCon tycon )
-			do_enum_primop primop
-
-	 	-- Bind the default binder if necessary
-		-- (avoiding it avoids the assignment)
-		-- The deadness info is set by StgVarInfo
-	; whenC (not (isDeadBinder bndr))
-		(do { tmp_reg <- bindNewToTemp bndr
-		    ; stmtC (CmmAssign
+  = do  {       -- ENUMERATION TYPE RETURN
+                -- Typical: case a ># b of { True -> ..; False -> .. }
+                -- The primop itself returns an index into the table of
+                -- closures for the enumeration type.
+           tag_amode <- ASSERT( isEnumerationTyCon tycon )
+                        do_enum_primop primop
+
+                -- Bind the default binder if necessary
+                -- (avoiding it avoids the assignment)
+                -- The deadness info is set by StgVarInfo
+        ; whenC (not (isDeadBinder bndr))
+                (do { tmp_reg <- bindNewToTemp bndr
+                    ; stmtC (CmmAssign
                              (CmmLocal tmp_reg)
                              (tagToClosure tycon tag_amode)) })
 
-		-- Compile the alts
-	; (branches, mb_deflt) <- cgAlgAlts NoGC Nothing{-cc_slot-}
-				   	    (AlgAlt tycon) alts
+                -- Compile the alts
+        ; (branches, mb_deflt) <- cgAlgAlts NoGC Nothing{-cc_slot-}
+                                            (AlgAlt tycon) alts
 
-		-- Do the switch
-	; emitSwitch tag_amode branches mb_deflt 0 (tyConFamilySize tycon - 1)
-	}
+                -- Do the switch
+        ; emitSwitch tag_amode branches mb_deflt 0 (tyConFamilySize tycon - 1)
+        }
   where
 
-    do_enum_primop :: PrimOp -> FCode CmmExpr	-- Returns amode for result
-    do_enum_primop TagToEnumOp	-- No code!
+    do_enum_primop :: PrimOp -> FCode CmmExpr   -- Returns amode for result
+    do_enum_primop TagToEnumOp  -- No code!
        | [arg] <- args = do
          (_,e) <- getArgAmode arg
-	 return e
+         return e
     do_enum_primop primop
       = do tmp <- newTemp bWord
-	   cgPrimOp [tmp] primop args live_in_alts
-    	   returnFC (CmmReg (CmmLocal tmp))
+           cgPrimOp [tmp] primop args live_in_alts
+           returnFC (CmmReg (CmmLocal tmp))
 
 cgInlinePrimOp _ _ bndr _ _ _
   = pprPanic "cgCase: case of primop has polymorphic type" (ppr bndr)
 \end{code}
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[CgCase-alts]{Alternatives}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 @cgEvalAlts@ returns an addressing mode for a continuation for the
@@ -413,77 +409,77 @@ alternatives of a @case@, used in a context when there
 is some evaluation to be done.
 
 \begin{code}
-cgEvalAlts :: Maybe VirtualSpOffset	-- Offset of cost-centre to be restored, if any
-	   -> Id
-	   -> AltType
-	   -> [StgAlt]
-	   -> FCode Sequel	-- Any addr modes inside are guaranteed
-				-- to be a label so that we can duplicate it 
-				-- without risk of duplicating code
+cgEvalAlts :: Maybe VirtualSpOffset     -- Offset of cost-centre to be restored, if any
+           -> Id
+           -> AltType
+           -> [StgAlt]
+           -> FCode Sequel      -- Any addr modes inside are guaranteed
+                                -- to be a label so that we can duplicate it
+                                -- without risk of duplicating code
 
 cgEvalAlts cc_slot bndr alt_type@(PrimAlt tycon) alts
-  = do	{ let   rep = tyConCgRep tycon
-		reg = dataReturnConvPrim rep	-- Bottom for voidRep
+  = do  { let   rep = tyConCgRep tycon
+                reg = dataReturnConvPrim rep    -- Bottom for voidRep
 
-	; abs_c <- forkProc $ do
-		{ 	-- Bind the case binder, except if it's void
-			-- (reg is bottom in that case)
-		  whenC (nonVoidArg rep) $
-		  bindNewToReg bndr reg (mkLFArgument bndr)
-		; restoreCurrentCostCentre cc_slot True
-		; cgPrimAlts GCMayHappen alt_type reg alts }
+        ; abs_c <- forkProc $ do
+                {       -- Bind the case binder, except if it's void
+                        -- (reg is bottom in that case)
+                  whenC (nonVoidArg rep) $
+                  bindNewToReg bndr reg (mkLFArgument bndr)
+                ; restoreCurrentCostCentre cc_slot True
+                ; cgPrimAlts GCMayHappen alt_type reg alts }
 
-	; lbl <- emitReturnTarget (idName bndr) abs_c
-	; returnFC (CaseAlts lbl Nothing bndr) }
+        ; lbl <- emitReturnTarget (idName bndr) abs_c
+        ; returnFC (CaseAlts lbl Nothing bndr) }
 
 cgEvalAlts cc_slot bndr (UbxTupAlt _) [(con,args,_,rhs)]
-  =	-- Unboxed tuple case
-	-- By now, the simplifier should have have turned it
-	-- into 	case e of (# a,b #) -> e
-	-- There shouldn't be a 
-	--		case e of DEFAULT -> e
+  =     -- Unboxed tuple case
+        -- By now, the simplifier should have have turned it
+        -- into         case e of (# a,b #) -> e
+        -- There shouldn't be a
+        --              case e of DEFAULT -> e
     ASSERT2( case con of { DataAlt _ -> True; _ -> False },
-	     text "cgEvalAlts: dodgy case of unboxed tuple type" )
-    do	{ 	-- forkAbsC for the RHS, so that the envt is
-		-- not changed for the emitReturn call
-	  abs_c <- forkProc $ do 
-		{ (live_regs, ptrs, nptrs, _) <- bindUnboxedTupleComponents args
-			-- Restore the CC *after* binding the tuple components, 
-			-- so that we get the stack offset of the saved CC right.
-		; restoreCurrentCostCentre cc_slot True
-			-- Generate a heap check if necessary
-			-- and finally the code for the alternative
-		; unbxTupleHeapCheck live_regs ptrs nptrs noStmts
-				     (cgExpr rhs) }
-	; lbl <- emitReturnTarget (idName bndr) abs_c
-	; returnFC (CaseAlts lbl Nothing bndr) }
+             text "cgEvalAlts: dodgy case of unboxed tuple type" )
+    do  {       -- forkAbsC for the RHS, so that the envt is
+                -- not changed for the emitReturn call
+          abs_c <- forkProc $ do
+                { (live_regs, ptrs, nptrs, _) <- bindUnboxedTupleComponents args
+                        -- Restore the CC *after* binding the tuple components,
+                        -- so that we get the stack offset of the saved CC right.
+                ; restoreCurrentCostCentre cc_slot True
+                        -- Generate a heap check if necessary
+                        -- and finally the code for the alternative
+                ; unbxTupleHeapCheck live_regs ptrs nptrs noStmts
+                                     (cgExpr rhs) }
+        ; lbl <- emitReturnTarget (idName bndr) abs_c
+        ; returnFC (CaseAlts lbl Nothing bndr) }
 
 cgEvalAlts cc_slot bndr alt_type alts
-  = 	-- Algebraic and polymorphic case
-    do	{	-- Bind the default binder
-	  bindNewToReg bndr nodeReg (mkLFArgument bndr)
+  =     -- Algebraic and polymorphic case
+    do  {       -- Bind the default binder
+          bindNewToReg bndr nodeReg (mkLFArgument bndr)
 
-	-- Generate sequel info for use downstream
-	-- At the moment, we only do it if the type is vector-returnable.
-	-- Reason: if not, then it costs extra to label the
-	-- alternatives, because we'd get return code like:
-	--
-	--	switch TagReg { 0 : JMP(alt_1); 1 : JMP(alt_2) ..etc }
-	--
-	-- which is worse than having the alt code in the switch statement
+        -- Generate sequel info for use downstream
+        -- At the moment, we only do it if the type is vector-returnable.
+        -- Reason: if not, then it costs extra to label the
+        -- alternatives, because we'd get return code like:
+        --
+        --      switch TagReg { 0 : JMP(alt_1); 1 : JMP(alt_2) ..etc }
+        --
+        -- which is worse than having the alt code in the switch statement
 
-	; (alts, mb_deflt) <- cgAlgAlts GCMayHappen cc_slot alt_type alts
+        ; (alts, mb_deflt) <- cgAlgAlts GCMayHappen cc_slot alt_type alts
 
-	; (lbl, branches) <- emitAlgReturnTarget (idName bndr) 
-				alts mb_deflt fam_sz
+        ; (lbl, branches) <- emitAlgReturnTarget (idName bndr)
+                                alts mb_deflt fam_sz
 
-	; returnFC (CaseAlts lbl branches bndr) }
+        ; returnFC (CaseAlts lbl branches bndr) }
   where
     fam_sz = case alt_type of
-    		AlgAlt tc -> tyConFamilySize tc
-    		PolyAlt   -> 0
-    		PrimAlt _ -> panic "cgEvalAlts: PrimAlt"
-    		UbxTupAlt _ -> panic "cgEvalAlts: UbxTupAlt"
+                AlgAlt tc -> tyConFamilySize tc
+                PolyAlt   -> 0
+                PrimAlt _ -> panic "cgEvalAlts: PrimAlt"
+                UbxTupAlt _ -> panic "cgEvalAlts: UbxTupAlt"
 \end{code}
 
 
@@ -494,9 +490,9 @@ must be  propagated  to cgAlgAltRhs (where the  GRAN_YIELD  macro might  be
 emitted). Hence, the new Bool arg to cgAlgAltRhs.
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[CgCase-alg-alts]{Algebraic alternatives}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 In @cgAlgAlts@, none of the binders in the alternatives are
@@ -510,36 +506,36 @@ are inlined alternatives.
 \begin{code}
 cgAlgAlts :: GCFlag
        -> Maybe VirtualSpOffset
-       -> AltType				--  ** AlgAlt or PolyAlt only **
-       -> [StgAlt]				-- The alternatives
+       -> AltType                               --  ** AlgAlt or PolyAlt only **
+       -> [StgAlt]                              -- The alternatives
        -> FCode ( [(ConTagZ, CgStmts)], -- The branches
-		  Maybe CgStmts )	-- The default case
+                  Maybe CgStmts )       -- The default case
 
 cgAlgAlts gc_flag cc_slot alt_type alts
   = do alts <- forkAlts [ cgAlgAlt gc_flag cc_slot alt_type alt | alt <- alts]
        let
-	    mb_deflt = case alts of -- DEFAULT is always first, if present
-			 ((DEFAULT,blks) : _) -> Just blks
-			 _    		      -> Nothing
+            mb_deflt = case alts of -- DEFAULT is always first, if present
+                         ((DEFAULT,blks) : _) -> Just blks
+                         _                    -> Nothing
 
-	    branches = [(dataConTagZ con, blks) 
-	   	       | (DataAlt con, blks) <- alts]
+            branches = [(dataConTagZ con, blks)
+                       | (DataAlt con, blks) <- alts]
        -- in
        return (branches, mb_deflt)
 
 
 cgAlgAlt :: GCFlag
-      	 -> Maybe VirtualSpOffset	-- Turgid state
-      	 -> AltType			--  ** AlgAlt or PolyAlt only **
-      	 -> StgAlt
-      	 -> FCode (AltCon, CgStmts)
+         -> Maybe VirtualSpOffset       -- Turgid state
+         -> AltType                     --  ** AlgAlt or PolyAlt only **
+         -> StgAlt
+         -> FCode (AltCon, CgStmts)
 
 cgAlgAlt gc_flag cc_slot alt_type (con, args, _use_mask, rhs)
-  = do	{ abs_c <- getCgStmts $ do
-		{ bind_con_args con args
-		; restoreCurrentCostCentre cc_slot True
-		; maybeAltHeapCheck gc_flag alt_type (cgExpr rhs) }
-	; return (con, abs_c) }
+  = do  { abs_c <- getCgStmts $ do
+                { bind_con_args con args
+                ; restoreCurrentCostCentre cc_slot True
+                ; maybeAltHeapCheck gc_flag alt_type (cgExpr rhs) }
+        ; return (con, abs_c) }
   where
     bind_con_args DEFAULT      _    = nopC
     bind_con_args (DataAlt dc) args = bindConArgs dc args
@@ -548,9 +544,9 @@ cgAlgAlt gc_flag cc_slot alt_type (con, args, _use_mask, rhs)
 
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[CgCase-prim-alts]{Primitive alternatives}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 @cgPrimAlts@ generates suitable a @CSwitch@
@@ -562,10 +558,10 @@ As usual, no binders in the alternatives are yet bound.
 
 \begin{code}
 cgPrimAlts :: GCFlag
-	   -> AltType	-- Always PrimAlt, but passed to maybeAltHeapCheck
-	   -> CmmReg	-- Scrutinee
-	   -> [StgAlt]	-- Alternatives
-	   -> Code
+           -> AltType   -- Always PrimAlt, but passed to maybeAltHeapCheck
+           -> CmmReg    -- Scrutinee
+           -> [StgAlt]  -- Alternatives
+           -> Code
 -- NB: cgPrimAlts emits code that does the case analysis.
 -- It's often used in inline situations, rather than to genearte
 -- a labelled return point.  That's why its interface is a little
@@ -573,73 +569,73 @@ cgPrimAlts :: GCFlag
 --
 -- INVARIANT: the default binder is already bound
 cgPrimAlts gc_flag alt_type scrutinee alts
-  = do	{ tagged_absCs <- forkAlts (map (cgPrimAlt gc_flag alt_type) alts)
-	; let ((DEFAULT, deflt_absC) : others) = tagged_absCs	-- There is always a default
-	      alt_absCs = [(lit,rhs) | (LitAlt lit, rhs) <- others]
- 	; emitLitSwitch (CmmReg scrutinee) alt_absCs deflt_absC }
+  = do  { tagged_absCs <- forkAlts (map (cgPrimAlt gc_flag alt_type) alts)
+        ; let ((DEFAULT, deflt_absC) : others) = tagged_absCs   -- There is always a default
+              alt_absCs = [(lit,rhs) | (LitAlt lit, rhs) <- others]
+        ; emitLitSwitch (CmmReg scrutinee) alt_absCs deflt_absC }
 
 cgPrimAlt :: GCFlag
-	  -> AltType
-	  -> StgAlt				-- The alternative
-	  -> FCode (AltCon, CgStmts)	-- Its compiled form
+          -> AltType
+          -> StgAlt                             -- The alternative
+          -> FCode (AltCon, CgStmts)    -- Its compiled form
 
 cgPrimAlt gc_flag alt_type (con, [], [], rhs)
   = ASSERT( case con of { DEFAULT -> True; LitAlt _ -> True; _ -> False } )
-    do	{ abs_c <- getCgStmts (maybeAltHeapCheck gc_flag alt_type (cgExpr rhs)) 
-	; returnFC (con, abs_c) }
+    do  { abs_c <- getCgStmts (maybeAltHeapCheck gc_flag alt_type (cgExpr rhs))
+        ; returnFC (con, abs_c) }
 cgPrimAlt _ _ _ = panic "cgPrimAlt: non-empty lists"
 \end{code}
 
 
 %************************************************************************
-%*									*
+%*                                                                      *
 \subsection[CgCase-tidy]{Code for tidying up prior to an eval}
-%*									*
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
-maybeAltHeapCheck 
-	:: GCFlag 
-	-> AltType	-- PolyAlt, PrimAlt, AlgAlt, but *not* UbxTupAlt
-	-> Code		-- Continuation
-	-> Code
-maybeAltHeapCheck NoGC	      _        code = code
+maybeAltHeapCheck
+        :: GCFlag
+        -> AltType      -- PolyAlt, PrimAlt, AlgAlt, but *not* UbxTupAlt
+        -> Code         -- Continuation
+        -> Code
+maybeAltHeapCheck NoGC        _        code = code
 maybeAltHeapCheck GCMayHappen alt_type code = altHeapCheck alt_type code
 
 saveVolatileVarsAndRegs
     :: StgLiveVars                    -- Vars which should be made safe
-    -> FCode (CmmStmts,  	      -- Assignments to do the saves
-	      EndOfBlockInfo,	      -- sequel for the alts
+    -> FCode (CmmStmts,               -- Assignments to do the saves
+              EndOfBlockInfo,         -- sequel for the alts
               Maybe VirtualSpOffset)  -- Slot for current cost centre
 
 saveVolatileVarsAndRegs vars
-  = do	{ var_saves <- saveVolatileVars vars
-	; (maybe_cc_slot, cc_save) <- saveCurrentCostCentre
-	; eob_info <- getEndOfBlockInfo
-	; returnFC (var_saves `plusStmts` cc_save,
-		    eob_info,
-		    maybe_cc_slot) }
+  = do  { var_saves <- saveVolatileVars vars
+        ; (maybe_cc_slot, cc_save) <- saveCurrentCostCentre
+        ; eob_info <- getEndOfBlockInfo
+        ; returnFC (var_saves `plusStmts` cc_save,
+                    eob_info,
+                    maybe_cc_slot) }
 
 
-saveVolatileVars :: StgLiveVars		-- Vars which should be made safe
-		 -> FCode CmmStmts	-- Assignments to to the saves
+saveVolatileVars :: StgLiveVars         -- Vars which should be made safe
+                 -> FCode CmmStmts      -- Assignments to to the saves
 
 saveVolatileVars vars
-  = do	{ stmts_s <- mapFCs save_it (varSetElems vars)
-	; return (foldr plusStmts noStmts stmts_s) }
+  = do  { stmts_s <- mapFCs save_it (varSetElems vars)
+        ; return (foldr plusStmts noStmts stmts_s) }
   where
     save_it var
       = do { v <- getCAddrModeIfVolatile var
-	   ; case v of
-		Nothing	        -> return noStmts 	   -- Non-volatile
-		Just vol_amode  -> save_var var vol_amode  -- Aha! It's volatile
-	}
+           ; case v of
+                Nothing         -> return noStmts          -- Non-volatile
+                Just vol_amode  -> save_var var vol_amode  -- Aha! It's volatile
+        }
 
     save_var var vol_amode
       = do { slot <- allocPrimStack (idCgRep var)
-	   ; rebindToStack var slot
-	   ; sp_rel <- getSpRelOffset slot
-	   ; returnFC (oneStmt (CmmStore sp_rel vol_amode)) }
+           ; rebindToStack var slot
+           ; sp_rel <- getSpRelOffset slot
+           ; returnFC (oneStmt (CmmStore sp_rel vol_amode)) }
 \end{code}
 
 ---------------------------------------------------------------------------
@@ -651,25 +647,25 @@ virtual offset of the location, to pass on to the alternatives, and
 
 \begin{code}
 saveCurrentCostCentre ::
-	FCode (Maybe VirtualSpOffset,	-- Where we decide to store it
-	       CmmStmts)		-- Assignment to save it
+        FCode (Maybe VirtualSpOffset,   -- Where we decide to store it
+               CmmStmts)                -- Assignment to save it
 
 saveCurrentCostCentre
-  | not opt_SccProfilingOn 
+  | not opt_SccProfilingOn
   = returnFC (Nothing, noStmts)
   | otherwise
-  = do	{ slot <- allocPrimStack PtrArg
-	; sp_rel <- getSpRelOffset slot
-	; returnFC (Just slot,
-		    oneStmt (CmmStore sp_rel curCCS)) }
+  = do  { slot <- allocPrimStack PtrArg
+        ; sp_rel <- getSpRelOffset slot
+        ; returnFC (Just slot,
+                    oneStmt (CmmStore sp_rel curCCS)) }
 
 -- Sometimes we don't free the slot containing the cost centre after restoring it
 -- (see CgLetNoEscape.cgLetNoEscapeBody).
 restoreCurrentCostCentre :: Maybe VirtualSpOffset -> Bool -> Code
 restoreCurrentCostCentre Nothing     _freeit = nopC
 restoreCurrentCostCentre (Just slot) freeit
- = do 	{ sp_rel <- getSpRelOffset slot
-	; whenC freeit (freeStackSlots [slot])
+ = do   { sp_rel <- getSpRelOffset slot
+        ; whenC freeit (freeStackSlots [slot])
         ; stmtC (storeCurCCS (CmmLoad sp_rel bWord)) }
 \end{code}
 
diff --git a/compiler/codeGen/CgForeignCall.hs b/compiler/codeGen/CgForeignCall.hs
index bdc9e50c11..09636bc6b2 100644
--- a/compiler/codeGen/CgForeignCall.hs
+++ b/compiler/codeGen/CgForeignCall.hs
@@ -7,15 +7,15 @@
 -----------------------------------------------------------------------------
 
 module CgForeignCall (
-  cgForeignCall,
-  emitForeignCall,
-  emitForeignCall',
-  shimForeignCallArg,
-  emitSaveThreadState, -- will be needed by the Cmm parser
-  emitLoadThreadState, -- ditto
-  emitCloseNursery,
-  emitOpenNursery,
- ) where
+        cgForeignCall,
+        emitForeignCall,
+        emitForeignCall',
+        shimForeignCallArg,
+        emitSaveThreadState, -- will be needed by the Cmm parser
+        emitLoadThreadState, -- ditto
+        emitCloseNursery,
+        emitOpenNursery,
+    ) where
 
 import StgSyn
 import CgProf
diff --git a/compiler/codeGen/CgPrimOp.hs b/compiler/codeGen/CgPrimOp.hs
index 3b11054efe..b0865d69d9 100644
--- a/compiler/codeGen/CgPrimOp.hs
+++ b/compiler/codeGen/CgPrimOp.hs
@@ -6,16 +6,9 @@
 --
 -----------------------------------------------------------------------------
 
-{-# OPTIONS -fno-warn-tabs #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and
--- detab the module (please do the detabbing in a separate patch). See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
--- for details
-
 module CgPrimOp (
-   cgPrimOp
- ) where
+        cgPrimOp
+    ) where
 
 import BasicTypes
 import ForeignCall
@@ -43,44 +36,44 @@ import StaticFlags
 -- ---------------------------------------------------------------------------
 -- Code generation for PrimOps
 
-cgPrimOp   :: [CmmFormal]	-- where to put the results
-	   -> PrimOp		-- the op
-	   -> [StgArg]		-- arguments
-	   -> StgLiveVars	-- live vars, in case we need to save them
-	   -> Code
+cgPrimOp :: [CmmFormal]       -- where to put the results
+         -> PrimOp            -- the op
+         -> [StgArg]          -- arguments
+         -> StgLiveVars       -- live vars, in case we need to save them
+         -> Code
 
 cgPrimOp results op args live
   = do arg_exprs <- getArgAmodes args
-       let non_void_args = [ e | (r,e) <- arg_exprs, nonVoidArg r ] 
+       let non_void_args = [ e | (r,e) <- arg_exprs, nonVoidArg r ]
        emitPrimOp results op non_void_args live
 
 
-emitPrimOp :: [CmmFormal]	-- where to put the results
-	   -> PrimOp		-- the op
-	   -> [CmmExpr]		-- arguments
-	   -> StgLiveVars	-- live vars, in case we need to save them
-	   -> Code
+emitPrimOp :: [CmmFormal]       -- where to put the results
+           -> PrimOp            -- the op
+           -> [CmmExpr]         -- arguments
+           -> StgLiveVars       -- live vars, in case we need to save them
+           -> Code
 
 --  First we handle various awkward cases specially.  The remaining
 -- easy cases are then handled by translateOp, defined below.
 
 emitPrimOp [res_r,res_c] IntAddCOp [aa,bb] _
-{- 
+{-
    With some bit-twiddling, we can define int{Add,Sub}Czh portably in
    C, and without needing any comparisons.  This may not be the
    fastest way to do it - if you have better code, please send it! --SDM
-  
+
    Return : r = a + b,  c = 0 if no overflow, 1 on overflow.
-  
-   We currently don't make use of the r value if c is != 0 (i.e. 
+
+   We currently don't make use of the r value if c is != 0 (i.e.
    overflow), we just convert to big integers and try again.  This
    could be improved by making r and c the correct values for
-   plugging into a new J#.  
-   
-   { r = ((I_)(a)) + ((I_)(b));					\
-     c = ((StgWord)(~(((I_)(a))^((I_)(b))) & (((I_)(a))^r)))	\
-         >> (BITS_IN (I_) - 1);					\
-   } 
+   plugging into a new J#.
+
+   { r = ((I_)(a)) + ((I_)(b));                                 \
+     c = ((StgWord)(~(((I_)(a))^((I_)(b))) & (((I_)(a))^r)))    \
+         >> (BITS_IN (I_) - 1);                                 \
+   }
    Wading through the mass of bracketry, it seems to reduce to:
    c = ( (~(a^b)) & (a^r) ) >>unsigned (BITS_IN(I_)-1)
 
@@ -88,22 +81,22 @@ emitPrimOp [res_r,res_c] IntAddCOp [aa,bb] _
    = stmtsC [
         CmmAssign (CmmLocal res_r) (CmmMachOp mo_wordAdd [aa,bb]),
         CmmAssign (CmmLocal res_c) $
-	  CmmMachOp mo_wordUShr [
-		CmmMachOp mo_wordAnd [
-		    CmmMachOp mo_wordNot [CmmMachOp mo_wordXor [aa,bb]],
-		    CmmMachOp mo_wordXor [aa, CmmReg (CmmLocal res_r)]
-		], 
-	        CmmLit (mkIntCLit (wORD_SIZE_IN_BITS - 1))
-	  ]
+          CmmMachOp mo_wordUShr [
+                CmmMachOp mo_wordAnd [
+                    CmmMachOp mo_wordNot [CmmMachOp mo_wordXor [aa,bb]],
+                    CmmMachOp mo_wordXor [aa, CmmReg (CmmLocal res_r)]
+                ],
+                CmmLit (mkIntCLit (wORD_SIZE_IN_BITS - 1))
+          ]
      ]
 
 
 emitPrimOp [res_r,res_c] IntSubCOp [aa,bb] _
 {- Similarly:
-   #define subIntCzh(r,c,a,b)					\
-   { r = ((I_)(a)) - ((I_)(b));					\
-     c = ((StgWord)((((I_)(a))^((I_)(b))) & (((I_)(a))^r)))	\
-         >> (BITS_IN (I_) - 1);					\
+   #define subIntCzh(r,c,a,b)                                   \
+   { r = ((I_)(a)) - ((I_)(b));                                 \
+     c = ((StgWord)((((I_)(a))^((I_)(b))) & (((I_)(a))^r)))     \
+         >> (BITS_IN (I_) - 1);                                 \
    }
 
    c =  ((a^b) & (a^r)) >>unsigned (BITS_IN(I_)-1)
@@ -111,27 +104,27 @@ emitPrimOp [res_r,res_c] IntSubCOp [aa,bb] _
    = stmtsC [
         CmmAssign (CmmLocal res_r) (CmmMachOp mo_wordSub [aa,bb]),
         CmmAssign (CmmLocal res_c) $
-	  CmmMachOp mo_wordUShr [
-		CmmMachOp mo_wordAnd [
-		    CmmMachOp mo_wordXor [aa,bb],
-		    CmmMachOp mo_wordXor [aa, CmmReg (CmmLocal res_r)]
-		], 
-	        CmmLit (mkIntCLit (wORD_SIZE_IN_BITS - 1))
-	  ]
+          CmmMachOp mo_wordUShr [
+                CmmMachOp mo_wordAnd [
+                    CmmMachOp mo_wordXor [aa,bb],
+                    CmmMachOp mo_wordXor [aa, CmmReg (CmmLocal res_r)]
+                ],
+                CmmLit (mkIntCLit (wORD_SIZE_IN_BITS - 1))
+          ]
      ]
 
 
 emitPrimOp [res] ParOp [arg] live
   = do
-	-- for now, just implement this in a C function
-	-- later, we might want to inline it.
+        -- for now, just implement this in a C function
+        -- later, we might want to inline it.
     vols <- getVolatileRegs live
     emitForeignCall' PlayRisky
-	[CmmHinted res NoHint]
-    	(CmmCallee newspark CCallConv) 
-	[   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
-          , (CmmHinted arg AddrHint)  ] 
-	(Just vols)
+        [CmmHinted res NoHint]
+        (CmmCallee newspark CCallConv)
+        [   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
+          , (CmmHinted arg AddrHint)  ]
+        (Just vols)
         NoC_SRT -- No SRT b/c we do PlayRisky
         CmmMayReturn
   where
@@ -148,15 +141,15 @@ emitPrimOp [res] SparkOp [arg] live = do
     res' <- newTemp bWord
     emitForeignCall' PlayRisky
         [CmmHinted res' NoHint]
-    	(CmmCallee newspark CCallConv) 
-	[   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
-          , (CmmHinted arg AddrHint)  ] 
-	(Just vols)
+        (CmmCallee newspark CCallConv)
+        [   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
+          , (CmmHinted arg AddrHint)  ]
+        (Just vols)
         NoC_SRT -- No SRT b/c we do PlayRisky
         CmmMayReturn
     stmtC (CmmAssign (CmmLocal res) (CmmReg (CmmLocal tmp)))
   where
-	newspark = CmmLit (CmmLabel (mkCmmCodeLabel rtsPackageId (fsLit "newSpark")))
+        newspark = CmmLit (CmmLabel (mkCmmCodeLabel rtsPackageId (fsLit "newSpark")))
 
 emitPrimOp [res] GetCCSOfOp [arg] _live
   = stmtC (CmmAssign (CmmLocal res) val)
@@ -172,15 +165,15 @@ emitPrimOp [res] ReadMutVarOp [mutv] _
 
 emitPrimOp [] WriteMutVarOp [mutv,var] live
    = do
-	stmtC (CmmStore (cmmOffsetW mutv fixedHdrSize) var)
-	vols <- getVolatileRegs live
-	emitForeignCall' PlayRisky
-		[{-no results-}]
-		(CmmCallee (CmmLit (CmmLabel mkDirty_MUT_VAR_Label))
-			 CCallConv)
-		[   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
+        stmtC (CmmStore (cmmOffsetW mutv fixedHdrSize) var)
+        vols <- getVolatileRegs live
+        emitForeignCall' PlayRisky
+                [{-no results-}]
+                (CmmCallee (CmmLit (CmmLabel mkDirty_MUT_VAR_Label))
+                         CCallConv)
+                [   (CmmHinted (CmmReg (CmmGlobal BaseReg)) AddrHint)
                   , (CmmHinted mutv AddrHint)  ]
-		(Just vols)
+                (Just vols)
                 NoC_SRT -- No SRT b/c we do PlayRisky
                 CmmMayReturn
 
@@ -188,7 +181,7 @@ emitPrimOp [] WriteMutVarOp [mutv,var] live
 --     r = ((StgArrWords *)(a))->bytes
 emitPrimOp [res] SizeofByteArrayOp [arg] _
    = stmtC $
-	CmmAssign (CmmLocal res) (cmmLoadIndexW arg fixedHdrSize bWord)
+        CmmAssign (CmmLocal res) (cmmLoadIndexW arg fixedHdrSize bWord)
 
 --  #define sizzeofMutableByteArrayzh(r,a) \
 --      r = ((StgArrWords *)(a))->bytes
@@ -208,13 +201,13 @@ emitPrimOp [res] ByteArrayContents_Char [arg] _
 emitPrimOp [res] StableNameToIntOp [arg] _
    = stmtC (CmmAssign (CmmLocal res) (cmmLoadIndexW arg fixedHdrSize bWord))
 
---  #define eqStableNamezh(r,sn1,sn2)					\
+--  #define eqStableNamezh(r,sn1,sn2)                                   \
 --    (r = (((StgStableName *)sn1)->sn == ((StgStableName *)sn2)->sn))
 emitPrimOp [res] EqStableNameOp [arg1,arg2] _
    = stmtC (CmmAssign (CmmLocal res) (CmmMachOp mo_wordEq [
-				cmmLoadIndexW arg1 fixedHdrSize bWord,
-				cmmLoadIndexW arg2 fixedHdrSize bWord
-			 ]))
+                                cmmLoadIndexW arg1 fixedHdrSize bWord,
+                                cmmLoadIndexW arg2 fixedHdrSize bWord
+                         ]))
 
 
 emitPrimOp [res] ReallyUnsafePtrEqualityOp [arg1,arg2] _
@@ -232,13 +225,13 @@ emitPrimOp [res] DataToTagOp [arg] _
 {- Freezing arrays-of-ptrs requires changing an info table, for the
    benefit of the generational collector.  It needs to scavenge mutable
    objects, even if they are in old space.  When they become immutable,
-   they can be removed from this scavenge list.	 -}
+   they can be removed from this scavenge list.  -}
 
 --  #define unsafeFreezzeArrayzh(r,a)
---	{
+--      {
 --        SET_INFO((StgClosure *)a,&stg_MUT_ARR_PTRS_FROZEN0_info);
---	  r = a;
---	}
+--        r = a;
+--      }
 emitPrimOp [res] UnsafeFreezeArrayOp [arg] _
    = stmtsC [ setInfo arg (CmmLit (CmmLabel mkMAP_FROZEN_infoLabel)),
        CmmAssign (CmmLocal res) arg ]
@@ -246,7 +239,7 @@ emitPrimOp [res] UnsafeFreezeArrayArrayOp [arg] _
    = stmtsC [ setInfo arg (CmmLit (CmmLabel mkMAP_FROZEN_infoLabel)),
        CmmAssign (CmmLocal res) arg ]
 
---  #define unsafeFreezzeByteArrayzh(r,a)	r=(a)
+--  #define unsafeFreezzeByteArrayzh(r,a)       r=(a)
 emitPrimOp [res] UnsafeFreezeByteArrayOp [arg] _
    = stmtC (CmmAssign (CmmLocal res) arg)
 
@@ -286,7 +279,7 @@ emitPrimOp []  WriteArrayArrayOp_ArrayArray        [obj,ix,v] _  = doWritePtrArr
 emitPrimOp []  WriteArrayArrayOp_MutableArrayArray [obj,ix,v] _  = doWritePtrArrayOp obj ix v
 
 emitPrimOp [res] SizeofArrayOp [arg] _
-   = stmtC $ 
+   = stmtC $
        CmmAssign (CmmLocal res) (cmmLoadIndexW arg (fixedHdrSize + oFFSET_StgMutArrPtrs_ptrs) bWord)
 emitPrimOp [res] SizeofMutableArrayOp [arg] live
    = emitPrimOp [res] SizeofArrayOp [arg] live
@@ -430,16 +423,16 @@ emitPrimOp [res] op [arg] _
 
    | Just (mop,rep) <- narrowOp op
    = stmtC (CmmAssign (CmmLocal res) $
-	    CmmMachOp (mop rep wordWidth) [CmmMachOp (mop wordWidth rep) [arg]])
+            CmmMachOp (mop rep wordWidth) [CmmMachOp (mop wordWidth rep) [arg]])
 
 emitPrimOp [res] op args live
    | Just prim <- callishOp op
    = do vols <- getVolatileRegs live
-	emitForeignCall' PlayRisky
-	   [CmmHinted res NoHint] 
-	   (CmmPrim prim) 
-	   [CmmHinted a NoHint | a<-args]  -- ToDo: hints?
-	   (Just vols)
+        emitForeignCall' PlayRisky
+           [CmmHinted res NoHint]
+           (CmmPrim prim)
+           [CmmHinted a NoHint | a<-args]  -- ToDo: hints?
+           (Just vols)
            NoC_SRT -- No SRT b/c we do PlayRisky
            CmmMayReturn
 
@@ -458,9 +451,9 @@ nopOp Int2WordOp     = True
 nopOp Word2IntOp     = True
 nopOp Int2AddrOp     = True
 nopOp Addr2IntOp     = True
-nopOp ChrOp	     = True  -- Int# and Char# are rep'd the same
-nopOp OrdOp	     = True
-nopOp _		     = False
+nopOp ChrOp          = True  -- Int# and Char# are rep'd the same
+nopOp OrdOp          = True
+nopOp _              = False
 
 -- These PrimOps turn into double casts
 
@@ -471,7 +464,7 @@ narrowOp Narrow32IntOp  = Just (MO_SS_Conv, W32)
 narrowOp Narrow8WordOp  = Just (MO_UU_Conv, W8)
 narrowOp Narrow16WordOp = Just (MO_UU_Conv, W16)
 narrowOp Narrow32WordOp = Just (MO_UU_Conv, W32)
-narrowOp _ 		= Nothing
+narrowOp _              = Nothing
 
 -- Native word signless ops
 
@@ -494,10 +487,10 @@ translateOp AndOp          = Just mo_wordAnd
 translateOp OrOp           = Just mo_wordOr
 translateOp XorOp          = Just mo_wordXor
 translateOp NotOp          = Just mo_wordNot
-translateOp SllOp	   = Just mo_wordShl
-translateOp SrlOp	   = Just mo_wordUShr
+translateOp SllOp          = Just mo_wordShl
+translateOp SrlOp          = Just mo_wordUShr
 
-translateOp AddrRemOp	   = Just mo_wordURem
+translateOp AddrRemOp      = Just mo_wordURem
 
 -- Native word signed ops
 
@@ -513,9 +506,9 @@ translateOp IntLeOp        = Just mo_wordSLe
 translateOp IntGtOp        = Just mo_wordSGt
 translateOp IntLtOp        = Just mo_wordSLt
 
-translateOp ISllOp	   = Just mo_wordShl
-translateOp ISraOp	   = Just mo_wordSShr
-translateOp ISrlOp	   = Just mo_wordUShr
+translateOp ISllOp         = Just mo_wordShl
+translateOp ISraOp         = Just mo_wordSShr
+translateOp ISrlOp         = Just mo_wordUShr
 
 -- Native word unsigned ops
 
@@ -633,9 +626,9 @@ callishOp _ = Nothing
 -- Helpers for translating various minor variants of array indexing.
 
 -- Bytearrays outside the heap; hence non-pointers
-doIndexOffAddrOp, doIndexByteArrayOp 
-	:: Maybe MachOp -> CmmType 
-	-> [LocalReg] -> [CmmExpr] -> Code
+doIndexOffAddrOp, doIndexByteArrayOp
+        :: Maybe MachOp -> CmmType
+        -> [LocalReg] -> [CmmExpr] -> Code
 doIndexOffAddrOp maybe_post_read_cast rep [res] [addr,idx]
    = mkBasicIndexedRead 0 maybe_post_read_cast rep res addr idx
 doIndexOffAddrOp _ _ _ _
@@ -643,7 +636,7 @@ doIndexOffAddrOp _ _ _ _
 
 doIndexByteArrayOp maybe_post_read_cast rep [res] [addr,idx]
    = mkBasicIndexedRead arrWordsHdrSize maybe_post_read_cast rep res addr idx
-doIndexByteArrayOp _ _ _ _ 
+doIndexByteArrayOp _ _ _ _
    = panic "CgPrimOp: doIndexByteArrayOp"
 
 doReadPtrArrayOp :: LocalReg -> CmmExpr -> CmmExpr -> Code
@@ -651,9 +644,9 @@ doReadPtrArrayOp res addr idx
    = mkBasicIndexedRead arrPtrsHdrSize Nothing gcWord res addr idx
 
 
-doWriteOffAddrOp, doWriteByteArrayOp 
-	:: Maybe MachOp -> CmmType 
-	-> [LocalReg] -> [CmmExpr] -> Code
+doWriteOffAddrOp, doWriteByteArrayOp
+        :: Maybe MachOp -> CmmType
+        -> [LocalReg] -> [CmmExpr] -> Code
 doWriteOffAddrOp maybe_pre_write_cast rep [] [addr,idx,val]
    = mkBasicIndexedWrite 0 maybe_pre_write_cast rep addr idx val
 doWriteOffAddrOp _ _ _ _
@@ -661,7 +654,7 @@ doWriteOffAddrOp _ _ _ _
 
 doWriteByteArrayOp maybe_pre_write_cast rep [] [addr,idx,val]
    = mkBasicIndexedWrite arrWordsHdrSize maybe_pre_write_cast rep addr idx val
-doWriteByteArrayOp _ _ _ _ 
+doWriteByteArrayOp _ _ _ _
    = panic "CgPrimOp: doWriteByteArrayOp"
 
 doWritePtrArrayOp :: CmmExpr -> CmmExpr -> CmmExpr -> Code
@@ -682,16 +675,16 @@ loadArrPtrsSize :: CmmExpr -> CmmExpr
 loadArrPtrsSize addr = CmmLoad (cmmOffsetB addr off) bWord
  where off = fixedHdrSize*wORD_SIZE + oFFSET_StgMutArrPtrs_ptrs
 
-mkBasicIndexedRead :: ByteOff -> Maybe MachOp -> CmmType 
-		   -> LocalReg -> CmmExpr -> CmmExpr -> Code
+mkBasicIndexedRead :: ByteOff -> Maybe MachOp -> CmmType
+                   -> LocalReg -> CmmExpr -> CmmExpr -> Code
 mkBasicIndexedRead off Nothing read_rep res base idx
    = stmtC (CmmAssign (CmmLocal res) (cmmLoadIndexOffExpr off read_rep base idx))
 mkBasicIndexedRead off (Just cast) read_rep res base idx
    = stmtC (CmmAssign (CmmLocal res) (CmmMachOp cast [
-				cmmLoadIndexOffExpr off read_rep base idx]))
+                                cmmLoadIndexOffExpr off read_rep base idx]))
 
-mkBasicIndexedWrite :: ByteOff -> Maybe MachOp -> CmmType 
-		    -> CmmExpr -> CmmExpr -> CmmExpr -> Code
+mkBasicIndexedWrite :: ByteOff -> Maybe MachOp -> CmmType
+                    -> CmmExpr -> CmmExpr -> CmmExpr -> Code
 mkBasicIndexedWrite off Nothing write_rep base idx val
    = stmtC (CmmStore (cmmIndexOffExpr off write_rep base idx) val)
 mkBasicIndexedWrite off (Just cast) write_rep base idx val