FreeRegs.hs 1.98 KB
Newer Older
1 2 3 4 5

-- | Free regs map for PowerPC
module RegAlloc.Linear.PPC.FreeRegs
where

6 7 8
import PPC.Regs
import RegClass
import Reg
9 10 11 12 13

import Outputable

import Data.Word
import Data.Bits
14
-- import Data.List
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

-- The PowerPC has 32 integer and 32 floating point registers.
-- This is 32bit PowerPC, so Word64 is inefficient - two Word32s are much
-- better.
-- Note that when getFreeRegs scans for free registers, it starts at register
-- 31 and counts down. This is a hack for the PowerPC - the higher-numbered
-- registers are callee-saves, while the lower regs are caller-saves, so it
-- makes sense to start at the high end.
-- Apart from that, the code does nothing PowerPC-specific, so feel free to
-- add your favourite platform to the #if (if you have 64 registers but only
-- 32-bit words).

data FreeRegs = FreeRegs !Word32 !Word32
	      deriving( Show )	-- The Show is used in an ASSERT

noFreeRegs :: FreeRegs
noFreeRegs = FreeRegs 0 0

33 34
releaseReg :: RealReg -> FreeRegs -> FreeRegs
releaseReg (RealRegSingle r) (FreeRegs g f)
35 36
    | r > 31    = FreeRegs g (f .|. (1 `shiftL` (r - 32)))
    | otherwise = FreeRegs (g .|. (1 `shiftL` r)) f
37 38 39

releaseReg _ _
	= panic "RegAlloc.Linear.PPC.releaseReg: bad reg"
40 41 42 43
    
initFreeRegs :: FreeRegs
initFreeRegs = foldr releaseReg noFreeRegs allocatableRegs

44
getFreeRegs :: RegClass -> FreeRegs -> [RealReg]	-- lazilly
45 46 47 48 49 50
getFreeRegs cls (FreeRegs g f)
    | RcDouble <- cls = go f (0x80000000) 63
    | RcInteger <- cls = go g (0x80000000) 31
    | otherwise = pprPanic "RegAllocLinear.getFreeRegs: Bad register class" (ppr cls)
    where
        go _ 0 _ = []
51
        go x m i | x .&. m /= 0 = RealRegSingle i : (go x (m `shiftR` 1) $! i-1)
52 53
                 | otherwise    = go x (m `shiftR` 1) $! i-1

54 55
allocateReg :: RealReg -> FreeRegs -> FreeRegs
allocateReg (RealRegSingle r) (FreeRegs g f) 
56 57
    | r > 31    = FreeRegs g (f .&. complement (1 `shiftL` (r - 32)))
    | otherwise = FreeRegs (g .&. complement (1 `shiftL` r)) f
58

59 60
allocateReg _ _
	= panic "RegAlloc.Linear.PPC.allocateReg: bad reg"