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.

17 files changed, 317 insertions, 279 deletions

diff --git a/compiler/cmm/CmmExpr.hs b/compiler/cmm/CmmExpr.hs
index 186b6bfdc2..3387b3f470 100644
--- a/compiler/cmm/CmmExpr.hs
+++ b/compiler/cmm/CmmExpr.hs
@@ -23,6 +23,7 @@ import CmmType
 import CmmMachOp
 import BlockId
 import CLabel
+import DynFlags
 import Unique
 
 import Data.Set (Set)
@@ -111,31 +112,32 @@ data CmmLit
   | CmmHighStackMark -- stands for the max stack space used during a procedure
   deriving Eq
 
-cmmExprType :: CmmExpr -> CmmType
-cmmExprType (CmmLit lit)        = cmmLitType lit
-cmmExprType (CmmLoad _ rep)     = rep
-cmmExprType (CmmReg reg)        = cmmRegType reg
-cmmExprType (CmmMachOp op args) = machOpResultType op (map cmmExprType args)
-cmmExprType (CmmRegOff reg _)   = cmmRegType reg
-cmmExprType (CmmStackSlot _ _)  = bWord -- an address
+cmmExprType :: DynFlags -> CmmExpr -> CmmType
+cmmExprType dflags (CmmLit lit)        = cmmLitType dflags lit
+cmmExprType _      (CmmLoad _ rep)     = rep
+cmmExprType dflags (CmmReg reg)        = cmmRegType dflags reg
+cmmExprType dflags (CmmMachOp op args) = machOpResultType dflags op (map (cmmExprType dflags) args)
+cmmExprType dflags (CmmRegOff reg _)   = cmmRegType dflags reg
+cmmExprType dflags (CmmStackSlot _ _)  = bWord dflags -- an address
 -- Careful though: what is stored at the stack slot may be bigger than
 -- an address
 
-cmmLitType :: CmmLit -> CmmType
-cmmLitType (CmmInt _ width)     = cmmBits  width
-cmmLitType (CmmFloat _ width)   = cmmFloat width
-cmmLitType (CmmLabel lbl)       = cmmLabelType lbl
-cmmLitType (CmmLabelOff lbl _)  = cmmLabelType lbl
-cmmLitType (CmmLabelDiffOff {}) = bWord
-cmmLitType (CmmBlock _)         = bWord
-cmmLitType (CmmHighStackMark)   = bWord
+cmmLitType :: DynFlags -> CmmLit -> CmmType
+cmmLitType _      (CmmInt _ width)     = cmmBits  width
+cmmLitType _      (CmmFloat _ width)   = cmmFloat width
+cmmLitType dflags (CmmLabel lbl)       = cmmLabelType dflags lbl
+cmmLitType dflags (CmmLabelOff lbl _)  = cmmLabelType dflags lbl
+cmmLitType dflags (CmmLabelDiffOff {}) = bWord dflags
+cmmLitType dflags (CmmBlock _)         = bWord dflags
+cmmLitType dflags (CmmHighStackMark)   = bWord dflags
 
-cmmLabelType :: CLabel -> CmmType
-cmmLabelType lbl | isGcPtrLabel lbl = gcWord
-                 | otherwise        = bWord
+cmmLabelType :: DynFlags -> CLabel -> CmmType
+cmmLabelType dflags lbl
+ | isGcPtrLabel lbl = gcWord
+ | otherwise        = bWord dflags
 
-cmmExprWidth :: CmmExpr -> Width
-cmmExprWidth e = typeWidth (cmmExprType e)
+cmmExprWidth :: DynFlags -> CmmExpr -> Width
+cmmExprWidth dflags e = typeWidth (cmmExprType dflags e)
 
 --------
 --- Negation for conditional branches
@@ -164,9 +166,9 @@ instance Ord LocalReg where
 instance Uniquable LocalReg where
   getUnique (LocalReg uniq _) = uniq
 
-cmmRegType :: CmmReg -> CmmType
-cmmRegType (CmmLocal  reg) = localRegType reg
-cmmRegType (CmmGlobal reg) = globalRegType reg
+cmmRegType :: DynFlags -> CmmReg -> CmmType
+cmmRegType _      (CmmLocal  reg) = localRegType reg
+cmmRegType dflags (CmmGlobal reg) = globalRegType dflags reg
 
 localRegType :: LocalReg -> CmmType
 localRegType (LocalReg _ rep) = rep
@@ -412,12 +414,12 @@ nodeReg = CmmGlobal node
 node :: GlobalReg
 node = VanillaReg 1 VGcPtr
 
-globalRegType :: GlobalReg -> CmmType
-globalRegType (VanillaReg _ VGcPtr)    = gcWord
-globalRegType (VanillaReg _ VNonGcPtr) = bWord
-globalRegType (FloatReg _)      = cmmFloat W32
-globalRegType (DoubleReg _)     = cmmFloat W64
-globalRegType (LongReg _)       = cmmBits W64
-globalRegType Hp                = gcWord    -- The initialiser for all
+globalRegType :: DynFlags -> GlobalReg -> CmmType
+globalRegType _      (VanillaReg _ VGcPtr)    = gcWord
+globalRegType dflags (VanillaReg _ VNonGcPtr) = bWord dflags
+globalRegType _      (FloatReg _)      = cmmFloat W32
+globalRegType _      (DoubleReg _)     = cmmFloat W64
+globalRegType _      (LongReg _)       = cmmBits W64
+globalRegType _      Hp                = gcWord    -- The initialiser for all
                                             -- dynamically allocated closures
-globalRegType _                 = bWord
+globalRegType dflags _                 = bWord dflags
diff --git a/compiler/cmm/CmmLayoutStack.hs b/compiler/cmm/CmmLayoutStack.hs
index 49a0176b45..27054bb8b3 100644
--- a/compiler/cmm/CmmLayoutStack.hs
+++ b/compiler/cmm/CmmLayoutStack.hs
@@ -120,7 +120,7 @@ cmmLayoutStack dflags procpoints entry_args
 
     (final_stackmaps, _final_high_sp, new_blocks) <-
           mfix $ \ ~(rec_stackmaps, rec_high_sp, _new_blocks) ->
-            layout procpoints liveness entry entry_args
+            layout dflags procpoints liveness entry entry_args
                    rec_stackmaps rec_high_sp blocks
 
     new_blocks' <- mapM (lowerSafeForeignCall dflags) new_blocks
@@ -130,7 +130,8 @@ cmmLayoutStack dflags procpoints entry_args
 
 
 
-layout :: BlockSet                      -- proc points
+layout :: DynFlags
+       -> BlockSet                      -- proc points
        -> BlockEnv CmmLive              -- liveness
        -> BlockId                       -- entry
        -> ByteOff                       -- stack args on entry
@@ -146,7 +147,7 @@ layout :: BlockSet                      -- proc points
           , [CmmBlock]                  -- [out] new blocks
           )
 
-layout procpoints liveness entry entry_args final_stackmaps final_hwm blocks
+layout dflags procpoints liveness entry entry_args final_stackmaps final_hwm blocks
   = go blocks init_stackmap entry_args []
   where
     (updfr, cont_info)  = collectContInfo blocks
@@ -187,7 +188,7 @@ layout procpoints liveness entry entry_args final_stackmaps final_hwm blocks
        --     each of the successor blocks.  See handleLastNode for
        --     details.
        (middle2, sp_off, last1, fixup_blocks, out)
-           <- handleLastNode procpoints liveness cont_info
+           <- handleLastNode dflags procpoints liveness cont_info
                              acc_stackmaps stack1 middle0 last0
     
        -- pprTrace "layout(out)" (ppr out) $ return ()
@@ -210,7 +211,7 @@ layout procpoints liveness entry entry_args final_stackmaps final_hwm blocks
               -- beginning of a proc, and we don't modify Sp before the
               -- check.
 
-           final_blocks = manifestSp final_stackmaps stack0 sp0 sp_high entry0
+           final_blocks = manifestSp dflags final_stackmaps stack0 sp0 sp_high entry0
                               middle_pre sp_off last1 fixup_blocks
 
            acc_stackmaps' = mapUnion acc_stackmaps out
@@ -317,7 +318,7 @@ getStackLoc (Young l) n stackmaps =
 -- extra code that goes *after* the Sp adjustment.
 
 handleLastNode
-   :: ProcPointSet -> BlockEnv CmmLive -> BlockEnv ByteOff
+   :: DynFlags -> ProcPointSet -> BlockEnv CmmLive -> BlockEnv ByteOff
    -> BlockEnv StackMap -> StackMap
    -> Block CmmNode O O
    -> CmmNode O C
@@ -329,7 +330,7 @@ handleLastNode
       , BlockEnv StackMap  -- stackmaps for the continuations
       )
 
-handleLastNode procpoints liveness cont_info stackmaps
+handleLastNode dflags procpoints liveness cont_info stackmaps
                stack0@StackMap { sm_sp = sp0 } middle last
  = case last of
     --  At each return / tail call,
@@ -428,7 +429,7 @@ handleLastNode procpoints liveness cont_info stackmaps
         | Just stack2 <- mapLookup l stackmaps
         = do
              let assigs = fixupStack stack0 stack2
-             (tmp_lbl, block) <- makeFixupBlock sp0 l stack2 assigs
+             (tmp_lbl, block) <- makeFixupBlock dflags sp0 l stack2 assigs
              return (l, tmp_lbl, stack2, block)
 
         --   (b) if the successor is a proc point, save everything
@@ -442,7 +443,7 @@ handleLastNode procpoints liveness cont_info stackmaps
                       setupStackFrame l liveness (sm_ret_off stack0)
                                                        cont_args stack0
              --
-             (tmp_lbl, block) <- makeFixupBlock sp0 l stack2 assigs
+             (tmp_lbl, block) <- makeFixupBlock dflags sp0 l stack2 assigs
              return (l, tmp_lbl, stack2, block)
 
         --   (c) otherwise, the current StackMap is the StackMap for
@@ -456,14 +457,15 @@ handleLastNode procpoints liveness cont_info stackmaps
               is_live (r,_) = r `elemRegSet` live
 
 
-makeFixupBlock :: ByteOff -> Label -> StackMap -> [CmmNode O O] -> UniqSM (Label, [CmmBlock])
-makeFixupBlock sp0 l stack assigs
+makeFixupBlock :: DynFlags -> ByteOff -> Label -> StackMap -> [CmmNode O O]
+               -> UniqSM (Label, [CmmBlock])
+makeFixupBlock dflags sp0 l stack assigs
   | null assigs && sp0 == sm_sp stack = return (l, [])
   | otherwise = do
     tmp_lbl <- liftM mkBlockId $ getUniqueM
     let sp_off = sp0 - sm_sp stack
         block = blockJoin (CmmEntry tmp_lbl)
-                          (maybeAddSpAdj sp_off (blockFromList assigs))
+                          (maybeAddSpAdj dflags sp_off (blockFromList assigs))
                           (CmmBranch l)
     return (tmp_lbl, [block])
 
@@ -705,7 +707,8 @@ allocate ret_off live stackmap@StackMap{ sm_sp = sp0
 -- middle_post, because the Sp adjustment intervenes.
 --
 manifestSp
-   :: BlockEnv StackMap  -- StackMaps for other blocks
+   :: DynFlags
+   -> BlockEnv StackMap  -- StackMaps for other blocks
    -> StackMap           -- StackMap for this block
    -> ByteOff            -- Sp on entry to the block
    -> ByteOff            -- SpHigh
@@ -716,17 +719,17 @@ manifestSp
    -> [CmmBlock]         -- new blocks
    -> [CmmBlock]         -- final blocks with Sp manifest
 
-manifestSp stackmaps stack0 sp0 sp_high
+manifestSp dflags stackmaps stack0 sp0 sp_high
            first middle_pre sp_off last fixup_blocks
   = final_block : fixup_blocks'
   where
     area_off = getAreaOff stackmaps
 
     adj_pre_sp, adj_post_sp :: CmmNode e x -> CmmNode e x
-    adj_pre_sp  = mapExpDeep (areaToSp sp0            sp_high area_off)
-    adj_post_sp = mapExpDeep (areaToSp (sp0 - sp_off) sp_high area_off)
+    adj_pre_sp  = mapExpDeep (areaToSp dflags sp0            sp_high area_off)
+    adj_post_sp = mapExpDeep (areaToSp dflags (sp0 - sp_off) sp_high area_off)
 
-    final_middle = maybeAddSpAdj sp_off $
+    final_middle = maybeAddSpAdj dflags sp_off $
                    blockFromList $
                    map adj_pre_sp $
                    elimStackStores stack0 stackmaps area_off $
@@ -747,10 +750,10 @@ getAreaOff stackmaps (Young l) =
     Nothing -> pprPanic "getAreaOff" (ppr l)
 
 
-maybeAddSpAdj :: ByteOff -> Block CmmNode O O -> Block CmmNode O O
-maybeAddSpAdj 0      block = block
-maybeAddSpAdj sp_off block
-   = block `blockSnoc` CmmAssign spReg (cmmOffset (CmmReg spReg) sp_off)
+maybeAddSpAdj :: DynFlags -> ByteOff -> Block CmmNode O O -> Block CmmNode O O
+maybeAddSpAdj _      0      block = block
+maybeAddSpAdj dflags sp_off block
+   = block `blockSnoc` CmmAssign spReg (cmmOffset dflags (CmmReg spReg) sp_off)
 
 
 {-
@@ -770,16 +773,16 @@ arguments.
    to be Sp + Sp(L) - Sp(L')
 -}
 
-areaToSp :: ByteOff -> ByteOff -> (Area -> StackLoc) -> CmmExpr -> CmmExpr
-areaToSp sp_old _sp_hwm area_off (CmmStackSlot area n) =
-  cmmOffset (CmmReg spReg) (sp_old - area_off area - n)
-areaToSp _ sp_hwm _ (CmmLit CmmHighStackMark) = mkIntExpr sp_hwm
-areaToSp _ _ _ (CmmMachOp (MO_U_Lt _)  -- Note [null stack check]
+areaToSp :: DynFlags -> ByteOff -> ByteOff -> (Area -> StackLoc) -> CmmExpr -> CmmExpr
+areaToSp dflags sp_old _sp_hwm area_off (CmmStackSlot area n) =
+  cmmOffset dflags (CmmReg spReg) (sp_old - area_off area - n)
+areaToSp _ _ sp_hwm _ (CmmLit CmmHighStackMark) = mkIntExpr sp_hwm
+areaToSp _ _ _ _ (CmmMachOp (MO_U_Lt _)  -- Note [null stack check]
                       [CmmMachOp (MO_Sub _)
                               [ CmmReg (CmmGlobal Sp)
                               , CmmLit (CmmInt 0 _)],
                        CmmReg (CmmGlobal SpLim)]) = zeroExpr
-areaToSp _ _ _ other = other
+areaToSp _ _ _ _ other = other
 
 -- -----------------------------------------------------------------------------
 -- Note [null stack check]
@@ -910,8 +913,8 @@ lowerSafeForeignCall dflags block
   = do
     -- Both 'id' and 'new_base' are KindNonPtr because they're
     -- RTS-only objects and are not subject to garbage collection
-    id <- newTemp bWord
-    new_base <- newTemp (cmmRegType (CmmGlobal BaseReg))
+    id <- newTemp (bWord dflags)
+    new_base <- newTemp (cmmRegType dflags (CmmGlobal BaseReg))
     let (caller_save, caller_load) = callerSaveVolatileRegs dflags
     load_tso <- newTemp gcWord
     load_stack <- newTemp gcWord
@@ -935,7 +938,7 @@ lowerSafeForeignCall dflags block
         -- received an exception during the call, then the stack might be
         -- different.  Hence we continue by jumping to the top stack frame,
         -- not by jumping to succ.
-        jump = CmmCall { cml_target    = CmmLoad (CmmReg spReg) bWord
+        jump = CmmCall { cml_target    = CmmLoad (CmmReg spReg) (bWord dflags)
                        , cml_cont      = Just succ
                        , cml_args_regs = regs
                        , cml_args      = widthInBytes wordWidth
diff --git a/compiler/cmm/CmmLint.hs b/compiler/cmm/CmmLint.hs
index 47c30b1a0f..53238edf94 100644
--- a/compiler/cmm/CmmLint.hs
+++ b/compiler/cmm/CmmLint.hs
@@ -19,6 +19,7 @@ import BlockId
 import FastString
 import Outputable
 import Constants
+import DynFlags
 
 import Data.Maybe
 
@@ -31,15 +32,15 @@ import Data.Maybe
 -- Exported entry points:
 
 cmmLint :: (Outputable d, Outputable h)
-        => GenCmmGroup d h CmmGraph -> Maybe SDoc
-cmmLint tops = runCmmLint (mapM_ lintCmmDecl) tops
+        => DynFlags -> GenCmmGroup d h CmmGraph -> Maybe SDoc
+cmmLint dflags tops = runCmmLint dflags (mapM_ lintCmmDecl) tops
 
-cmmLintGraph :: CmmGraph -> Maybe SDoc
-cmmLintGraph g = runCmmLint lintCmmGraph g
+cmmLintGraph :: DynFlags -> CmmGraph -> Maybe SDoc
+cmmLintGraph dflags g = runCmmLint dflags lintCmmGraph g
 
-runCmmLint :: Outputable a => (a -> CmmLint b) -> a -> Maybe SDoc
-runCmmLint l p =
-   case unCL (l p) of
+runCmmLint :: Outputable a => DynFlags -> (a -> CmmLint b) -> a -> Maybe SDoc
+runCmmLint dflags l p =
+   case unCL (l p) dflags of
      Left err -> Just (vcat [ptext $ sLit ("Cmm lint error:"),
                              nest 2 err,
                              ptext $ sLit ("Program was:"),
@@ -85,23 +86,27 @@ lintCmmExpr (CmmLoad expr rep) = do
   --   cmmCheckWordAddress expr
   return rep
 lintCmmExpr expr@(CmmMachOp op args) = do
+  dflags <- getDynFlags
   tys <- mapM lintCmmExpr args
-  if map (typeWidth . cmmExprType) args == machOpArgReps op
+  if map (typeWidth . cmmExprType dflags) args == machOpArgReps op
         then cmmCheckMachOp op args tys
-        else cmmLintMachOpErr expr (map cmmExprType args) (machOpArgReps op)
+        else cmmLintMachOpErr expr (map (cmmExprType dflags) args) (machOpArgReps op)
 lintCmmExpr (CmmRegOff reg offset)
-  = lintCmmExpr (CmmMachOp (MO_Add rep)
+  = do dflags <- getDynFlags
+       let rep = typeWidth (cmmRegType dflags reg)
+       lintCmmExpr (CmmMachOp (MO_Add rep)
                 [CmmReg reg, CmmLit (CmmInt (fromIntegral offset) rep)])
-  where rep = typeWidth (cmmRegType reg)
 lintCmmExpr expr =
-  return (cmmExprType expr)
+  do dflags <- getDynFlags
+     return (cmmExprType dflags expr)
 
 -- Check for some common byte/word mismatches (eg. Sp + 1)
 cmmCheckMachOp   :: MachOp -> [CmmExpr] -> [CmmType] -> CmmLint CmmType
 cmmCheckMachOp op [lit@(CmmLit (CmmInt { })), reg@(CmmReg _)] tys
   = cmmCheckMachOp op [reg, lit] tys
 cmmCheckMachOp op _ tys
-  = return (machOpResultType op tys)
+  = do dflags <- getDynFlags
+       return (machOpResultType dflags op tys)
 
 isOffsetOp :: MachOp -> Bool
 isOffsetOp (MO_Add _) = True
@@ -131,8 +136,9 @@ lintCmmMiddle node = case node of
   CmmComment _ -> return ()
 
   CmmAssign reg expr -> do
+            dflags <- getDynFlags
             erep <- lintCmmExpr expr
-            let reg_ty = cmmRegType reg
+            let reg_ty = cmmRegType dflags reg
             if (erep `cmmEqType_ignoring_ptrhood` reg_ty)
                 then return ()
                 else cmmLintAssignErr (CmmAssign reg expr) erep reg_ty
@@ -157,9 +163,10 @@ lintCmmLast labels node = case node of
             checkCond e
 
   CmmSwitch e branches -> do
+            dflags <- getDynFlags
             mapM_ checkTarget $ catMaybes branches
             erep <- lintCmmExpr e
-            if (erep `cmmEqType_ignoring_ptrhood` bWord)
+            if (erep `cmmEqType_ignoring_ptrhood` bWord dflags)
               then return ()
               else cmmLintErr (text "switch scrutinee is not a word: " <>
                                ppr e <> text " :: " <> ppr erep)
@@ -195,20 +202,24 @@ checkCond expr
 
 -- just a basic error monad:
 
-newtype CmmLint a = CmmLint { unCL :: Either SDoc a }
+newtype CmmLint a = CmmLint { unCL :: DynFlags -> Either SDoc a }
 
 instance Monad CmmLint where
-  CmmLint m >>= k = CmmLint $ case m of
+  CmmLint m >>= k = CmmLint $ \dflags ->
+                                case m dflags of
                                 Left e -> Left e
-                                Right a -> unCL (k a)
-  return a = CmmLint (Right a)
+                                Right a -> unCL (k a) dflags
+  return a = CmmLint (\_ -> Right a)
+
+instance HasDynFlags CmmLint where
+    getDynFlags = CmmLint (\dflags -> Right dflags)
 
 cmmLintErr :: SDoc -> CmmLint a
-cmmLintErr msg = CmmLint (Left msg)
+cmmLintErr msg = CmmLint (\_ -> Left msg)
 
 addLintInfo :: SDoc -> CmmLint a -> CmmLint a
-addLintInfo info thing = CmmLint $
-   case unCL thing of
+addLintInfo info thing = CmmLint $ \dflags ->
+   case unCL thing dflags of
         Left err -> Left (hang info 2 err)
         Right a  -> Right a
 
diff --git a/compiler/cmm/CmmMachOp.hs b/compiler/cmm/CmmMachOp.hs
index d53f4855da..6e152c5f04 100644
--- a/compiler/cmm/CmmMachOp.hs
+++ b/compiler/cmm/CmmMachOp.hs
@@ -25,6 +25,7 @@ where
 
 import CmmType
 import Outputable
+import DynFlags
 
 -----------------------------------------------------------------------------
 --              MachOp
@@ -283,8 +284,8 @@ maybeInvertComparison op
 {- |
 Returns the MachRep of the result of a MachOp.
 -}
-machOpResultType :: MachOp -> [CmmType] -> CmmType
-machOpResultType mop tys =
+machOpResultType :: DynFlags -> MachOp -> [CmmType] -> CmmType
+machOpResultType dflags mop tys =
   case mop of
     MO_Add {}           -> ty1  -- Preserve GC-ptr-hood
     MO_Sub {}           -> ty1  -- of first arg
@@ -297,29 +298,29 @@ machOpResultType mop tys =
     MO_U_Quot r         -> cmmBits r
     MO_U_Rem  r         -> cmmBits r
 
-    MO_Eq {}            -> comparisonResultRep
-    MO_Ne {}            -> comparisonResultRep
-    MO_S_Ge {}          -> comparisonResultRep
-    MO_S_Le {}          -> comparisonResultRep
-    MO_S_Gt {}          -> comparisonResultRep
-    MO_S_Lt {}          -> comparisonResultRep
+    MO_Eq {}            -> comparisonResultRep dflags
+    MO_Ne {}            -> comparisonResultRep dflags
+    MO_S_Ge {}          -> comparisonResultRep dflags
+    MO_S_Le {}          -> comparisonResultRep dflags
+    MO_S_Gt {}          -> comparisonResultRep dflags
+    MO_S_Lt {}          -> comparisonResultRep dflags
 
-    MO_U_Ge {}          -> comparisonResultRep
-    MO_U_Le {}          -> comparisonResultRep
-    MO_U_Gt {}          -> comparisonResultRep
-    MO_U_Lt {}          -> comparisonResultRep
+    MO_U_Ge {}          -> comparisonResultRep dflags
+    MO_U_Le {}          -> comparisonResultRep dflags
+    MO_U_Gt {}          -> comparisonResultRep dflags
+    MO_U_Lt {}          -> comparisonResultRep dflags
 
     MO_F_Add r          -> cmmFloat r
     MO_F_Sub r          -> cmmFloat r
     MO_F_Mul r          -> cmmFloat r
     MO_F_Quot r         -> cmmFloat r
     MO_F_Neg r          -> cmmFloat r
-    MO_F_Eq  {}         -> comparisonResultRep
-    MO_F_Ne  {}         -> comparisonResultRep
-    MO_F_Ge  {}         -> comparisonResultRep
-    MO_F_Le  {}         -> comparisonResultRep
-    MO_F_Gt  {}         -> comparisonResultRep
-    MO_F_Lt  {}         -> comparisonResultRep
+    MO_F_Eq  {}         -> comparisonResultRep dflags
+    MO_F_Ne  {}         -> comparisonResultRep dflags
+    MO_F_Ge  {}         -> comparisonResultRep dflags
+    MO_F_Le  {}         -> comparisonResultRep dflags
+    MO_F_Gt  {}         -> comparisonResultRep dflags
+    MO_F_Lt  {}         -> comparisonResultRep dflags
 
     MO_And {}           -> ty1  -- Used for pointer masking
     MO_Or {}            -> ty1
@@ -337,7 +338,7 @@ machOpResultType mop tys =
   where
     (ty1:_) = tys
 
-comparisonResultRep :: CmmType
+comparisonResultRep :: DynFlags -> CmmType
 comparisonResultRep = bWord  -- is it?
 
 
diff --git a/compiler/cmm/CmmParse.y b/compiler/cmm/CmmParse.y
index 8a10724524..d7df52a566 100644
--- a/compiler/cmm/CmmParse.y
+++ b/compiler/cmm/CmmParse.y
@@ -522,7 +522,7 @@ expr0   :: { ExtFCode CmmExpr }
 
 -- leaving out the type of a literal gives you the native word size in C--
 maybe_ty :: { CmmType }
-        : {- empty -}                   { bWord }
+        : {- empty -}                   {% do dflags <- getDynFlags; return $ bWord dflags }
         | '::' type                     { $2 }
 
 maybe_actuals :: { [ExtFCode HintedCmmActual] }
@@ -630,8 +630,9 @@ mkString s = CmmString (map (fromIntegral.ord) s)
 -- the op.
 mkMachOp :: (Width -> MachOp) -> [ExtFCode CmmExpr] -> ExtFCode CmmExpr
 mkMachOp fn args = do
+  dflags <- getDynFlags
   arg_exprs <- sequence args
-  return (CmmMachOp (fn (typeWidth (cmmExprType (head arg_exprs)))) arg_exprs)
+  return (CmmMachOp (fn (typeWidth (cmmExprType dflags (head arg_exprs)))) arg_exprs)
 
 getLit :: CmmExpr -> CmmLit
 getLit (CmmLit l) = l
@@ -658,12 +659,12 @@ exprOp name args_code = do
 exprMacros :: DynFlags -> UniqFM ([CmmExpr] -> CmmExpr)
 exprMacros dflags = listToUFM [
   ( fsLit "ENTRY_CODE",   \ [x] -> entryCode dflags x ),
-  ( fsLit "INFO_PTR",     \ [x] -> closureInfoPtr x ),
+  ( fsLit "INFO_PTR",     \ [x] -> closureInfoPtr dflags x ),
   ( fsLit "STD_INFO",     \ [x] -> infoTable dflags x ),
   ( fsLit "FUN_INFO",     \ [x] -> funInfoTable dflags x ),
-  ( fsLit "GET_ENTRY",    \ [x] -> entryCode dflags (closureInfoPtr x) ),
-  ( fsLit "GET_STD_INFO", \ [x] -> infoTable dflags (closureInfoPtr x) ),
-  ( fsLit "GET_FUN_INFO", \ [x] -> funInfoTable dflags (closureInfoPtr x) ),
+  ( fsLit "GET_ENTRY",    \ [x] -> entryCode dflags (closureInfoPtr dflags x) ),
+  ( fsLit "GET_STD_INFO", \ [x] -> infoTable dflags (closureInfoPtr dflags x) ),
+  ( fsLit "GET_FUN_INFO", \ [x] -> funInfoTable dflags (closureInfoPtr dflags x) ),
   ( fsLit "INFO_TYPE",    \ [x] -> infoTableClosureType dflags x ),
   ( fsLit "INFO_PTRS",    \ [x] -> infoTablePtrs dflags x ),
   ( fsLit "INFO_NPTRS",   \ [x] -> infoTableNonPtrs dflags x )
@@ -868,7 +869,7 @@ foreignCall conv_string results_code expr_code args_code vols safety ret
             -- Temporary hack so at least some functions are CmmSafe
             CmmCallConv -> code (stmtC (CmmCall (CmmCallee expr convention) results args ret))
             _ ->
-              let expr' = adjCallTarget platform convention expr args in
+              let expr' = adjCallTarget dflags convention expr args in
               case safety of
               CmmUnsafe ->
                 code (emitForeignCall' PlayRisky results
@@ -880,13 +881,14 @@ foreignCall conv_string results_code expr_code args_code vols safety ret
                 code (emitForeignCall' PlayInterruptible results
                    (CmmCallee expr' convention) args vols NoC_SRT ret)
 
-adjCallTarget :: Platform -> CCallConv -> CmmExpr -> [CmmHinted CmmExpr]
+adjCallTarget :: DynFlags -> CCallConv -> CmmExpr -> [CmmHinted CmmExpr]
               -> CmmExpr
 -- On Windows, we have to add the '@N' suffix to the label when making
 -- a call with the stdcall calling convention.
-adjCallTarget (Platform { platformOS = OSMinGW32 }) StdCallConv (CmmLit (CmmLabel lbl)) args
+adjCallTarget dflags StdCallConv (CmmLit (CmmLabel lbl)) args
+ | platformOS (targetPlatform dflags) == OSMinGW32
   = CmmLit (CmmLabel (addLabelSize lbl (sum (map size args))))
-  where size (CmmHinted e _) = max wORD_SIZE (widthInBytes (typeWidth (cmmExprType e)))
+  where size (CmmHinted e _) = max wORD_SIZE (widthInBytes (typeWidth (cmmExprType dflags e)))
                  -- c.f. CgForeignCall.emitForeignCall
 adjCallTarget _ _ expr _
   = expr
@@ -917,14 +919,15 @@ primCall results_code name args_code vols safety
 
 doStore :: CmmType -> ExtFCode CmmExpr  -> ExtFCode CmmExpr -> ExtCode
 doStore rep addr_code val_code
-  = do addr <- addr_code
+  = do dflags <- getDynFlags
+       addr <- addr_code
        val <- val_code
         -- if the specified store type does not match the type of the expr
         -- on the rhs, then we insert a coercion that will cause the type
         -- mismatch to be flagged by cmm-lint.  If we don't do this, then
         -- the store will happen at the wrong type, and the error will not
         -- be noticed.
-       let val_width = typeWidth (cmmExprType val)
+       let val_width = typeWidth (cmmExprType dflags val)
            rep_width = typeWidth rep
        let coerce_val
                 | val_width /= rep_width = CmmMachOp (MO_UU_Conv val_width rep_width) [val]
@@ -941,7 +944,7 @@ emitRetUT args = do
                            -- or regs that we assign to, so better use
                            -- simultaneous assignments here (#3546)
   when (sp /= 0) $ stmtC (CmmAssign spReg (cmmRegOffW spReg (-sp)))
-  stmtC $ CmmJump (entryCode dflags (CmmLoad (cmmRegOffW spReg sp) bWord)) (Just live)
+  stmtC $ CmmJump (entryCode dflags (CmmLoad (cmmRegOffW spReg sp) (bWord dflags))) (Just live)
 
 -- -----------------------------------------------------------------------------
 -- If-then-else and boolean expressions
diff --git a/compiler/cmm/CmmPipeline.hs b/compiler/cmm/CmmPipeline.hs
index 0c075b8476..e87502b5a0 100644
--- a/compiler/cmm/CmmPipeline.hs
+++ b/compiler/cmm/CmmPipeline.hs
@@ -183,7 +183,7 @@ dumpGraph dflags flag name g = do
   when (dopt Opt_DoCmmLinting dflags) $ do_lint g
   dumpWith dflags flag name g
  where
-  do_lint g = case cmmLintGraph g of
+  do_lint g = case cmmLintGraph dflags g of
                  Just err -> do { fatalErrorMsg dflags err
                                 ; ghcExit dflags 1
                                 }
diff --git a/compiler/cmm/CmmRewriteAssignments.hs b/compiler/cmm/CmmRewriteAssignments.hs
index a5b7602078..824883654c 100644
--- a/compiler/cmm/CmmRewriteAssignments.hs
+++ b/compiler/cmm/CmmRewriteAssignments.hs
@@ -20,6 +20,7 @@ import CmmUtils
 import CmmOpt
 import StgCmmUtils
 
+import DynFlags
 import UniqSupply
 import Platform
 import UniqFM
@@ -35,8 +36,9 @@ import Prelude hiding (succ, zip)
 ----------------------------------------------------------------
 --- Main function
 
-rewriteAssignments :: Platform -> CmmGraph -> UniqSM CmmGraph
-rewriteAssignments platform g = do
+rewriteAssignments :: DynFlags -> CmmGraph -> UniqSM CmmGraph
+rewriteAssignments dflags g = do
+  let platform = targetPlatform dflags
   -- Because we need to act on forwards and backwards information, we
   -- first perform usage analysis and bake this information into the
   -- graph (backwards transform), and then do a forwards transform
@@ -44,7 +46,7 @@ rewriteAssignments platform g = do
   g'  <- annotateUsage g
   g'' <- liftM fst $ dataflowPassFwd g' [(g_entry g, fact_bot assignmentLattice)] $
                                      analRewFwd assignmentLattice
-                                                (assignmentTransfer platform)
+                                                (assignmentTransfer dflags)
                                                 (assignmentRewrite `thenFwdRw` machOpFoldRewrite platform)
   return (modifyGraph eraseRegUsage g'')
 
@@ -309,7 +311,7 @@ invalidateUsersOf reg = mapUFM (invalidateUsers' reg)
 -- optimize; we need an algorithmic change to prevent us from having to
 -- traverse the /entire/ map continually.
 
-middleAssignment :: Platform -> WithRegUsage CmmNode O O -> AssignmentMap
+middleAssignment :: DynFlags -> WithRegUsage CmmNode O O -> AssignmentMap
                  -> AssignmentMap
 
 -- Algorithm for annotated assignments:
@@ -349,10 +351,10 @@ middleAssignment _ (Plain (CmmAssign (CmmLocal _) _)) assign = assign
 --  1. Delete any sinking assignments that were used by this instruction
 --  2. Look for all assignments that load from memory locations that
 --     were clobbered by this store and invalidate them.
-middleAssignment _ (Plain n@(CmmStore lhs rhs)) assign
+middleAssignment dflags (Plain n@(CmmStore lhs rhs)) assign
     = let m = deleteSinks n assign
       in foldUFM_Directly f m m -- [foldUFM performance]
-      where f u (xassign -> Just x) m | (lhs, rhs) `clobbers` (u, x) = addToUFM_Directly m u NeverOptimize
+      where f u (xassign -> Just x) m | clobbers dflags (lhs, rhs) (u, x) = addToUFM_Directly m u NeverOptimize
             f _ _ m = m
 {- Also leaky
     = mapUFM_Directly p . deleteSinks n $ assign
@@ -371,7 +373,7 @@ middleAssignment _ (Plain n@(CmmStore lhs rhs)) assign
 -- This is kind of expensive. (One way to optimize this might be to
 -- store extra information about expressions that allow this and other
 -- checks to be done cheaply.)
-middleAssignment platform (Plain n@(CmmUnsafeForeignCall{})) assign
+middleAssignment dflags (Plain n@(CmmUnsafeForeignCall{})) assign
     = deleteCallerSaves (foldRegsDefd (\m r -> addToUFM m r NeverOptimize) (deleteSinks n assign) n)
     where deleteCallerSaves m = foldUFM_Directly f m m
           f u (xassign -> Just x) m | wrapRecExpf g x False = addToUFM_Directly m u NeverOptimize
@@ -379,6 +381,7 @@ middleAssignment platform (Plain n@(CmmUnsafeForeignCall{})) assign
           g (CmmReg (CmmGlobal r)) _      | callerSaves platform r = True
           g (CmmRegOff (CmmGlobal r) _) _ | callerSaves platform r = True
           g _ b = b
+          platform = targetPlatform dflags
 
 middleAssignment _ (Plain (CmmComment {})) assign
     = assign
@@ -398,17 +401,18 @@ middleAssignment _ (Plain (CmmComment {})) assign
 --    the next spill.)
 --  * Non stack-slot stores always conflict with each other.  (This is
 --    not always the case; we could probably do something special for Hp)
-clobbers :: (CmmExpr, CmmExpr) -- (lhs, rhs) of clobbering CmmStore
+clobbers :: DynFlags
+         -> (CmmExpr, CmmExpr) -- (lhs, rhs) of clobbering CmmStore
          -> (Unique,  CmmExpr) -- (register, expression) that may be clobbered
          -> Bool
-clobbers (CmmRegOff (CmmGlobal Hp) _, _) (_, _) = False
-clobbers (CmmReg (CmmGlobal Hp), _) (_, _) = False
+clobbers _ (CmmRegOff (CmmGlobal Hp) _, _) (_, _) = False
+clobbers _ (CmmReg (CmmGlobal Hp), _) (_, _) = False
 -- ToDo: Also catch MachOp case
-clobbers (ss@CmmStackSlot{}, CmmReg (CmmLocal r)) (u, CmmLoad (ss'@CmmStackSlot{}) _)
+clobbers _ (ss@CmmStackSlot{}, CmmReg (CmmLocal r)) (u, CmmLoad (ss'@CmmStackSlot{}) _)
     | getUnique r == u, ss == ss' = False -- No-op on the stack slot (XXX: Do we need this special case?)
-clobbers (CmmStackSlot a o, rhs) (_, expr) = f expr
+clobbers dflags (CmmStackSlot a o, rhs) (_, expr) = f expr
     where f (CmmLoad (CmmStackSlot a' o') t)
-            = (a, o, widthInBytes (cmmExprWidth rhs)) `overlaps` (a', o', widthInBytes (typeWidth t))
+            = (a, o, widthInBytes (cmmExprWidth dflags rhs)) `overlaps` (a', o', widthInBytes (typeWidth t))
           f (CmmLoad e _)    = containsStackSlot e
           f (CmmMachOp _ es) = or (map f es)
           f _                = False
@@ -418,7 +422,7 @@ clobbers (CmmStackSlot a o, rhs) (_, expr) = f expr
           containsStackSlot (CmmMachOp _ es) = or (map containsStackSlot es)
           containsStackSlot (CmmStackSlot{}) = True
           containsStackSlot _ = False
-clobbers _ (_, e) = f e
+clobbers _ _ (_, e) = f e
     where f (CmmLoad (CmmStackSlot _ _) _) = False
           f (CmmLoad{}) = True -- conservative
           f (CmmMachOp _ es) = or (map f es)
@@ -463,11 +467,11 @@ invalidateVolatile k m = mapUFM p m
                   exp _ = False
         p _ = NeverOptimize -- probably shouldn't happen with AlwaysSink
 
-assignmentTransfer :: Platform
+assignmentTransfer :: DynFlags
                    -> FwdTransfer (WithRegUsage CmmNode) AssignmentMap
-assignmentTransfer platform
+assignmentTransfer dflags
     = mkFTransfer3 (flip const)
-                   (middleAssignment platform)
+                   (middleAssignment dflags)
                    ((mkFactBase assignmentLattice .) . lastAssignment)
 
 -- Note [Soundness of inlining]
diff --git a/compiler/cmm/CmmSink.hs b/compiler/cmm/CmmSink.hs
index 71ed4f09f8..8c5c99d469 100644
--- a/compiler/cmm/CmmSink.hs
+++ b/compiler/cmm/CmmSink.hs
@@ -237,8 +237,8 @@ walk dflags nodes assigs = go nodes emptyBlock assigs
    go []               block as = (block, as)
    go ((live,node):ns) block as
     | shouldDiscard node live    = go ns block as
-    | Just a <- shouldSink node1 = go ns block (a : as1)
-    | otherwise                  = go ns block' as'
+    | Just a <- shouldSink dflags node1 = go ns block (a : as1)
+    | otherwise                         = go ns block' as'
     where
       (node1, as1) = tryToInline dflags live node as
 
@@ -251,10 +251,10 @@ walk dflags nodes assigs = go nodes emptyBlock assigs
 -- be profitable to sink assignments to global regs too, but the
 -- liveness analysis doesn't track those (yet) so we can't.
 --
-shouldSink :: CmmNode e x -> Maybe Assignment
-shouldSink (CmmAssign (CmmLocal r) e) | no_local_regs = Just (r, e, exprMem e)
+shouldSink :: DynFlags -> CmmNode e x -> Maybe Assignment
+shouldSink dflags (CmmAssign (CmmLocal r) e) | no_local_regs = Just (r, e, exprMem dflags e)
   where no_local_regs = True -- foldRegsUsed (\_ _ -> False) True e
-shouldSink _other = Nothing
+shouldSink _ _other = Nothing
 
 --
 -- discard dead assignments.  This doesn't do as good a job as
@@ -342,7 +342,7 @@ tryToInline dflags live node assigs = go usages node [] assigs
         node' = mapExpDeep inline node
            where inline (CmmReg    (CmmLocal l'))     | l == l' = rhs
                  inline (CmmRegOff (CmmLocal l') off) | l == l'
-                    = cmmOffset rhs off
+                    = cmmOffset dflags rhs off
                  inline other = other
 
   go usages node skipped (assig@(l,rhs,_) : rest)
@@ -407,7 +407,7 @@ conflicts dflags (r, rhs, addr) node
   | foldRegsUsed (\b r' -> r == r' || b) False node               = True
 
   -- (2) a store to an address conflicts with a read of the same memory
-  | CmmStore addr' e <- node, memConflicts addr (loadAddr addr' (cmmExprWidth e)) = True
+  | CmmStore addr' e <- node, memConflicts addr (loadAddr dflags addr' (cmmExprWidth dflags e)) = True
 
   -- (3) an assignment to Hp/Sp conflicts with a heap/stack read respectively
   | HeapMem    <- addr, CmmAssign (CmmGlobal Hp) _ <- node        = True
@@ -480,21 +480,21 @@ memConflicts (SpMem o1 w1) (SpMem o2 w2)
   | otherwise = o2 + w2 > o1
 memConflicts _         _         = True
 
-exprMem :: CmmExpr -> AbsMem
-exprMem (CmmLoad addr w)  = bothMems (loadAddr addr (typeWidth w)) (exprMem addr)
-exprMem (CmmMachOp _ es)  = foldr bothMems NoMem (map exprMem es)
-exprMem _                 = NoMem
+exprMem :: DynFlags -> CmmExpr -> AbsMem
+exprMem dflags (CmmLoad addr w)  = bothMems (loadAddr dflags addr (typeWidth w)) (exprMem dflags addr)
+exprMem dflags (CmmMachOp _ es)  = foldr bothMems NoMem (map (exprMem dflags) es)
+exprMem _      _                 = NoMem
 
-loadAddr :: CmmExpr -> Width -> AbsMem
-loadAddr e w =
+loadAddr :: DynFlags -> CmmExpr -> Width -> AbsMem
+loadAddr dflags e w =
   case e of
-   CmmReg r       -> regAddr r 0 w
-   CmmRegOff r i  -> regAddr r i w
+   CmmReg r       -> regAddr dflags r 0 w
+   CmmRegOff r i  -> regAddr dflags r i w
    _other | CmmGlobal Sp `regUsedIn` e -> StackMem
           | otherwise -> AnyMem
 
-regAddr :: CmmReg -> Int -> Width -> AbsMem
-regAddr (CmmGlobal Sp) i w = SpMem i (widthInBytes w)
-regAddr (CmmGlobal Hp) _ _ = HeapMem
-regAddr r _ _ | isGcPtrType (cmmRegType r) = HeapMem -- yay! GCPtr pays for itself
-regAddr _ _ _ = AnyMem
+regAddr :: DynFlags -> CmmReg -> Int -> Width -> AbsMem
+regAddr _      (CmmGlobal Sp) i w = SpMem i (widthInBytes w)
+regAddr _      (CmmGlobal Hp) _ _ = HeapMem
+regAddr dflags r _ _ | isGcPtrType (cmmRegType dflags r) = HeapMem -- yay! GCPtr pays for itself
+regAddr _      _ _ _ = AnyMem
diff --git a/compiler/cmm/CmmType.hs b/compiler/cmm/CmmType.hs
index 63b42f83bb..db5db9bf96 100644
--- a/compiler/cmm/CmmType.hs
+++ b/compiler/cmm/CmmType.hs
@@ -18,9 +18,9 @@ where
 #include "HsVersions.h"
 
 import Constants
+import DynFlags
 import FastString
 import Outputable
-import Platform
 
 import Data.Word
 import Data.Int
@@ -96,11 +96,11 @@ f32    = cmmFloat W32
 f64    = cmmFloat W64
 
 -- CmmTypes of native word widths
-bWord :: CmmType
-bWord = cmmBits wordWidth
+bWord :: DynFlags -> CmmType
+bWord _ = cmmBits wordWidth
 
-bHalfWord :: Platform -> CmmType
-bHalfWord platform = cmmBits (halfWordWidth platform)
+bHalfWord :: DynFlags -> CmmType
+bHalfWord dflags = cmmBits (halfWordWidth dflags)
 
 gcWord :: CmmType
 gcWord = CmmType GcPtrCat wordWidth
@@ -165,13 +165,13 @@ wordWidth | wORD_SIZE == 4 = W32
           | wORD_SIZE == 8 = W64
           | otherwise      = panic "MachOp.wordRep: Unknown word size"
 
-halfWordWidth :: Platform -> Width
+halfWordWidth :: DynFlags -> Width
 halfWordWidth _
  | wORD_SIZE == 4 = W16
  | wORD_SIZE == 8 = W32
  | otherwise      = panic "MachOp.halfWordRep: Unknown word size"
 
-halfWordMask :: Platform -> Integer
+halfWordMask :: DynFlags -> Integer
 halfWordMask _
  | wORD_SIZE == 4 = 0xFFFF
  | wORD_SIZE == 8 = 0xFFFFFFFF
diff --git a/compiler/cmm/CmmUtils.hs b/compiler/cmm/CmmUtils.hs
index 6607aec33c..bc092177b1 100644
--- a/compiler/cmm/CmmUtils.hs
+++ b/compiler/cmm/CmmUtils.hs
@@ -73,6 +73,7 @@ import Outputable
 import Unique
 import UniqSupply
 import Constants( wORD_SIZE, tAG_MASK )
+import DynFlags
 import Util
 
 import Data.Word
@@ -86,19 +87,19 @@ import Hoopl
 --
 ---------------------------------------------------
 
-primRepCmmType :: PrimRep -> CmmType
-primRepCmmType VoidRep    = panic "primRepCmmType:VoidRep"
-primRepCmmType PtrRep     = gcWord
-primRepCmmType IntRep     = bWord
-primRepCmmType WordRep    = bWord
-primRepCmmType Int64Rep   = b64
-primRepCmmType Word64Rep  = b64
-primRepCmmType AddrRep    = bWord
-primRepCmmType FloatRep   = f32
-primRepCmmType DoubleRep  = f64
+primRepCmmType :: DynFlags -> PrimRep -> CmmType
+primRepCmmType _      VoidRep    = panic "primRepCmmType:VoidRep"
+primRepCmmType _      PtrRep     = gcWord
+primRepCmmType dflags IntRep     = bWord dflags
+primRepCmmType dflags WordRep    = bWord dflags
+primRepCmmType _      Int64Rep   = b64
+primRepCmmType _      Word64Rep  = b64
+primRepCmmType dflags AddrRep    = bWord dflags
+primRepCmmType _      FloatRep   = f32
+primRepCmmType _      DoubleRep  = f64
 
-typeCmmType :: UnaryType -> CmmType
-typeCmmType ty = primRepCmmType (typePrimRep ty)
+typeCmmType :: DynFlags -> UnaryType -> CmmType
+typeCmmType dflags ty = primRepCmmType dflags (typePrimRep ty)
 
 primRepForeignHint :: PrimRep -> ForeignHint
 primRepForeignHint VoidRep      = panic "primRepForeignHint:VoidRep"
@@ -182,10 +183,10 @@ packHalfWordsCLit lower_half_word upper_half_word
 mkLblExpr :: CLabel -> CmmExpr
 mkLblExpr lbl = CmmLit (CmmLabel lbl)
 
-cmmOffsetExpr :: CmmExpr -> CmmExpr -> CmmExpr
+cmmOffsetExpr :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
 -- assumes base and offset have the same CmmType
-cmmOffsetExpr e (CmmLit (CmmInt n _)) = cmmOffset e (fromInteger n)
-cmmOffsetExpr e byte_off = CmmMachOp (MO_Add (cmmExprWidth e)) [e, byte_off]
+cmmOffsetExpr dflags e (CmmLit (CmmInt n _)) = cmmOffset dflags e (fromInteger n)
+cmmOffsetExpr dflags e byte_off = CmmMachOp (MO_Add (cmmExprWidth dflags e)) [e, byte_off]
 
 -- NB. Do *not* inspect the value of the offset in these smart constructors!!!
 -- because the offset is sometimes involved in a loop in the code generator
@@ -194,18 +195,18 @@ cmmOffsetExpr e byte_off = CmmMachOp (MO_Add (cmmExprWidth e)) [e, byte_off]
 -- stage; they're eliminated later instead (either during printing or
 -- a later optimisation step on Cmm).
 --
-cmmOffset :: CmmExpr -> Int -> CmmExpr
-cmmOffset e                 0        = e
-cmmOffset (CmmReg reg)      byte_off = cmmRegOff reg byte_off
-cmmOffset (CmmRegOff reg m) byte_off = cmmRegOff reg (m+byte_off)
-cmmOffset (CmmLit lit)      byte_off = CmmLit (cmmOffsetLit lit byte_off)
-cmmOffset (CmmMachOp (MO_Add rep) [expr, CmmLit (CmmInt byte_off1 _rep)]) byte_off2
+cmmOffset :: DynFlags -> CmmExpr -> Int -> CmmExpr
+cmmOffset _ e                 0        = e
+cmmOffset _ (CmmReg reg)      byte_off = cmmRegOff reg byte_off
+cmmOffset _ (CmmRegOff reg m) byte_off = cmmRegOff reg (m+byte_off)
+cmmOffset _ (CmmLit lit)      byte_off = CmmLit (cmmOffsetLit lit byte_off)
+cmmOffset _ (CmmMachOp (MO_Add rep) [expr, CmmLit (CmmInt byte_off1 _rep)]) byte_off2
   = CmmMachOp (MO_Add rep)
               [expr, CmmLit (CmmInt (byte_off1 + toInteger byte_off2) rep)]
-cmmOffset expr byte_off
+cmmOffset dflags expr byte_off
   = CmmMachOp (MO_Add width) [expr, CmmLit (CmmInt (toInteger byte_off) width)]
   where
-    width = cmmExprWidth expr
+    width = cmmExprWidth dflags expr
 
 -- Smart constructor for CmmRegOff.  Same caveats as cmmOffset above.
 cmmRegOff :: CmmReg -> Int -> CmmExpr
@@ -224,35 +225,37 @@ cmmLabelOff lbl byte_off = CmmLabelOff lbl byte_off
 
 -- | Useful for creating an index into an array, with a staticaly known offset.
 -- The type is the element type; used for making the multiplier
-cmmIndex :: Width       -- Width w
+cmmIndex :: DynFlags
+         -> Width       -- Width w
          -> CmmExpr     -- Address of vector of items of width w
          -> Int         -- Which element of the vector (0 based)
          -> CmmExpr     -- Address of i'th element
-cmmIndex width base idx = cmmOffset base (idx * widthInBytes width)
+cmmIndex dflags width base idx = cmmOffset dflags base (idx * widthInBytes width)
 
 -- | Useful for creating an index into an array, with an unknown offset.
-cmmIndexExpr :: Width           -- Width w
+cmmIndexExpr :: DynFlags
+             -> Width           -- Width w
              -> CmmExpr         -- Address of vector of items of width w
              -> CmmExpr         -- Which element of the vector (0 based)
              -> CmmExpr         -- Address of i'th element
-cmmIndexExpr width base (CmmLit (CmmInt n _)) = cmmIndex width base (fromInteger n)
-cmmIndexExpr width base idx =
-  cmmOffsetExpr base byte_off
+cmmIndexExpr dflags width base (CmmLit (CmmInt n _)) = cmmIndex dflags width base (fromInteger n)
+cmmIndexExpr dflags width base idx =
+  cmmOffsetExpr dflags base byte_off
   where
-    idx_w = cmmExprWidth idx
+    idx_w = cmmExprWidth dflags idx
     byte_off = CmmMachOp (MO_Shl idx_w) [idx, mkIntExpr (widthInLog width)]
 
-cmmLoadIndex :: CmmType -> CmmExpr -> Int -> CmmExpr
-cmmLoadIndex ty expr ix = CmmLoad (cmmIndex (typeWidth ty) expr ix) ty
+cmmLoadIndex :: DynFlags -> CmmType -> CmmExpr -> Int -> CmmExpr
+cmmLoadIndex dflags ty expr ix = CmmLoad (cmmIndex dflags (typeWidth ty) expr ix) ty
 
 -- The "B" variants take byte offsets
 cmmRegOffB :: CmmReg -> ByteOff -> CmmExpr
 cmmRegOffB = cmmRegOff
 
-cmmOffsetB :: CmmExpr -> ByteOff -> CmmExpr
+cmmOffsetB :: DynFlags -> CmmExpr -> ByteOff -> CmmExpr
 cmmOffsetB = cmmOffset
 
-cmmOffsetExprB :: CmmExpr -> CmmExpr -> CmmExpr
+cmmOffsetExprB :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
 cmmOffsetExprB = cmmOffsetExpr
 
 cmmLabelOffB :: CLabel -> ByteOff -> CmmLit
@@ -263,13 +266,13 @@ cmmOffsetLitB = cmmOffsetLit
 
 -----------------------
 -- The "W" variants take word offsets
-cmmOffsetExprW :: CmmExpr -> CmmExpr -> CmmExpr
+cmmOffsetExprW :: DynFlags -> CmmExpr -> CmmExpr -> CmmExpr
 -- The second arg is a *word* offset; need to change it to bytes
-cmmOffsetExprW e (CmmLit (CmmInt n _)) = cmmOffsetW e (fromInteger n)
-cmmOffsetExprW e wd_off = cmmIndexExpr wordWidth e wd_off
+cmmOffsetExprW dflags  e (CmmLit (CmmInt n _)) = cmmOffsetW dflags e (fromInteger n)
+cmmOffsetExprW dflags e wd_off = cmmIndexExpr dflags wordWidth e wd_off
 
-cmmOffsetW :: CmmExpr -> WordOff -> CmmExpr
-cmmOffsetW e n = cmmOffsetB e (wORD_SIZE * n)
+cmmOffsetW :: DynFlags -> CmmExpr -> WordOff -> CmmExpr
+cmmOffsetW dflags e n = cmmOffsetB dflags e (wORD_SIZE * n)
 
 cmmRegOffW :: CmmReg -> WordOff -> CmmExpr
 cmmRegOffW reg wd_off = cmmRegOffB reg (wd_off * wORD_SIZE)
@@ -280,8 +283,8 @@ cmmOffsetLitW lit wd_off = cmmOffsetLitB lit (wORD_SIZE * wd_off)
 cmmLabelOffW :: CLabel -> WordOff -> CmmLit
 cmmLabelOffW lbl wd_off = cmmLabelOffB lbl (wORD_SIZE * wd_off)
 
-cmmLoadIndexW :: CmmExpr -> Int -> CmmType -> CmmExpr
-cmmLoadIndexW base off ty = CmmLoad (cmmOffsetW base off) ty
+cmmLoadIndexW :: DynFlags -> CmmExpr -> Int -> CmmType -> CmmExpr
+cmmLoadIndexW dflags base off ty = CmmLoad (cmmOffsetW dflags base off) ty
 
 -----------------------
 cmmULtWord, cmmUGeWord, cmmUGtWord, cmmSubWord,
@@ -302,9 +305,9 @@ cmmSubWord e1 e2 = CmmMachOp mo_wordSub [e1, e2]
 cmmMulWord e1 e2 = CmmMachOp mo_wordMul [e1, e2]
 cmmQuotWord e1 e2 = CmmMachOp mo_wordUQuot [e1, e2]
 
-cmmNegate :: CmmExpr -> CmmExpr
-cmmNegate (CmmLit (CmmInt n rep)) = CmmLit (CmmInt (-n) rep)
-cmmNegate e                       = CmmMachOp (MO_S_Neg (cmmExprWidth e)) [e]
+cmmNegate :: DynFlags -> CmmExpr -> CmmExpr
+cmmNegate _      (CmmLit (CmmInt n rep)) = CmmLit (CmmInt (-n) rep)
+cmmNegate dflags e                       = CmmMachOp (MO_S_Neg (cmmExprWidth dflags e)) [e]
 
 blankWord :: CmmStatic
 blankWord = CmmUninitialised wORD_SIZE
diff --git a/compiler/cmm/MkGraph.hs b/compiler/cmm/MkGraph.hs
index 8952ba1803..6bcdcaa966 100644
--- a/compiler/cmm/MkGraph.hs
+++ b/compiler/cmm/MkGraph.hs
@@ -367,7 +367,7 @@ copyOutOflow dflags conv transfer area actuals updfr_off
     arg_offset = init_offset + extra_stack_off
 
     args :: [(CmmExpr, ParamLocation)]   -- The argument and where to put it
-    args = assignArgumentsPos dflags conv cmmExprType actuals
+    args = assignArgumentsPos dflags conv (cmmExprType dflags) actuals
 
     args' = foldl adjust setRA args
       where adjust rst   (v, StackParam off)  = (v, StackParam (off + arg_offset)) : rst
diff --git a/compiler/cmm/OldCmmLint.hs b/compiler/cmm/OldCmmLint.hs
index 72e40ce4f8..009a7841f1 100644
--- a/compiler/cmm/OldCmmLint.hs
+++ b/compiler/cmm/OldCmmLint.hs
@@ -24,7 +24,7 @@ import Outputable
 import OldPprCmm()
 import Constants
 import FastString
-import Platform
+import DynFlags
 
 import Data.Maybe
 
@@ -32,15 +32,15 @@ import Data.Maybe
 -- Exported entry points:
 
 cmmLint :: (Outputable d, Outputable h)
-        => Platform -> GenCmmGroup d h (ListGraph CmmStmt) -> Maybe SDoc
-cmmLint platform tops = runCmmLint platform (mapM_ (lintCmmDecl platform)) tops
+        => DynFlags -> GenCmmGroup d h (ListGraph CmmStmt) -> Maybe SDoc
+cmmLint dflags tops = runCmmLint dflags (mapM_ (lintCmmDecl dflags)) tops
 
 cmmLintTop :: (Outputable d, Outputable h)
-           => Platform -> GenCmmDecl d h (ListGraph CmmStmt) -> Maybe SDoc
-cmmLintTop platform top = runCmmLint platform (lintCmmDecl platform) top
+           => DynFlags -> GenCmmDecl d h (ListGraph CmmStmt) -> Maybe SDoc
+cmmLintTop dflags top = runCmmLint dflags (lintCmmDecl dflags) top
 
 runCmmLint :: Outputable a
-           => Platform -> (a -> CmmLint b) -> a -> Maybe SDoc
+           => DynFlags -> (a -> CmmLint b) -> a -> Maybe SDoc
 runCmmLint _ l p =
    case unCL (l p) of
    Left err -> Just (vcat [ptext $ sLit ("Cmm lint error:"),
@@ -49,19 +49,20 @@ runCmmLint _ l p =
                            nest 2 (ppr p)])
    Right _  -> Nothing
 
-lintCmmDecl :: Platform -> (GenCmmDecl h i (ListGraph CmmStmt)) -> CmmLint ()
-lintCmmDecl platform (CmmProc _ lbl (ListGraph blocks))
+lintCmmDecl :: DynFlags -> (GenCmmDecl h i (ListGraph CmmStmt)) -> CmmLint ()
+lintCmmDecl dflags (CmmProc _ lbl (ListGraph blocks))
   = addLintInfo (text "in proc " <> pprCLabel platform lbl) $
         let labels = foldl (\s b -> setInsert (blockId b) s) setEmpty blocks
-	in  mapM_ (lintCmmBlock platform labels) blocks
+        in  mapM_ (lintCmmBlock dflags labels) blocks
+    where platform = targetPlatform dflags
 
 lintCmmDecl _ (CmmData {})
   = return ()
 
-lintCmmBlock :: Platform -> BlockSet -> GenBasicBlock CmmStmt -> CmmLint ()
-lintCmmBlock platform labels (BasicBlock id stmts)
+lintCmmBlock :: DynFlags -> BlockSet -> GenBasicBlock CmmStmt -> CmmLint ()
+lintCmmBlock dflags labels (BasicBlock id stmts)
   = addLintInfo (text "in basic block " <> ppr id) $
-	mapM_ (lintCmmStmt platform labels) stmts
+	mapM_ (lintCmmStmt dflags labels) stmts
 
 -- -----------------------------------------------------------------------------
 -- lintCmmExpr
@@ -69,32 +70,32 @@ lintCmmBlock platform labels (BasicBlock id stmts)
 -- Checks whether a CmmExpr is "type-correct", and check for obvious-looking
 -- byte/word mismatches.
 
-lintCmmExpr :: Platform -> CmmExpr -> CmmLint CmmType
-lintCmmExpr platform (CmmLoad expr rep) = do
-  _ <- lintCmmExpr platform expr
+lintCmmExpr :: DynFlags -> CmmExpr -> CmmLint CmmType
+lintCmmExpr dflags (CmmLoad expr rep) = do
+  _ <- lintCmmExpr dflags expr
   -- Disabled, if we have the inlining phase before the lint phase,
   -- we can have funny offsets due to pointer tagging. -- EZY
   -- when (widthInBytes (typeWidth rep) >= wORD_SIZE) $
   --   cmmCheckWordAddress expr
   return rep
-lintCmmExpr platform expr@(CmmMachOp op args) = do
-  tys <- mapM (lintCmmExpr platform) args
-  if map (typeWidth . cmmExprType) args == machOpArgReps op
-  	then cmmCheckMachOp op args tys
-	else cmmLintMachOpErr expr (map cmmExprType args) (machOpArgReps op)
-lintCmmExpr platform (CmmRegOff reg offset)
-  = lintCmmExpr platform (CmmMachOp (MO_Add rep)
+lintCmmExpr dflags expr@(CmmMachOp op args) = do
+  tys <- mapM (lintCmmExpr dflags) args
+  if map (typeWidth . cmmExprType dflags) args == machOpArgReps op
+  	then cmmCheckMachOp dflags op args tys
+	else cmmLintMachOpErr expr (map (cmmExprType dflags) args) (machOpArgReps op)
+lintCmmExpr dflags (CmmRegOff reg offset)
+  = lintCmmExpr dflags (CmmMachOp (MO_Add rep)
 		[CmmReg reg, CmmLit (CmmInt (fromIntegral offset) rep)])
-  where rep = typeWidth (cmmRegType reg)
-lintCmmExpr _ expr =
-  return (cmmExprType expr)
+  where rep = typeWidth (cmmRegType dflags reg)
+lintCmmExpr dflags expr =
+  return (cmmExprType dflags expr)
 
 -- Check for some common byte/word mismatches (eg. Sp + 1)
-cmmCheckMachOp   :: MachOp -> [CmmExpr] -> [CmmType] -> CmmLint CmmType
-cmmCheckMachOp op [lit@(CmmLit (CmmInt { })), reg@(CmmReg _)] tys
-  = cmmCheckMachOp op [reg, lit] tys
-cmmCheckMachOp op _ tys
-  = return (machOpResultType op tys)
+cmmCheckMachOp   :: DynFlags -> MachOp -> [CmmExpr] -> [CmmType] -> CmmLint CmmType
+cmmCheckMachOp dflags op [lit@(CmmLit (CmmInt { })), reg@(CmmReg _)] tys
+  = cmmCheckMachOp dflags op [reg, lit] tys
+cmmCheckMachOp dflags op _ tys
+  = return (machOpResultType dflags op tys)
 
 isOffsetOp :: MachOp -> Bool
 isOffsetOp (MO_Add _) = True
@@ -119,43 +120,43 @@ notNodeReg :: CmmExpr -> Bool
 notNodeReg (CmmReg reg) | reg == nodeReg = False
 notNodeReg _                             = True
 
-lintCmmStmt :: Platform -> BlockSet -> CmmStmt -> CmmLint ()
-lintCmmStmt platform labels = lint
+lintCmmStmt :: DynFlags -> BlockSet -> CmmStmt -> CmmLint ()
+lintCmmStmt dflags labels = lint
     where lint (CmmNop) = return ()
           lint (CmmComment {}) = return ()
           lint stmt@(CmmAssign reg expr) = do
-            erep <- lintCmmExpr platform expr
-	    let reg_ty = cmmRegType reg
+            erep <- lintCmmExpr dflags expr
+            let reg_ty = cmmRegType dflags reg
             if (erep `cmmEqType_ignoring_ptrhood` reg_ty)
                 then return ()
                 else cmmLintAssignErr stmt erep reg_ty
           lint (CmmStore l r) = do
-            _ <- lintCmmExpr platform l
-            _ <- lintCmmExpr platform r
+            _ <- lintCmmExpr dflags l
+            _ <- lintCmmExpr dflags r
             return ()
           lint (CmmCall target _res args _) =
-              do lintTarget platform labels target
-                 mapM_ (lintCmmExpr platform . hintlessCmm) args
-          lint (CmmCondBranch e id) = checkTarget id >> lintCmmExpr platform e >> checkCond e
+              do lintTarget dflags labels target
+                 mapM_ (lintCmmExpr dflags . hintlessCmm) args
+          lint (CmmCondBranch e id) = checkTarget id >> lintCmmExpr dflags e >> checkCond e
           lint (CmmSwitch e branches) = do
             mapM_ checkTarget $ catMaybes branches
-            erep <- lintCmmExpr platform e
-            if (erep `cmmEqType_ignoring_ptrhood` bWord)
+            erep <- lintCmmExpr dflags e
+            if (erep `cmmEqType_ignoring_ptrhood` bWord dflags)
               then return ()
               else cmmLintErr (text "switch scrutinee is not a word: " <> ppr e <>
                                text " :: " <> ppr erep)
-          lint (CmmJump e _) = lintCmmExpr platform e >> return ()
+          lint (CmmJump e _) = lintCmmExpr dflags e >> return ()
           lint (CmmReturn) = return ()
           lint (CmmBranch id)    = checkTarget id
           checkTarget id = if setMember id labels then return ()
                            else cmmLintErr (text "Branch to nonexistent id" <+> ppr id)
 
-lintTarget :: Platform -> BlockSet -> CmmCallTarget -> CmmLint ()
-lintTarget platform _      (CmmCallee e _) = do _ <- lintCmmExpr platform e
-                                                return ()
-lintTarget _        _      (CmmPrim _ Nothing) = return ()
-lintTarget platform labels (CmmPrim _ (Just stmts))
-    = mapM_ (lintCmmStmt platform labels) stmts
+lintTarget :: DynFlags -> BlockSet -> CmmCallTarget -> CmmLint ()
+lintTarget dflags _      (CmmCallee e _) = do _ <- lintCmmExpr dflags e
+                                              return ()
+lintTarget _      _      (CmmPrim _ Nothing) = return ()
+lintTarget dflags labels (CmmPrim _ (Just stmts))
+    = mapM_ (lintCmmStmt dflags labels) stmts
 
 
 checkCond :: CmmExpr -> CmmLint ()
diff --git a/compiler/cmm/OldCmmUtils.hs b/compiler/cmm/OldCmmUtils.hs
index 0ec7a25f15..fe6ccee642 100644
--- a/compiler/cmm/OldCmmUtils.hs
+++ b/compiler/cmm/OldCmmUtils.hs
@@ -20,6 +20,7 @@ module OldCmmUtils(
 import OldCmm
 import CmmUtils
 import OrdList
+import DynFlags
 import Unique
 
 ---------------------------------------------------
@@ -77,23 +78,23 @@ cheapEqReg _ _                = False
 --
 ---------------------------------------------------
 
-loadArgsIntoTemps :: [Unique]
+loadArgsIntoTemps :: DynFlags -> [Unique]
                   -> [HintedCmmActual]
                   -> ([Unique], [CmmStmt], [HintedCmmActual])
-loadArgsIntoTemps uniques [] = (uniques, [], [])
-loadArgsIntoTemps uniques ((CmmHinted e hint):args) =
+loadArgsIntoTemps _      uniques [] = (uniques, [], [])
+loadArgsIntoTemps dflags uniques ((CmmHinted e hint):args) =
     (uniques'',
      new_stmts ++ remaining_stmts,
      (CmmHinted new_e hint) : remaining_e)
     where
-      (uniques', new_stmts, new_e) = maybeAssignTemp uniques e
+      (uniques', new_stmts, new_e) = maybeAssignTemp dflags uniques e
       (uniques'', remaining_stmts, remaining_e) =
-          loadArgsIntoTemps uniques' args
+          loadArgsIntoTemps dflags uniques' args
 
 
-maybeAssignTemp :: [Unique] -> CmmExpr -> ([Unique], [CmmStmt], CmmExpr)
-maybeAssignTemp uniques e
+maybeAssignTemp :: DynFlags -> [Unique] -> CmmExpr -> ([Unique], [CmmStmt], CmmExpr)
+maybeAssignTemp dflags uniques e
     | hasNoGlobalRegs e = (uniques, [], e)
     | otherwise         = (tail uniques, [CmmAssign local e], CmmReg local)
-    where local = CmmLocal (LocalReg (head uniques) (cmmExprType e))
+    where local = CmmLocal (LocalReg (head uniques) (cmmExprType dflags e))
 
diff --git a/compiler/cmm/OldPprCmm.hs b/compiler/cmm/OldPprCmm.hs
index 9605cb9bdf..a3857d4e47 100644
--- a/compiler/cmm/OldPprCmm.hs
+++ b/compiler/cmm/OldPprCmm.hs
@@ -93,9 +93,10 @@ pprStmt stmt = case stmt of
     CmmAssign reg expr -> ppr reg <+> equals <+> ppr expr <> semi
 
     -- rep[lv] = expr;
-    CmmStore lv expr -> rep <> brackets(ppr lv) <+> equals <+> ppr expr <> semi
-        where
-          rep = ppr ( cmmExprType expr )
+    CmmStore lv expr ->
+        sdocWithDynFlags $ \dflags ->
+        let rep = ppr ( cmmExprType dflags expr )
+        in rep <> brackets(ppr lv) <+> equals <+> ppr expr <> semi
 
     -- call "ccall" foo(x, y)[r1, r2];
     -- ToDo ppr volatile
diff --git a/compiler/cmm/PprC.hs b/compiler/cmm/PprC.hs
index dd71ac655e..01c64dae60 100644
--- a/compiler/cmm/PprC.hs
+++ b/compiler/cmm/PprC.hs
@@ -167,7 +167,9 @@ pprLocalness lbl | not $ externallyVisibleCLabel lbl = ptext (sLit "static ")
 
 pprStmt :: CmmStmt -> SDoc
 
-pprStmt stmt = case stmt of
+pprStmt stmt =
+    sdocWithDynFlags $ \dflags ->
+    case stmt of
     CmmReturn    -> panic "pprStmt: return statement should have been cps'd away"
     CmmNop       -> empty
     CmmComment _ -> empty -- (hang (ptext (sLit "/*")) 3 (ftext s)) $$ ptext (sLit "*/")
@@ -187,7 +189,7 @@ pprStmt stmt = case stmt of
         | otherwise
         -> hsep [ pprExpr (CmmLoad dest rep), equals, pprExpr src <> semi ]
         where
-          rep = cmmExprType src
+          rep = cmmExprType dflags src
 
     CmmCall (CmmCallee fn cconv) results args ret ->
         maybe_proto $$
@@ -262,15 +264,15 @@ pprForeignCall fn cconv results args = (proto, fn_call)
 
 pprCFunType :: SDoc -> CCallConv -> [HintedCmmFormal] -> [HintedCmmActual] -> SDoc
 pprCFunType ppr_fn cconv ress args
-  = res_type ress <+>
-    parens (ccallConvAttribute cconv <> ppr_fn) <>
-    parens (commafy (map arg_type args))
-  where
-        res_type [] = ptext (sLit "void")
+  = sdocWithDynFlags $ \dflags ->
+    let res_type [] = ptext (sLit "void")
         res_type [CmmHinted one hint] = machRepHintCType (localRegType one) hint
         res_type _ = panic "pprCFunType: only void or 1 return value supported"
 
-        arg_type (CmmHinted expr hint) = machRepHintCType (cmmExprType expr) hint
+        arg_type (CmmHinted expr hint) = machRepHintCType (cmmExprType dflags expr) hint
+    in res_type ress <+>
+       parens (ccallConvAttribute cconv <> ppr_fn) <>
+       parens (commafy (map arg_type args))
 
 -- ---------------------------------------------------------------------
 -- unconditional branches
@@ -423,8 +425,10 @@ pprMachOpApp' mop args
 
   where
         -- Cast needed for signed integer ops
-    pprArg e | signedOp    mop = cCast (machRep_S_CType (typeWidth (cmmExprType e))) e
-             | needsFCasts mop = cCast (machRep_F_CType (typeWidth (cmmExprType e))) e
+    pprArg e | signedOp    mop = sdocWithDynFlags $ \dflags ->
+                                 cCast (machRep_S_CType (typeWidth (cmmExprType dflags e))) e
+             | needsFCasts mop = sdocWithDynFlags $ \dflags ->
+                                 cCast (machRep_F_CType (typeWidth (cmmExprType dflags e))) e
              | otherwise    = pprExpr1 e
     needsFCasts (MO_F_Eq _)   = False
     needsFCasts (MO_F_Ne _)   = False
@@ -480,7 +484,8 @@ pprStatics (CmmStaticLit (CmmFloat f W32) : rest)
   = pprLit1 (floatToWord f) : pprStatics rest
   | otherwise
   = pprPanic "pprStatics: float" (vcat (map ppr' rest))
-    where ppr' (CmmStaticLit l) = ppr (cmmLitType l)
+    where ppr' (CmmStaticLit l) = sdocWithDynFlags $ \dflags ->
+                                  ppr (cmmLitType dflags l)
           ppr' _other           = ptext (sLit "bad static!")
 pprStatics (CmmStaticLit (CmmFloat f W64) : rest)
   = map pprLit1 (doubleToWords f) ++ pprStatics rest
@@ -846,7 +851,8 @@ pprCall ppr_fn cconv results args
         = cCast (ptext (sLit "void *")) expr
         -- see comment by machRepHintCType below
      pprArg (CmmHinted expr SignedHint)
-        = cCast (machRep_S_CType $ typeWidth $ cmmExprType expr) expr
+        = sdocWithDynFlags $ \dflags ->
+          cCast (machRep_S_CType $ typeWidth $ cmmExprType dflags expr) expr
      pprArg (CmmHinted expr _other)
         = pprExpr expr
 
diff --git a/compiler/cmm/PprCmm.hs b/compiler/cmm/PprCmm.hs
index 58866979f8..423bcd5504 100644
--- a/compiler/cmm/PprCmm.hs
+++ b/compiler/cmm/PprCmm.hs
@@ -185,7 +185,8 @@ pprNode node = pp_node <+> pp_debug
       -- rep[lv] = expr;
       CmmStore lv expr -> rep <> brackets(ppr lv) <+> equals <+> ppr expr <> semi
           where
-            rep = ppr ( cmmExprType expr )
+            rep = sdocWithDynFlags $ \dflags ->
+                  ppr ( cmmExprType dflags expr )
 
       -- call "ccall" foo(x, y)[r1, r2];
       -- ToDo ppr volatile
diff --git a/compiler/cmm/PprCmmExpr.hs b/compiler/cmm/PprCmmExpr.hs
index 2f25b028d1..2c481c38a2 100644
--- a/compiler/cmm/PprCmmExpr.hs
+++ b/compiler/cmm/PprCmmExpr.hs
@@ -73,11 +73,12 @@ instance Outputable GlobalReg where
 
 pprExpr :: CmmExpr -> SDoc
 pprExpr e
-    = case e of
+    = sdocWithDynFlags $ \dflags ->
+      case e of
         CmmRegOff reg i ->
                 pprExpr (CmmMachOp (MO_Add rep)
                            [CmmReg reg, CmmLit (CmmInt (fromIntegral i) rep)])
-                where rep = typeWidth (cmmRegType reg)
+                where rep = typeWidth (cmmRegType dflags reg)
         CmmLit lit -> pprLit lit
         _other     -> pprExpr1 e