Pass DynFlags down to bWord

I've switched to passing DynFlags rather than Platform, as (a) it's
simpler to not have to extract targetPlatform in so many places, and
(b) it may be useful to have DynFlags around in future.

6 files changed, 33 insertions, 20 deletions

diff --git a/compiler/nativeGen/SPARC/CodeGen.hs b/compiler/nativeGen/SPARC/CodeGen.hs
index a3409dd28b..27dafb7d42 100644
--- a/compiler/nativeGen/SPARC/CodeGen.hs
+++ b/compiler/nativeGen/SPARC/CodeGen.hs
@@ -111,7 +111,9 @@ stmtsToInstrs stmts
 
 
 stmtToInstrs :: CmmStmt -> NatM InstrBlock
-stmtToInstrs stmt = case stmt of
+stmtToInstrs stmt = do
+  dflags <- getDynFlags
+  case stmt of
     CmmNop         -> return nilOL
     CmmComment s   -> return (unitOL (COMMENT s))
 
@@ -119,14 +121,14 @@ stmtToInstrs stmt = case stmt of
       | isFloatType ty  -> assignReg_FltCode size reg src
       | isWord64 ty     -> assignReg_I64Code      reg src
       | otherwise       -> assignReg_IntCode size reg src
-        where ty = cmmRegType reg
+        where ty = cmmRegType dflags reg
               size = cmmTypeSize ty
 
     CmmStore addr src
       | isFloatType ty  -> assignMem_FltCode size addr src
       | isWord64 ty     -> assignMem_I64Code      addr src
       | otherwise       -> assignMem_IntCode size addr src
-        where ty = cmmExprType src
+        where ty = cmmExprType dflags src
               size = cmmTypeSize ty
 
     CmmCall target result_regs args _
@@ -203,11 +205,12 @@ assignReg_IntCode _ reg src = do
 -- Floating point assignment to memory
 assignMem_FltCode :: Size -> CmmExpr -> CmmExpr -> NatM InstrBlock
 assignMem_FltCode pk addr src = do
+    dflags <- getDynFlags
     Amode dst__2 code1 <- getAmode addr
     (src__2, code2) <- getSomeReg src
     tmp1 <- getNewRegNat pk
     let
-        pk__2   = cmmExprType src
+        pk__2   = cmmExprType dflags src
         code__2 = code1 `appOL` code2 `appOL`
             if   sizeToWidth pk == typeWidth pk__2
             then unitOL (ST pk src__2 dst__2)
@@ -458,17 +461,21 @@ genCCall target dest_regs argsAndHints
 -- | Generate code to calculate an argument, and move it into one
 --      or two integer vregs.
 arg_to_int_vregs :: CmmExpr -> NatM (OrdList Instr, [Reg])
-arg_to_int_vregs arg
+arg_to_int_vregs arg = do dflags <- getDynFlags
+                          arg_to_int_vregs' dflags arg
+
+arg_to_int_vregs' :: DynFlags -> CmmExpr -> NatM (OrdList Instr, [Reg])
+arg_to_int_vregs' dflags arg
 
         -- If the expr produces a 64 bit int, then we can just use iselExpr64
-        | isWord64 (cmmExprType arg)
+        | isWord64 (cmmExprType dflags arg)
         = do    (ChildCode64 code r_lo) <- iselExpr64 arg
                 let r_hi                = getHiVRegFromLo r_lo
                 return (code, [r_hi, r_lo])
 
         | otherwise
         = do    (src, code)     <- getSomeReg arg
-                let pk          = cmmExprType arg
+                let pk          = cmmExprType dflags arg
 
                 case cmmTypeSize pk of
 
diff --git a/compiler/nativeGen/SPARC/CodeGen/Amode.hs b/compiler/nativeGen/SPARC/CodeGen/Amode.hs
index 92e70eb4dc..139064ccbd 100644
--- a/compiler/nativeGen/SPARC/CodeGen/Amode.hs
+++ b/compiler/nativeGen/SPARC/CodeGen/Amode.hs
@@ -33,7 +33,8 @@ getAmode
 	-> NatM Amode
 
 getAmode tree@(CmmRegOff _ _) 
-	= getAmode (mangleIndexTree tree)
+    = do dflags <- getDynFlags
+         getAmode (mangleIndexTree dflags tree)
 
 getAmode (CmmMachOp (MO_Sub _) [x, CmmLit (CmmInt i _)])
   | fits13Bits (-i)
diff --git a/compiler/nativeGen/SPARC/CodeGen/Base.hs b/compiler/nativeGen/SPARC/CodeGen/Base.hs
index 469361139b..367d9230ba 100644
--- a/compiler/nativeGen/SPARC/CodeGen/Base.hs
+++ b/compiler/nativeGen/SPARC/CodeGen/Base.hs
@@ -29,6 +29,7 @@ import Size
 import Reg
 
 import CodeGen.Platform
+import DynFlags
 import OldCmm
 import OldPprCmm ()
 import Platform
@@ -114,13 +115,13 @@ getRegisterReg platform (CmmGlobal mid)
 
 -- Expand CmmRegOff.  ToDo: should we do it this way around, or convert
 -- CmmExprs into CmmRegOff?
-mangleIndexTree :: CmmExpr -> CmmExpr
+mangleIndexTree :: DynFlags -> CmmExpr -> CmmExpr
 
-mangleIndexTree (CmmRegOff reg off)
+mangleIndexTree dflags (CmmRegOff reg off)
 	= CmmMachOp (MO_Add width) [CmmReg reg, CmmLit (CmmInt (fromIntegral off) width)]
-	where width = typeWidth (cmmRegType reg)
+	where width = typeWidth (cmmRegType dflags reg)
 
-mangleIndexTree _
+mangleIndexTree _ _
 	= panic "SPARC.CodeGen.Base.mangleIndexTree: no match"
 
 
diff --git a/compiler/nativeGen/SPARC/CodeGen/CondCode.hs b/compiler/nativeGen/SPARC/CodeGen/CondCode.hs
index 74f20196df..d459d98212 100644
--- a/compiler/nativeGen/SPARC/CodeGen/CondCode.hs
+++ b/compiler/nativeGen/SPARC/CodeGen/CondCode.hs
@@ -93,14 +93,15 @@ condIntCode cond x y = do
 
 condFltCode :: Cond -> CmmExpr -> CmmExpr -> NatM CondCode
 condFltCode cond x y = do
+    dflags <- getDynFlags
     (src1, code1) <- getSomeReg x
     (src2, code2) <- getSomeReg y
     tmp <- getNewRegNat FF64
     let
    	promote x = FxTOy FF32 FF64 x tmp
 
-    	pk1   = cmmExprType x
-    	pk2   = cmmExprType y
+    	pk1   = cmmExprType dflags x
+    	pk2   = cmmExprType dflags y
 
     	code__2 =
 		if pk1 `cmmEqType` pk2 then
diff --git a/compiler/nativeGen/SPARC/CodeGen/Gen32.hs b/compiler/nativeGen/SPARC/CodeGen/Gen32.hs
index c2c47e99aa..f7c7419e15 100644
--- a/compiler/nativeGen/SPARC/CodeGen/Gen32.hs
+++ b/compiler/nativeGen/SPARC/CodeGen/Gen32.hs
@@ -57,11 +57,12 @@ getRegister :: CmmExpr -> NatM Register
 getRegister (CmmReg reg) 
   = do dflags <- getDynFlags
        let platform = targetPlatform dflags
-       return (Fixed (cmmTypeSize (cmmRegType reg))
-              (getRegisterReg platform reg) nilOL)
+       return (Fixed (cmmTypeSize (cmmRegType dflags reg))
+                     (getRegisterReg platform reg) nilOL)
 
 getRegister tree@(CmmRegOff _ _) 
-  = getRegister (mangleIndexTree tree)
+  = do dflags <- getDynFlags
+       getRegister (mangleIndexTree dflags tree)
 
 getRegister (CmmMachOp (MO_UU_Conv W64 W32)
              [CmmMachOp (MO_U_Shr W64) [x,CmmLit (CmmInt 32 _)]]) = do
@@ -490,14 +491,15 @@ trivialFCode
 	-> NatM Register
 
 trivialFCode pk instr x y = do
+    dflags <- getDynFlags
     (src1, code1) <- getSomeReg x
     (src2, code2) <- getSomeReg y
     tmp <- getNewRegNat FF64
     let
     	promote x = FxTOy FF32 FF64 x tmp
 
-    	pk1   = cmmExprType x
-    	pk2   = cmmExprType y
+    	pk1   = cmmExprType dflags x
+    	pk2   = cmmExprType dflags y
 
     	code__2 dst =
     	    	if pk1 `cmmEqType` pk2 then
diff --git a/compiler/nativeGen/SPARC/Ppr.hs b/compiler/nativeGen/SPARC/Ppr.hs
index 8ae3b4b744..55afac0ee2 100644
--- a/compiler/nativeGen/SPARC/Ppr.hs
+++ b/compiler/nativeGen/SPARC/Ppr.hs
@@ -338,7 +338,8 @@ pprSectionHeader seg
 -- | Pretty print a data item.
 pprDataItem :: CmmLit -> SDoc
 pprDataItem lit
-  = vcat (ppr_item (cmmTypeSize $ cmmLitType lit) lit)
+  = sdocWithDynFlags $ \dflags ->
+    vcat (ppr_item (cmmTypeSize $ cmmLitType dflags lit) lit)
     where
         imm = litToImm lit