Pass DynFlags down to wordWidth

1 files changed, 31 insertions, 27 deletions

diff --git a/compiler/codeGen/StgCmmUtils.hs b/compiler/codeGen/StgCmmUtils.hs
index b402199ac4..1b934df9f7 100644
--- a/compiler/codeGen/StgCmmUtils.hs
+++ b/compiler/codeGen/StgCmmUtils.hs
@@ -86,31 +86,32 @@ import Data.Maybe
 cgLit :: Literal -> FCode CmmLit
 cgLit (MachStr s) = newByteStringCLit (bytesFB s)
  -- not unpackFS; we want the UTF-8 byte stream.
-cgLit other_lit   = return (mkSimpleLit other_lit)
+cgLit other_lit   = do dflags <- getDynFlags
+                       return (mkSimpleLit dflags other_lit)
 
 mkLtOp :: DynFlags -> Literal -> MachOp
 -- On signed literals we must do a signed comparison
-mkLtOp _      (MachInt _)    = MO_S_Lt wordWidth
+mkLtOp dflags (MachInt _)    = MO_S_Lt (wordWidth dflags)
 mkLtOp _      (MachFloat _)  = MO_F_Lt W32
 mkLtOp _      (MachDouble _) = MO_F_Lt W64
-mkLtOp dflags lit            = MO_U_Lt (typeWidth (cmmLitType dflags (mkSimpleLit lit)))
+mkLtOp dflags lit            = MO_U_Lt (typeWidth (cmmLitType dflags (mkSimpleLit dflags lit)))
                                 -- ToDo: seems terribly indirect!
 
-mkSimpleLit :: Literal -> CmmLit
-mkSimpleLit (MachChar   c)    = CmmInt (fromIntegral (ord c)) wordWidth
-mkSimpleLit MachNullAddr      = zeroCLit
-mkSimpleLit (MachInt i)       = CmmInt i wordWidth
-mkSimpleLit (MachInt64 i)     = CmmInt i W64
-mkSimpleLit (MachWord i)      = CmmInt i wordWidth
-mkSimpleLit (MachWord64 i)    = CmmInt i W64
-mkSimpleLit (MachFloat r)     = CmmFloat r W32
-mkSimpleLit (MachDouble r)    = CmmFloat r W64
-mkSimpleLit (MachLabel fs ms fod)
+mkSimpleLit :: DynFlags -> Literal -> CmmLit
+mkSimpleLit dflags (MachChar   c)    = CmmInt (fromIntegral (ord c)) (wordWidth dflags)
+mkSimpleLit dflags MachNullAddr      = zeroCLit dflags
+mkSimpleLit dflags (MachInt i)       = CmmInt i (wordWidth dflags)
+mkSimpleLit _      (MachInt64 i)     = CmmInt i W64
+mkSimpleLit dflags (MachWord i)      = CmmInt i (wordWidth dflags)
+mkSimpleLit _      (MachWord64 i)    = CmmInt i W64
+mkSimpleLit _      (MachFloat r)     = CmmFloat r W32
+mkSimpleLit _      (MachDouble r)    = CmmFloat r W64
+mkSimpleLit _      (MachLabel fs ms fod)
         = CmmLabel (mkForeignLabel fs ms labelSrc fod)
         where
                 -- TODO: Literal labels might not actually be in the current package...
                 labelSrc = ForeignLabelInThisPackage
-mkSimpleLit other             = pprPanic "mkSimpleLit" (ppr other)
+mkSimpleLit _ other             = pprPanic "mkSimpleLit" (ppr other)
 
 --------------------------------------------------------------------------
 --
@@ -514,11 +515,11 @@ mk_switch _tag_expr [(_tag,lbl)] Nothing _ _ _
 
 -- SINGLETON BRANCH: one equality check to do
 mk_switch tag_expr [(tag,lbl)] (Just deflt) _ _ _
-  = return (mkCbranch cond deflt lbl)
-  where
-    cond =  cmmNeWord tag_expr (mkIntExpr tag)
-        -- We have lo_tag < hi_tag, but there's only one branch,
-        -- so there must be a default
+  = do dflags <- getDynFlags
+       let cond =  cmmNeWord dflags tag_expr (mkIntExpr dflags tag)
+            -- We have lo_tag < hi_tag, but there's only one branch,
+            -- so there must be a default
+       return (mkCbranch cond deflt lbl)
 
 -- ToDo: we might want to check for the two branch case, where one of
 -- the branches is the tag 0, because comparing '== 0' is likely to be
@@ -551,28 +552,31 @@ mk_switch tag_expr branches mb_deflt lo_tag hi_tag via_C
 
   -- if we can knock off a bunch of default cases with one if, then do so
   | Just deflt <- mb_deflt, (lowest_branch - lo_tag) >= n_branches
-  = do stmts <- mk_switch tag_expr branches mb_deflt
+  = do dflags <- getDynFlags
+       stmts <- mk_switch tag_expr branches mb_deflt
                         lowest_branch hi_tag via_C
        mkCmmIfThenElse
-        (cmmULtWord tag_expr (mkIntExpr lowest_branch))
+        (cmmULtWord dflags tag_expr (mkIntExpr dflags lowest_branch))
         (mkBranch deflt)
         stmts
 
   | Just deflt <- mb_deflt, (hi_tag - highest_branch) >= n_branches
-  = do stmts <- mk_switch tag_expr branches mb_deflt
+  = do dflags <- getDynFlags
+       stmts <- mk_switch tag_expr branches mb_deflt
                         lo_tag highest_branch via_C
        mkCmmIfThenElse
-        (cmmUGtWord tag_expr (mkIntExpr highest_branch))
+        (cmmUGtWord dflags tag_expr (mkIntExpr dflags highest_branch))
         (mkBranch deflt)
         stmts
 
   | otherwise   -- Use an if-tree
-  = do lo_stmts <- mk_switch tag_expr lo_branches mb_deflt
+  = do dflags <- getDynFlags
+       lo_stmts <- mk_switch tag_expr lo_branches mb_deflt
                              lo_tag (mid_tag-1) via_C
        hi_stmts <- mk_switch tag_expr hi_branches mb_deflt
                              mid_tag hi_tag via_C
        mkCmmIfThenElse
-        (cmmUGeWord tag_expr (mkIntExpr mid_tag))
+        (cmmUGeWord dflags tag_expr (mkIntExpr dflags mid_tag))
         hi_stmts
         lo_stmts
         -- we test (e >= mid_tag) rather than (e < mid_tag), because
@@ -656,7 +660,7 @@ mk_lit_switch scrut deflt [(lit,blk)]
   = do
   dflags <- getDynFlags
   let
-    cmm_lit = mkSimpleLit lit
+    cmm_lit = mkSimpleLit dflags lit
     cmm_ty  = cmmLitType dflags cmm_lit
     rep     = typeWidth cmm_ty
     ne      = if isFloatType cmm_ty then MO_F_Ne rep else MO_Ne rep
@@ -676,7 +680,7 @@ mk_lit_switch scrut deflt_blk_id branches
     is_lo (t,_) = t < mid_lit
 
     cond dflags = CmmMachOp (mkLtOp dflags mid_lit)
-                            [scrut, CmmLit (mkSimpleLit mid_lit)]
+                            [scrut, CmmLit (mkSimpleLit dflags mid_lit)]
 
 
 --------------