module RegSpill (
regSpill,
SpillStats(..),
- accSpillLS
+ accSpillSL
)
where
= do instrss' <- mapM (regSpill_instr regSlotMap) instrs
return $ BasicBlock i (concat instrss')
-
-regSpill_instr _ li@(Instr (DELTA delta) _)
- = do
- setDelta delta
- return [li]
-
regSpill_instr _ li@(Instr _ Nothing)
= do return [li]
-
regSpill_instr regSlotMap
(Instr instr (Just live))
= do
spillRead regSlotMap instr reg
| Just slot <- lookupUFM regSlotMap reg
- = do delta <- getDelta
- (instr', nReg) <- patchInstr reg instr
-
- let pre = [ COMMENT FSLIT("spill load")
- , mkLoadInstr nReg delta slot ]
+ = do (instr', nReg) <- patchInstr reg instr
modify $ \s -> s
- { stateSpillLS = addToUFM_C accSpillLS (stateSpillLS s) reg (reg, 1, 0) }
+ { stateSpillSL = addToUFM_C accSpillSL (stateSpillSL s) reg (reg, 0, 1) }
- return ( instr', (pre, []))
+ return ( instr'
+ , ( [RELOAD slot nReg]
+ , []) )
| otherwise = panic "RegSpill.spillRead: no slot defined for spilled reg"
spillWrite regSlotMap instr reg
| Just slot <- lookupUFM regSlotMap reg
- = do delta <- getDelta
- (instr', nReg) <- patchInstr reg instr
-
- let post = [ COMMENT FSLIT("spill store")
- , mkSpillInstr nReg delta slot ]
+ = do (instr', nReg) <- patchInstr reg instr
modify $ \s -> s
- { stateSpillLS = addToUFM_C accSpillLS (stateSpillLS s) reg (reg, 0, 1) }
+ { stateSpillSL = addToUFM_C accSpillSL (stateSpillSL s) reg (reg, 1, 0) }
- return ( instr', ([], post))
+ return ( instr'
+ , ( []
+ , [SPILL nReg slot]))
| otherwise = panic "RegSpill.spillWrite: no slot defined for spilled reg"
spillModify regSlotMap instr reg
| Just slot <- lookupUFM regSlotMap reg
- = do delta <- getDelta
- (instr', nReg) <- patchInstr reg instr
-
- let pre = [ COMMENT FSLIT("spill mod load")
- , mkLoadInstr nReg delta slot ]
-
- let post = [ COMMENT FSLIT("spill mod store")
- , mkSpillInstr nReg delta slot ]
+ = do (instr', nReg) <- patchInstr reg instr
modify $ \s -> s
- { stateSpillLS = addToUFM_C accSpillLS (stateSpillLS s) reg (reg, 1, 1) }
+ { stateSpillSL = addToUFM_C accSpillSL (stateSpillSL s) reg (reg, 1, 1) }
- return ( instr', (pre, post))
+ return ( instr'
+ , ( [RELOAD slot nReg]
+ , [SPILL nReg slot]))
| otherwise = panic "RegSpill.spillModify: no slot defined for spilled reg"
data SpillS
= SpillS
- { stateDelta :: Int
- , stateUS :: UniqSupply
- , stateSpillLS :: UniqFM (Reg, Int, Int) } -- ^ spilled reg vs number of times vreg was loaded, stored
+ { stateUS :: UniqSupply
+ , stateSpillSL :: UniqFM (Reg, Int, Int) } -- ^ spilled reg vs number of times vreg was loaded, stored
initSpillS uniqueSupply
= SpillS
- { stateDelta = 0
- , stateUS = uniqueSupply
- , stateSpillLS = emptyUFM }
+ { stateUS = uniqueSupply
+ , stateSpillSL = emptyUFM }
type SpillM a = State SpillS a
-setDelta :: Int -> SpillM ()
-setDelta delta
- = modify $ \s -> s { stateDelta = delta }
-
-getDelta :: SpillM Int
-getDelta = gets stateDelta
-
newUnique :: SpillM Unique
newUnique
= do us <- gets stateUS
modify $ \s -> s { stateUS = us2 }
return uniq
-accSpillLS (r1, l1, s1) (r2, l2, s2)
- = (r1, l1 + l2, s1 + s2)
-
+accSpillSL (r1, s1, l1) (r2, s2, l2)
+ = (r1, s1 + s2, l1 + l2)
----------------------------------------------------
data SpillStats
= SpillStats
- { spillLoadStore :: UniqFM (Reg, Int, Int) }
+ { spillStoreLoad :: UniqFM (Reg, Int, Int) }
makeSpillStats :: SpillS -> SpillStats
makeSpillStats s
= SpillStats
- { spillLoadStore = stateSpillLS s }
+ { spillStoreLoad = stateSpillSL s }
instance Outputable SpillStats where
- ppr s
- = (vcat $ map (\(r, l, s) -> ppr r <+> int l <+> int s)
- $ eltsUFM (spillLoadStore s))
+ ppr stats
+ = (vcat $ map (\(r, s, l) -> ppr r <+> int s <+> int l)
+ $ eltsUFM (spillStoreLoad stats))