import CmmExpr
import CmmUtils
import CLabel
-import MachOp
import StaticFlags
import UniqFM
cmmMiniInlineStmts :: UniqFM Int -> [CmmStmt] -> [CmmStmt]
cmmMiniInlineStmts uses [] = []
-cmmMiniInlineStmts uses (stmt@(CmmAssign (CmmLocal (LocalReg u _ _)) expr) : stmts)
+cmmMiniInlineStmts uses (stmt@(CmmAssign (CmmLocal (LocalReg u _)) expr) : stmts)
-- not used at all: just discard this assignment
| Nothing <- lookupUFM uses u
= cmmMiniInlineStmts uses stmts
cmmMiniInlineStmts uses (stmt:stmts)
= stmt : cmmMiniInlineStmts uses stmts
+lookForInline u expr (stmt : rest)
+ | Just 1 <- lookupUFM (countUses stmt) u, ok_to_inline
+ = Just (inlineStmt u expr stmt : rest)
--- Try to inline a temporary assignment. We can skip over assignments to
--- other tempoararies, because we know that expressions aren't side-effecting
--- and temporaries are single-assignment.
-lookForInline u expr (stmt@(CmmAssign (CmmLocal (LocalReg u' _ _)) rhs) : rest)
- | u /= u'
- = case lookupUFM (countUses rhs) u of
- Just 1 -> Just (inlineStmt u expr stmt : rest)
- _other -> case lookForInline u expr rest of
- Nothing -> Nothing
- Just stmts -> Just (stmt:stmts)
+ | ok_to_skip
+ = case lookForInline u expr rest of
+ Nothing -> Nothing
+ Just stmts -> Just (stmt:stmts)
-lookForInline u expr (CmmNop : rest)
- = lookForInline u expr rest
+ | otherwise
+ = Nothing
-lookForInline _ _ [] = Nothing
-
-lookForInline u expr (stmt:stmts)
- = case lookupUFM (countUses stmt) u of
- Just 1 | ok_to_inline -> Just (inlineStmt u expr stmt : stmts)
- _other -> Nothing
where
-- we don't inline into CmmCall if the expression refers to global
-- registers. This is a HACK to avoid global registers clashing with
CmmCall{} -> hasNoGlobalRegs expr
_ -> True
+ -- We can skip over assignments to other tempoararies, because we
+ -- know that expressions aren't side-effecting and temporaries are
+ -- single-assignment.
+ ok_to_skip = case stmt of
+ CmmNop -> True
+ CmmAssign (CmmLocal (LocalReg u' _)) rhs | u' /= u -> True
+ CmmAssign g@(CmmGlobal _) rhs -> not (g `regUsedIn` expr)
+ _other -> False
+
+
inlineStmt :: Unique -> CmmExpr -> CmmStmt -> CmmStmt
inlineStmt u a (CmmAssign r e) = CmmAssign r (inlineExpr u a e)
inlineStmt u a (CmmStore e1 e2) = CmmStore (inlineExpr u a e1) (inlineExpr u a e2)
inlineStmt u a other_stmt = other_stmt
inlineExpr :: Unique -> CmmExpr -> CmmExpr -> CmmExpr
-inlineExpr u a e@(CmmReg (CmmLocal (LocalReg u' _ _)))
+inlineExpr u a e@(CmmReg (CmmLocal (LocalReg u' _)))
| u == u' = a
| otherwise = e
-inlineExpr u a e@(CmmRegOff (CmmLocal (LocalReg u' rep _)) off)
- | u == u' = CmmMachOp (MO_Add rep) [a, CmmLit (CmmInt (fromIntegral off) rep)]
+inlineExpr u a e@(CmmRegOff (CmmLocal (LocalReg u' rep)) off)
+ | u == u' = CmmMachOp (MO_Add width) [a, CmmLit (CmmInt (fromIntegral off) width)]
| otherwise = e
+ where
+ width = typeWidth rep
inlineExpr u a (CmmLoad e rep) = CmmLoad (inlineExpr u a e) rep
inlineExpr u a (CmmMachOp op es) = CmmMachOp op (map (inlineExpr u a) es)
inlineExpr u a other_expr = other_expr
-- "from" type, in order to truncate to the correct size.
-- The final narrow/widen to the destination type
-- is implicit in the CmmLit.
- MO_S_Conv from to
- | isFloatingRep to -> CmmLit (CmmFloat (fromInteger x) to)
- | otherwise -> CmmLit (CmmInt (narrowS from x) to)
- MO_U_Conv from to -> CmmLit (CmmInt (narrowU from x) to)
+ MO_SF_Conv from to -> CmmLit (CmmFloat (fromInteger x) to)
+ MO_SS_Conv from to -> CmmLit (CmmInt (narrowS from x) to)
+ MO_UU_Conv from to -> CmmLit (CmmInt (narrowU from x) to)
_ -> panic "cmmMachOpFold: unknown unary op"
-- Eliminate conversion NOPs
-cmmMachOpFold (MO_S_Conv rep1 rep2) [x] | rep1 == rep2 = x
-cmmMachOpFold (MO_U_Conv rep1 rep2) [x] | rep1 == rep2 = x
+cmmMachOpFold (MO_SS_Conv rep1 rep2) [x] | rep1 == rep2 = x
+cmmMachOpFold (MO_UU_Conv rep1 rep2) [x] | rep1 == rep2 = x
-- Eliminate nested conversions where possible
cmmMachOpFold conv_outer args@[CmmMachOp conv_inner [x]]
cmmMachOpFold (intconv signed1 rep1 rep3) [x]
-- Nested narrowings: collapse
| rep1 > rep2 && rep2 > rep3 ->
- cmmMachOpFold (MO_U_Conv rep1 rep3) [x]
+ cmmMachOpFold (MO_UU_Conv rep1 rep3) [x]
| otherwise ->
CmmMachOp conv_outer args
where
- isIntConversion (MO_U_Conv rep1 rep2)
- | not (isFloatingRep rep1) && not (isFloatingRep rep2)
+ isIntConversion (MO_UU_Conv rep1 rep2)
= Just (rep1,rep2,False)
- isIntConversion (MO_S_Conv rep1 rep2)
- | not (isFloatingRep rep1) && not (isFloatingRep rep2)
+ isIntConversion (MO_SS_Conv rep1 rep2)
= Just (rep1,rep2,True)
isIntConversion _ = Nothing
- intconv True = MO_S_Conv
- intconv False = MO_U_Conv
+ intconv True = MO_SS_Conv
+ intconv False = MO_UU_Conv
-- ToDo: a narrow of a load can be collapsed into a narrow load, right?
-- but what if the architecture only supports word-sized loads, should
= case mop of
-- for comparisons: don't forget to narrow the arguments before
-- comparing, since they might be out of range.
- MO_Eq r -> CmmLit (CmmInt (if x_u == y_u then 1 else 0) wordRep)
- MO_Ne r -> CmmLit (CmmInt (if x_u /= y_u then 1 else 0) wordRep)
+ MO_Eq r -> CmmLit (CmmInt (if x_u == y_u then 1 else 0) wordWidth)
+ MO_Ne r -> CmmLit (CmmInt (if x_u /= y_u then 1 else 0) wordWidth)
- MO_U_Gt r -> CmmLit (CmmInt (if x_u > y_u then 1 else 0) wordRep)
- MO_U_Ge r -> CmmLit (CmmInt (if x_u >= y_u then 1 else 0) wordRep)
- MO_U_Lt r -> CmmLit (CmmInt (if x_u < y_u then 1 else 0) wordRep)
- MO_U_Le r -> CmmLit (CmmInt (if x_u <= y_u then 1 else 0) wordRep)
+ MO_U_Gt r -> CmmLit (CmmInt (if x_u > y_u then 1 else 0) wordWidth)
+ MO_U_Ge r -> CmmLit (CmmInt (if x_u >= y_u then 1 else 0) wordWidth)
+ MO_U_Lt r -> CmmLit (CmmInt (if x_u < y_u then 1 else 0) wordWidth)
+ MO_U_Le r -> CmmLit (CmmInt (if x_u <= y_u then 1 else 0) wordWidth)
- MO_S_Gt r -> CmmLit (CmmInt (if x_s > y_s then 1 else 0) wordRep)
- MO_S_Ge r -> CmmLit (CmmInt (if x_s >= y_s then 1 else 0) wordRep)
- MO_S_Lt r -> CmmLit (CmmInt (if x_s < y_s then 1 else 0) wordRep)
- MO_S_Le r -> CmmLit (CmmInt (if x_s <= y_s then 1 else 0) wordRep)
+ MO_S_Gt r -> CmmLit (CmmInt (if x_s > y_s then 1 else 0) wordWidth)
+ MO_S_Ge r -> CmmLit (CmmInt (if x_s >= y_s then 1 else 0) wordWidth)
+ MO_S_Lt r -> CmmLit (CmmInt (if x_s < y_s then 1 else 0) wordWidth)
+ MO_S_Le r -> CmmLit (CmmInt (if x_s <= y_s then 1 else 0) wordWidth)
MO_Add r -> CmmLit (CmmInt (x + y) r)
MO_Sub r -> CmmLit (CmmInt (x - y) r)
= CmmLit (CmmLabelOff lbl (fromIntegral (negate (narrowU rep i))))
--- Comparison of literal with narrowed/widened operand: perform
--- the comparison at a different width, as long as the literal is
--- within range.
+-- Comparison of literal with widened operand: perform the comparison
+-- at the smaller width, as long as the literal is within range.
+
+-- We can't do the reverse trick, when the operand is narrowed:
+-- narrowing throws away bits from the operand, there's no way to do
+-- the same comparison at the larger size.
#if i386_TARGET_ARCH || x86_64_TARGET_ARCH
-- powerPC NCG has a TODO for I8/I16 comparisons, so don't try
cmmMachOpFold cmp [CmmMachOp conv [x], CmmLit (CmmInt i _)]
- | Just (rep, narrow) <- maybe_conversion conv,
- Just narrow_cmp <- maybe_comparison cmp rep,
- let narrow_i = narrow rep i,
- narrow_i == i
- = cmmMachOpFold narrow_cmp [x, CmmLit (CmmInt narrow_i rep)]
+ | -- if the operand is widened:
+ Just (rep, signed, narrow_fn) <- maybe_conversion conv,
+ -- and this is a comparison operation:
+ Just narrow_cmp <- maybe_comparison cmp rep signed,
+ -- and the literal fits in the smaller size:
+ i == narrow_fn rep i
+ -- then we can do the comparison at the smaller size
+ = cmmMachOpFold narrow_cmp [x, CmmLit (CmmInt i rep)]
where
- maybe_conversion (MO_U_Conv from _) = Just (from, narrowU)
- maybe_conversion (MO_S_Conv from _)
- | not (isFloatingRep from) = Just (from, narrowS)
+ maybe_conversion (MO_UU_Conv from to)
+ | to > from
+ = Just (from, False, narrowU)
+ maybe_conversion (MO_SS_Conv from to)
+ | to > from
+ = Just (from, True, narrowS)
+
-- don't attempt to apply this optimisation when the source
-- is a float; see #1916
maybe_conversion _ = Nothing
- maybe_comparison (MO_U_Gt _) rep = Just (MO_U_Gt rep)
- maybe_comparison (MO_U_Ge _) rep = Just (MO_U_Ge rep)
- maybe_comparison (MO_U_Lt _) rep = Just (MO_U_Lt rep)
- maybe_comparison (MO_U_Le _) rep = Just (MO_U_Le rep)
- maybe_comparison (MO_S_Gt _) rep = Just (MO_S_Gt rep)
- maybe_comparison (MO_S_Ge _) rep = Just (MO_S_Ge rep)
- maybe_comparison (MO_S_Lt _) rep = Just (MO_S_Lt rep)
- maybe_comparison (MO_S_Le _) rep = Just (MO_S_Le rep)
- maybe_comparison (MO_Eq _) rep = Just (MO_Eq rep)
- maybe_comparison _ _ = Nothing
+ -- careful (#2080): if the original comparison was signed, but
+ -- we were doing an unsigned widen, then we must do an
+ -- unsigned comparison at the smaller size.
+ maybe_comparison (MO_U_Gt _) rep _ = Just (MO_U_Gt rep)
+ maybe_comparison (MO_U_Ge _) rep _ = Just (MO_U_Ge rep)
+ maybe_comparison (MO_U_Lt _) rep _ = Just (MO_U_Lt rep)
+ maybe_comparison (MO_U_Le _) rep _ = Just (MO_U_Le rep)
+ maybe_comparison (MO_Eq _) rep _ = Just (MO_Eq rep)
+ maybe_comparison (MO_S_Gt _) rep True = Just (MO_S_Gt rep)
+ maybe_comparison (MO_S_Ge _) rep True = Just (MO_S_Ge rep)
+ maybe_comparison (MO_S_Lt _) rep True = Just (MO_S_Lt rep)
+ maybe_comparison (MO_S_Le _) rep True = Just (MO_S_Le rep)
+ maybe_comparison (MO_S_Gt _) rep False = Just (MO_U_Gt rep)
+ maybe_comparison (MO_S_Ge _) rep False = Just (MO_U_Ge rep)
+ maybe_comparison (MO_S_Lt _) rep False = Just (MO_U_Lt rep)
+ maybe_comparison (MO_S_Le _) rep False = Just (MO_U_Le rep)
+ maybe_comparison _ _ _ = Nothing
#endif
MO_Eq r | Just x' <- maybeInvertCmmExpr x -> x'
MO_U_Gt r | isComparisonExpr x -> x
MO_S_Gt r | isComparisonExpr x -> x
- MO_U_Lt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordRep)
- MO_S_Lt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordRep)
- MO_U_Ge r | isComparisonExpr x -> CmmLit (CmmInt 1 wordRep)
- MO_S_Ge r | isComparisonExpr x -> CmmLit (CmmInt 1 wordRep)
+ MO_U_Lt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordWidth)
+ MO_S_Lt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordWidth)
+ MO_U_Ge r | isComparisonExpr x -> CmmLit (CmmInt 1 wordWidth)
+ MO_S_Ge r | isComparisonExpr x -> CmmLit (CmmInt 1 wordWidth)
MO_U_Le r | Just x' <- maybeInvertCmmExpr x -> x'
MO_S_Le r | Just x' <- maybeInvertCmmExpr x -> x'
other -> CmmMachOp mop args
MO_Eq r | isComparisonExpr x -> x
MO_U_Lt r | Just x' <- maybeInvertCmmExpr x -> x'
MO_S_Lt r | Just x' <- maybeInvertCmmExpr x -> x'
- MO_U_Gt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordRep)
- MO_S_Gt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordRep)
- MO_U_Le r | isComparisonExpr x -> CmmLit (CmmInt 1 wordRep)
- MO_S_Le r | isComparisonExpr x -> CmmLit (CmmInt 1 wordRep)
+ MO_U_Gt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordWidth)
+ MO_S_Gt r | isComparisonExpr x -> CmmLit (CmmInt 0 wordWidth)
+ MO_U_Le r | isComparisonExpr x -> CmmLit (CmmInt 1 wordWidth)
+ MO_S_Le r | isComparisonExpr x -> CmmLit (CmmInt 1 wordWidth)
MO_U_Ge r | isComparisonExpr x -> x
MO_S_Ge r | isComparisonExpr x -> x
other -> CmmMachOp mop args
-- x1 = x >> word_size-1 (unsigned)
-- return = (x + x1) >>= log2(divisor)
let
- bits = fromIntegral (machRepBitWidth rep) - 1
+ bits = fromIntegral (widthInBits rep) - 1
shr = if p == 1 then MO_U_Shr rep else MO_S_Shr rep
x1 = CmmMachOp shr [x, CmmLit (CmmInt bits rep)]
x2 = if p == 1 then x1 else
-- -----------------------------------------------------------------------------
--- widening / narrowing
-
-narrowU :: MachRep -> Integer -> Integer
-narrowU I8 x = fromIntegral (fromIntegral x :: Word8)
-narrowU I16 x = fromIntegral (fromIntegral x :: Word16)
-narrowU I32 x = fromIntegral (fromIntegral x :: Word32)
-narrowU I64 x = fromIntegral (fromIntegral x :: Word64)
-narrowU _ _ = panic "narrowTo"
-
-narrowS :: MachRep -> Integer -> Integer
-narrowS I8 x = fromIntegral (fromIntegral x :: Int8)
-narrowS I16 x = fromIntegral (fromIntegral x :: Int16)
-narrowS I32 x = fromIntegral (fromIntegral x :: Int32)
-narrowS I64 x = fromIntegral (fromIntegral x :: Int64)
-narrowS _ _ = panic "narrowTo"
-
--- -----------------------------------------------------------------------------
-- Loopify for C
{-
-}
cmmLoopifyForC :: RawCmmTop -> RawCmmTop
-cmmLoopifyForC p@(CmmProc info entry_lbl [] (ListGraph blocks@(BasicBlock top_id _ : _)))
+cmmLoopifyForC p@(CmmProc info entry_lbl []
+ (ListGraph blocks@(BasicBlock top_id _ : _)))
| null info = p -- only if there's an info table, ignore case alts
| otherwise =
-- pprTrace "jump_lbl" (ppr jump_lbl <+> ppr entry_lbl) $
isPicReg (CmmReg (CmmGlobal PicBaseReg)) = True
isPicReg _ = False
-_unused :: FS.FastString -- stops a warning
-_unused = undefined
projects / ghc-hetmet.git / blobdiff