Whitespace only in codeGen/StgCmmForeign.hs

1 files changed, 92 insertions, 99 deletions

diff --git a/compiler/codeGen/StgCmmForeign.hs b/compiler/codeGen/StgCmmForeign.hs
index f07fd6c6bc..78aabd82ce 100644
--- a/compiler/codeGen/StgCmmForeign.hs
+++ b/compiler/codeGen/StgCmmForeign.hs
@@ -6,13 +6,6 @@
 --
 -----------------------------------------------------------------------------
 
-{-# 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 StgCmmForeign (
   cgForeignCall, loadThreadState, saveThreadState,
   emitPrimCall, emitCCall,
@@ -52,63 +45,63 @@ import Control.Monad
 -- Code generation for Foreign Calls
 -----------------------------------------------------------------------------
 
-cgForeignCall :: [LocalReg]		-- r1,r2  where to put the results
-	      -> [ForeignHint]
-	      -> ForeignCall		-- the op
-	      -> [StgArg]		-- x,y	  arguments
-	      -> FCode ()
+cgForeignCall :: [LocalReg]             -- r1,r2  where to put the results
+              -> [ForeignHint]
+              -> ForeignCall            -- the op
+              -> [StgArg]               -- x,y    arguments
+              -> FCode ()
 -- Emits code for an unsafe foreign call:      r1, r2 = foo( x, y, z )
 
 cgForeignCall results result_hints (CCall (CCallSpec target cconv safety)) stg_args
-  = do	{ cmm_args <- getFCallArgs stg_args
+  = do  { cmm_args <- getFCallArgs stg_args
         ; let ((call_args, arg_hints), cmm_target)
                 = case target of
-                   StaticTarget lbl mPkgId 
-		     -> let labelSource
-				= case mPkgId of
-					Nothing		-> ForeignLabelInThisPackage
-					Just pkgId	-> ForeignLabelInPackage pkgId
-			    size	= call_size cmm_args
-			in  ( unzip cmm_args
-			    , CmmLit (CmmLabel 
-					(mkForeignLabel lbl size labelSource IsFunction)))
- 
+                   StaticTarget lbl mPkgId
+                     -> let labelSource
+                                = case mPkgId of
+                                        Nothing         -> ForeignLabelInThisPackage
+                                        Just pkgId      -> ForeignLabelInPackage pkgId
+                            size        = call_size cmm_args
+                        in  ( unzip cmm_args
+                            , CmmLit (CmmLabel
+                                        (mkForeignLabel lbl size labelSource IsFunction)))
+
                    DynamicTarget    ->  case cmm_args of
                                            (fn,_):rest -> (unzip rest, fn)
                                            [] -> panic "cgForeignCall []"
               fc = ForeignConvention cconv arg_hints result_hints
               call_target = ForeignTarget cmm_target fc
-        
-        ; srt <- getSRTInfo NoSRT        -- SLPJ: Not sure what SRT 
+
+        ; srt <- getSRTInfo NoSRT        -- SLPJ: Not sure what SRT
                                         -- is right here
                                         -- JD: Does it matter in the new codegen?
         ; emitForeignCall safety results call_target call_args srt CmmMayReturn }
   where
-	-- in the stdcall calling convention, the symbol needs @size appended
-	-- to it, where size is the total number of bytes of arguments.  We
-	-- attach this info to the CLabel here, and the CLabel pretty printer
-	-- will generate the suffix when the label is printed.
+        -- in the stdcall calling convention, the symbol needs @size appended
+        -- to it, where size is the total number of bytes of arguments.  We
+        -- attach this info to the CLabel here, and the CLabel pretty printer
+        -- will generate the suffix when the label is printed.
       call_size args
-	| StdCallConv <- cconv = Just (sum (map arg_size args))
-	| otherwise            = Nothing
+        | StdCallConv <- cconv = Just (sum (map arg_size args))
+        | otherwise            = Nothing
 
-	-- ToDo: this might not be correct for 64-bit API
+        -- ToDo: this might not be correct for 64-bit API
       arg_size (arg, _) = max (widthInBytes $ typeWidth $ cmmExprType arg) wORD_SIZE
 
 emitCCall :: [(CmmFormal,ForeignHint)]
-	  -> CmmExpr 
-	  -> [(CmmActual,ForeignHint)]
-	  -> FCode ()
+          -> CmmExpr
+          -> [(CmmActual,ForeignHint)]
+          -> FCode ()
 emitCCall hinted_results fn hinted_args
   = emitForeignCall PlayRisky results target args
-	            NoC_SRT -- No SRT b/c we PlayRisky
-              	    CmmMayReturn
+                    NoC_SRT -- No SRT b/c we PlayRisky
+                    CmmMayReturn
   where
     (args, arg_hints) = unzip hinted_args
     (results, result_hints) = unzip hinted_results
     target = ForeignTarget fn fc
     fc = ForeignConvention CCallConv arg_hints result_hints
-    
+
 
 emitPrimCall :: [CmmFormal] -> CallishMachOp -> [CmmActual] -> FCode ()
 emitPrimCall res op args
@@ -138,7 +131,7 @@ emitForeignCall safety results target args _srt _ret
 
 
 {-
---	THINK ABOUT THIS (used to happen)
+--      THINK ABOUT THIS (used to happen)
 -- we might need to load arguments into temporaries before
 -- making the call, because certain global registers might
 -- overlap with registers that the C calling convention uses
@@ -148,12 +141,12 @@ emitForeignCall safety results target args _srt _ret
 -- it's easier to generate the temporaries here.
 load_args_into_temps = mapM arg_assign_temp
   where arg_assign_temp (e,hint) = do
-	   tmp <- maybe_assign_temp e
-	   return (tmp,hint)
+           tmp <- maybe_assign_temp e
+           return (tmp,hint)
 -}
-	
+
 load_target_into_temp :: ForeignTarget -> FCode ForeignTarget
-load_target_into_temp (ForeignTarget expr conv) = do 
+load_target_into_temp (ForeignTarget expr conv) = do
   tmp <- maybe_assign_temp expr
   return (ForeignTarget tmp conv)
 load_target_into_temp other_target@(PrimTarget _) =
@@ -162,13 +155,13 @@ load_target_into_temp other_target@(PrimTarget _) =
 maybe_assign_temp :: CmmExpr -> FCode CmmExpr
 maybe_assign_temp e
   | hasNoGlobalRegs e = return e
-  | otherwise         = do 
-	-- don't use assignTemp, it uses its own notion of "trivial"
-	-- expressions, which are wrong here.
+  | otherwise         = do
+        -- don't use assignTemp, it uses its own notion of "trivial"
+        -- expressions, which are wrong here.
         -- this is a NonPtr because it only duplicates an existing
-	reg <- newTemp (cmmExprType e) --TODO FIXME NOW
-	emit (mkAssign (CmmLocal reg) e)
-	return (CmmReg (CmmLocal reg))
+        reg <- newTemp (cmmExprType e) --TODO FIXME NOW
+        emit (mkAssign (CmmLocal reg) e)
+        return (CmmReg (CmmLocal reg))
 
 -- -----------------------------------------------------------------------------
 -- Save/restore the thread state in the TSO
@@ -183,7 +176,7 @@ saveThreadState =
   <*> closeNursery
   -- and save the current cost centre stack in the TSO when profiling:
   <*> if opt_SccProfilingOn then
-	mkStore (cmmOffset stgCurrentTSO tso_CCCS) curCCS
+        mkStore (cmmOffset stgCurrentTSO tso_CCCS) curCCS
       else mkNop
 
 emitSaveThreadState :: BlockId -> FCode ()
@@ -194,7 +187,7 @@ emitSaveThreadState bid = do
   emit closeNursery
   -- and save the current cost centre stack in the TSO when profiling:
   when opt_SccProfilingOn $
-	emit (mkStore (cmmOffset stgCurrentTSO tso_CCCS) curCCS)
+        emit (mkStore (cmmOffset stgCurrentTSO tso_CCCS) curCCS)
 
    -- CurrentNursery->free = Hp+1;
 closeNursery :: CmmAGraph
@@ -205,19 +198,19 @@ loadThreadState tso stack = do
   -- tso <- newTemp gcWord -- TODO FIXME NOW
   -- stack <- newTemp gcWord -- TODO FIXME NOW
   catAGraphs [
-	-- tso = CurrentTSO;
-  	mkAssign (CmmLocal tso) stgCurrentTSO,
-	-- stack = tso->stackobj;
-	mkAssign (CmmLocal stack) (CmmLoad (cmmOffset (CmmReg (CmmLocal tso)) tso_stackobj) bWord),
-	-- Sp = stack->sp;
-	mkAssign sp (CmmLoad (cmmOffset (CmmReg (CmmLocal stack)) stack_SP) bWord),
-	-- SpLim = stack->stack + RESERVED_STACK_WORDS;
-	mkAssign spLim (cmmOffsetW (cmmOffset (CmmReg (CmmLocal stack)) stack_STACK)
-			            rESERVED_STACK_WORDS),
+        -- tso = CurrentTSO;
+        mkAssign (CmmLocal tso) stgCurrentTSO,
+        -- stack = tso->stackobj;
+        mkAssign (CmmLocal stack) (CmmLoad (cmmOffset (CmmReg (CmmLocal tso)) tso_stackobj) bWord),
+        -- Sp = stack->sp;
+        mkAssign sp (CmmLoad (cmmOffset (CmmReg (CmmLocal stack)) stack_SP) bWord),
+        -- SpLim = stack->stack + RESERVED_STACK_WORDS;
+        mkAssign spLim (cmmOffsetW (cmmOffset (CmmReg (CmmLocal stack)) stack_STACK)
+                                    rESERVED_STACK_WORDS),
         openNursery,
         -- and load the current cost centre stack from the TSO when profiling:
         if opt_SccProfilingOn then
-	  mkStore curCCSAddr
+          mkStore curCCSAddr
                   (CmmLoad (cmmOffset (CmmReg (CmmLocal tso)) tso_CCCS) ccsType)
         else mkNop]
 emitLoadThreadState :: LocalReg -> LocalReg -> FCode ()
@@ -226,22 +219,22 @@ emitLoadThreadState tso stack = emit $ loadThreadState tso stack
 openNursery :: CmmAGraph
 openNursery = catAGraphs [
         -- Hp = CurrentNursery->free - 1;
-	mkAssign hp (cmmOffsetW (CmmLoad nursery_bdescr_free bWord) (-1)),
-
-        -- HpLim = CurrentNursery->start + 
-	--		CurrentNursery->blocks*BLOCK_SIZE_W - 1;
-	mkAssign hpLim
-	    (cmmOffsetExpr
-		(CmmLoad nursery_bdescr_start bWord)
-		(cmmOffset
-		  (CmmMachOp mo_wordMul [
-		    CmmMachOp (MO_SS_Conv W32 wordWidth)
-		      [CmmLoad nursery_bdescr_blocks b32],
-		    CmmLit (mkIntCLit bLOCK_SIZE)
-		   ])
-		  (-1)
-		)
-	    )
+        mkAssign hp (cmmOffsetW (CmmLoad nursery_bdescr_free bWord) (-1)),
+
+        -- HpLim = CurrentNursery->start +
+        --              CurrentNursery->blocks*BLOCK_SIZE_W - 1;
+        mkAssign hpLim
+            (cmmOffsetExpr
+                (CmmLoad nursery_bdescr_start bWord)
+                (cmmOffset
+                  (CmmMachOp mo_wordMul [
+                    CmmMachOp (MO_SS_Conv W32 wordWidth)
+                      [CmmLoad nursery_bdescr_blocks b32],
+                    CmmLit (mkIntCLit bLOCK_SIZE)
+                   ])
+                  (-1)
+                )
+            )
    ]
 emitOpenNursery :: FCode ()
 emitOpenNursery = emit openNursery
@@ -262,18 +255,18 @@ closureField :: ByteOff -> ByteOff
 closureField off = off + fixedHdrSize * wORD_SIZE
 
 stgSp, stgHp, stgCurrentTSO, stgCurrentNursery :: CmmExpr
-stgSp		  = CmmReg sp
-stgHp		  = CmmReg hp
-stgCurrentTSO	  = CmmReg currentTSO
+stgSp             = CmmReg sp
+stgHp             = CmmReg hp
+stgCurrentTSO     = CmmReg currentTSO
 stgCurrentNursery = CmmReg currentNursery
 
 sp, spLim, hp, hpLim, currentTSO, currentNursery :: CmmReg
-sp		  = CmmGlobal Sp
-spLim		  = CmmGlobal SpLim
-hp		  = CmmGlobal Hp
-hpLim		  = CmmGlobal HpLim
-currentTSO	  = CmmGlobal CurrentTSO
-currentNursery 	  = CmmGlobal CurrentNursery
+sp                = CmmGlobal Sp
+spLim             = CmmGlobal SpLim
+hp                = CmmGlobal Hp
+hpLim             = CmmGlobal HpLim
+currentTSO        = CmmGlobal CurrentTSO
+currentNursery    = CmmGlobal CurrentNursery
 
 -- -----------------------------------------------------------------------------
 -- For certain types passed to foreign calls, we adjust the actual
@@ -286,18 +279,18 @@ getFCallArgs :: [StgArg] -> FCode [(CmmExpr, ForeignHint)]
 -- It's (b) that makes this differ from getNonVoidArgAmodes
 
 getFCallArgs args
-  = do	{ mb_cmms <- mapM get args
-	; return (catMaybes mb_cmms) }
+  = do  { mb_cmms <- mapM get args
+        ; return (catMaybes mb_cmms) }
   where
-    get arg | isVoidRep arg_rep 
-	    = return Nothing
-	    | otherwise
-	    = do { cmm <- getArgAmode (NonVoid arg)
-		 ; return (Just (add_shim arg_ty cmm, hint)) }
-	    where
-	      arg_ty  = stgArgType arg
-	      arg_rep = typePrimRep arg_ty
-	      hint    = typeForeignHint arg_ty
+    get arg | isVoidRep arg_rep
+            = return Nothing
+            | otherwise
+            = do { cmm <- getArgAmode (NonVoid arg)
+                 ; return (Just (add_shim arg_ty cmm, hint)) }
+            where
+              arg_ty  = stgArgType arg
+              arg_rep = typePrimRep arg_ty
+              hint    = typeForeignHint arg_ty
 
 add_shim :: Type -> CmmExpr -> CmmExpr
 add_shim arg_ty expr
@@ -308,6 +301,6 @@ add_shim arg_ty expr
   = cmmOffsetB expr arrWordsHdrSize
 
   | otherwise = expr
-  where	
+  where
     tycon = tyConAppTyCon (repType arg_ty)
-	-- should be a tycon app, since this is a foreign call
+        -- should be a tycon app, since this is a foreign call