compiler/nativeGen/SPARC/Instr.hs

   1 -----------------------------------------------------------------------------
   2 --
   3 -- Machine-dependent assembly language
   4 --
   5 -- (c) The University of Glasgow 1993-2004
   6 --
   7 -----------------------------------------------------------------------------
   8
   9 #include "HsVersions.h"
  10 #include "nativeGen/NCG.h"
  11
  12 module SPARC.Instr (
  13         RI(..),
  14         riZero,
  15
  16         fpRelEA,
  17         moveSp,
  18
  19         isUnconditionalJump,
  20
  21         Instr(..),
  22         maxSpillSlots
  23 )
  24
  25 where
  26
  27 import SPARC.Stack
  28 import SPARC.Imm
  29 import SPARC.AddrMode
  30 import SPARC.Cond
  31 import SPARC.Regs
  32 import SPARC.RegPlate
  33 import SPARC.Base
  34 import TargetReg
  35 import Instruction
  36 import RegClass
  37 import Reg
  38 import Size
  39
  40 import BlockId
  41 import Cmm
  42 import FastString
  43 import FastBool
  44 import Outputable
  45
  46 import GHC.Exts
  47
  48
  49 -- | Register or immediate
  50 data RI
  51         = RIReg Reg
  52         | RIImm Imm
  53
  54 -- | Check if a RI represents a zero value.
  55 --      - a literal zero
  56 --      - register %g0, which is always zero.
  57 --
  58 riZero :: RI -> Bool
  59 riZero (RIImm (ImmInt 0))                       = True
  60 riZero (RIImm (ImmInteger 0))                   = True
  61 riZero (RIReg (RegReal (RealRegSingle 0)))      = True
  62 riZero _                                        = False
  63
  64
  65 -- | Calculate the effective address which would be used by the
  66 --      corresponding fpRel sequence.
  67 fpRelEA :: Int -> Reg -> Instr
  68 fpRelEA n dst
  69    = ADD False False fp (RIImm (ImmInt (n * wordLength))) dst
  70
  71
  72 -- | Code to shift the stack pointer by n words.
  73 moveSp :: Int -> Instr
  74 moveSp n
  75    = ADD False False sp (RIImm (ImmInt (n * wordLength))) sp
  76
  77 -- | An instruction that will cause the one after it never to be exectuted
  78 isUnconditionalJump :: Instr -> Bool
  79 isUnconditionalJump ii
  80  = case ii of
  81         CALL{}          -> True
  82         JMP{}           -> True
  83         JMP_TBL{}       -> True
  84         BI ALWAYS _ _   -> True
  85         BF ALWAYS _ _   -> True
  86         _               -> False
  87
  88
  89 -- | instance for sparc instruction set
  90 instance Instruction Instr where
  91         regUsageOfInstr         = sparc_regUsageOfInstr
  92         patchRegsOfInstr        = sparc_patchRegsOfInstr
  93         isJumpishInstr          = sparc_isJumpishInstr
  94         jumpDestsOfInstr        = sparc_jumpDestsOfInstr
  95         patchJumpInstr          = sparc_patchJumpInstr
  96         mkSpillInstr            = sparc_mkSpillInstr
  97         mkLoadInstr             = sparc_mkLoadInstr
  98         takeDeltaInstr          = sparc_takeDeltaInstr
  99         isMetaInstr             = sparc_isMetaInstr
 100         mkRegRegMoveInstr       = sparc_mkRegRegMoveInstr
 101         takeRegRegMoveInstr     = sparc_takeRegRegMoveInstr
 102         mkJumpInstr             = sparc_mkJumpInstr
 103
 104
 105 -- | SPARC instruction set.
 106 --      Not complete. This is only the ones we need.
 107 --
 108 data Instr
 109
 110         -- meta ops --------------------------------------------------
 111         -- comment pseudo-op
 112         = COMMENT FastString
 113
 114         -- some static data spat out during code generation.
 115         -- Will be extracted before pretty-printing.
 116         | LDATA   Section [CmmStatic]
 117
 118         -- Start a new basic block.  Useful during codegen, removed later.
 119         -- Preceding instruction should be a jump, as per the invariants
 120         -- for a BasicBlock (see Cmm).
 121         | NEWBLOCK BlockId
 122
 123         -- specify current stack offset for benefit of subsequent passes.
 124         | DELTA   Int
 125
 126         -- real instrs -----------------------------------------------
 127         -- Loads and stores.
 128         | LD            Size AddrMode Reg               -- size, src, dst
 129         | ST            Size Reg AddrMode               -- size, src, dst
 130
 131         -- Int Arithmetic.
 132         --      x:   add/sub with carry bit.
 133         --              In SPARC V9 addx and friends were renamed addc.
 134         --
 135         --      cc:  modify condition codes
 136         --
 137         | ADD           Bool Bool Reg RI Reg            -- x?, cc?, src1, src2, dst
 138         | SUB           Bool Bool Reg RI Reg            -- x?, cc?, src1, src2, dst
 139
 140         | UMUL          Bool Reg RI Reg                 --     cc?, src1, src2, dst
 141         | SMUL          Bool Reg RI Reg                 --     cc?, src1, src2, dst
 142
 143
 144         -- The SPARC divide instructions perform 64bit by 32bit division
 145         --   The Y register is xored into the first operand.
 146
 147         --   On _some implementations_ the Y register is overwritten by
 148         --   the remainder, so we have to make sure it is 0 each time.
 149
 150         --   dst <- ((Y `shiftL` 32) `or` src1) `div` src2
 151         | UDIV          Bool Reg RI Reg                 --     cc?, src1, src2, dst
 152         | SDIV          Bool Reg RI Reg                 --     cc?, src1, src2, dst
 153
 154         | RDY           Reg                             -- move contents of Y register to reg
 155         | WRY           Reg  Reg                        -- Y <- src1 `xor` src2
 156
 157         -- Logic operations.
 158         | AND           Bool Reg RI Reg                 -- cc?, src1, src2, dst
 159         | ANDN          Bool Reg RI Reg                 -- cc?, src1, src2, dst
 160         | OR            Bool Reg RI Reg                 -- cc?, src1, src2, dst
 161         | ORN           Bool Reg RI Reg                 -- cc?, src1, src2, dst
 162         | XOR           Bool Reg RI Reg                 -- cc?, src1, src2, dst
 163         | XNOR          Bool Reg RI Reg                 -- cc?, src1, src2, dst
 164         | SLL           Reg RI Reg                      -- src1, src2, dst
 165         | SRL           Reg RI Reg                      -- src1, src2, dst
 166         | SRA           Reg RI Reg                      -- src1, src2, dst
 167
 168         -- Load immediates.
 169         | SETHI         Imm Reg                         -- src, dst
 170
 171         -- Do nothing.
 172         -- Implemented by the assembler as SETHI 0, %g0, but worth an alias
 173         | NOP
 174
 175         -- Float Arithmetic.
 176         -- Note that we cheat by treating F{ABS,MOV,NEG} of doubles as single
 177         -- instructions right up until we spit them out.
 178         --
 179         | FABS          Size Reg Reg                    -- src dst
 180         | FADD          Size Reg Reg Reg                -- src1, src2, dst
 181         | FCMP          Bool Size Reg Reg               -- exception?, src1, src2, dst
 182         | FDIV          Size Reg Reg Reg                -- src1, src2, dst
 183         | FMOV          Size Reg Reg                    -- src, dst
 184         | FMUL          Size Reg Reg Reg                -- src1, src2, dst
 185         | FNEG          Size Reg Reg                    -- src, dst
 186         | FSQRT         Size Reg Reg                    -- src, dst
 187         | FSUB          Size Reg Reg Reg                -- src1, src2, dst
 188         | FxTOy         Size Size Reg Reg               -- src, dst
 189
 190         -- Jumping around.
 191         | BI            Cond Bool BlockId               -- cond, annul?, target
 192         | BF            Cond Bool BlockId               -- cond, annul?, target
 193
 194         | JMP           AddrMode                        -- target
 195
 196         -- With a tabled jump we know all the possible destinations.
 197         -- We also need this info so we can work out what regs are live across the jump.
 198         --
 199         | JMP_TBL       AddrMode [BlockId]
 200
 201         | CALL          (Either Imm Reg) Int Bool       -- target, args, terminal
 202
 203
 204 -- | regUsage returns the sets of src and destination registers used
 205 --      by a particular instruction.  Machine registers that are
 206 --      pre-allocated to stgRegs are filtered out, because they are
 207 --      uninteresting from a register allocation standpoint.  (We wouldn't
 208 --      want them to end up on the free list!)  As far as we are concerned,
 209 --      the fixed registers simply don't exist (for allocation purposes,
 210 --      anyway).
 211
 212 --      regUsage doesn't need to do any trickery for jumps and such.  Just
 213 --      state precisely the regs read and written by that insn.  The
 214 --      consequences of control flow transfers, as far as register
 215 --      allocation goes, are taken care of by the register allocator.
 216 --
 217 sparc_regUsageOfInstr :: Instr -> RegUsage
 218 sparc_regUsageOfInstr instr
 219  = case instr of
 220     LD    _ addr reg            -> usage (regAddr addr,         [reg])
 221     ST    _ reg addr            -> usage (reg : regAddr addr,   [])
 222     ADD   _ _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 223     SUB   _ _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 224     UMUL    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 225     SMUL    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 226     UDIV    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 227     SDIV    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 228     RDY       rd                -> usage ([],                   [rd])
 229     WRY       r1 r2             -> usage ([r1, r2],             [])
 230     AND     _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 231     ANDN    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 232     OR      _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 233     ORN     _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 234     XOR     _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 235     XNOR    _ r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 236     SLL       r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 237     SRL       r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 238     SRA       r1 ar r2          -> usage (r1 : regRI ar,        [r2])
 239     SETHI   _ reg               -> usage ([],                   [reg])
 240     FABS    _ r1 r2             -> usage ([r1],                 [r2])
 241     FADD    _ r1 r2 r3          -> usage ([r1, r2],             [r3])
 242     FCMP    _ _  r1 r2          -> usage ([r1, r2],             [])
 243     FDIV    _ r1 r2 r3          -> usage ([r1, r2],             [r3])
 244     FMOV    _ r1 r2             -> usage ([r1],                 [r2])
 245     FMUL    _ r1 r2 r3          -> usage ([r1, r2],             [r3])
 246     FNEG    _ r1 r2             -> usage ([r1],                 [r2])
 247     FSQRT   _ r1 r2             -> usage ([r1],                 [r2])
 248     FSUB    _ r1 r2 r3          -> usage ([r1, r2],             [r3])
 249     FxTOy   _ _  r1 r2          -> usage ([r1],                 [r2])
 250
 251     JMP     addr                -> usage (regAddr addr, [])
 252     JMP_TBL addr _              -> usage (regAddr addr, [])
 253
 254     CALL  (Left _  )  _ True    -> noUsage
 255     CALL  (Left _  )  n False   -> usage (argRegs n, callClobberedRegs)
 256     CALL  (Right reg) _ True    -> usage ([reg], [])
 257     CALL  (Right reg) n False   -> usage (reg : (argRegs n), callClobberedRegs)
 258     _                           -> noUsage
 259
 260   where
 261     usage (src, dst)
 262      = RU (filter interesting src) (filter interesting dst)
 263
 264     regAddr (AddrRegReg r1 r2)  = [r1, r2]
 265     regAddr (AddrRegImm r1 _)   = [r1]
 266
 267     regRI (RIReg r)             = [r]
 268     regRI  _                    = []
 269
 270
 271 -- | Interesting regs are virtuals, or ones that are allocatable
 272 --      by the register allocator.
 273 interesting :: Reg -> Bool
 274 interesting reg
 275  = case reg of
 276         RegVirtual _                    -> True
 277         RegReal (RealRegSingle r1)      -> isFastTrue (freeReg r1)
 278         RegReal (RealRegPair r1 _)      -> isFastTrue (freeReg r1)
 279
 280
 281
 282 -- | Apply a given mapping to tall the register references in this instruction.
 283 sparc_patchRegsOfInstr :: Instr -> (Reg -> Reg) -> Instr
 284 sparc_patchRegsOfInstr instr env = case instr of
 285     LD    sz addr reg           -> LD sz (fixAddr addr) (env reg)
 286     ST    sz reg addr           -> ST sz (env reg) (fixAddr addr)
 287
 288     ADD   x cc r1 ar r2         -> ADD   x cc  (env r1) (fixRI ar) (env r2)
 289     SUB   x cc r1 ar r2         -> SUB   x cc  (env r1) (fixRI ar) (env r2)
 290     UMUL    cc r1 ar r2         -> UMUL    cc  (env r1) (fixRI ar) (env r2)
 291     SMUL    cc r1 ar r2         -> SMUL    cc  (env r1) (fixRI ar) (env r2)
 292     UDIV    cc r1 ar r2         -> UDIV    cc  (env r1) (fixRI ar) (env r2)
 293     SDIV    cc r1 ar r2         -> SDIV    cc  (env r1) (fixRI ar) (env r2)
 294     RDY   rd                    -> RDY         (env rd)
 295     WRY   r1 r2                 -> WRY         (env r1) (env r2)
 296     AND   b r1 ar r2            -> AND   b     (env r1) (fixRI ar) (env r2)
 297     ANDN  b r1 ar r2            -> ANDN  b     (env r1) (fixRI ar) (env r2)
 298     OR    b r1 ar r2            -> OR    b     (env r1) (fixRI ar) (env r2)
 299     ORN   b r1 ar r2            -> ORN   b     (env r1) (fixRI ar) (env r2)
 300     XOR   b r1 ar r2            -> XOR   b     (env r1) (fixRI ar) (env r2)
 301     XNOR  b r1 ar r2            -> XNOR  b     (env r1) (fixRI ar) (env r2)
 302     SLL   r1 ar r2              -> SLL         (env r1) (fixRI ar) (env r2)
 303     SRL   r1 ar r2              -> SRL         (env r1) (fixRI ar) (env r2)
 304     SRA   r1 ar r2              -> SRA         (env r1) (fixRI ar) (env r2)
 305
 306     SETHI imm reg               -> SETHI imm (env reg)
 307
 308     FABS  s r1 r2               -> FABS    s   (env r1) (env r2)
 309     FADD  s r1 r2 r3            -> FADD    s   (env r1) (env r2) (env r3)
 310     FCMP  e s r1 r2             -> FCMP e  s   (env r1) (env r2)
 311     FDIV  s r1 r2 r3            -> FDIV    s   (env r1) (env r2) (env r3)
 312     FMOV  s r1 r2               -> FMOV    s   (env r1) (env r2)
 313     FMUL  s r1 r2 r3            -> FMUL    s   (env r1) (env r2) (env r3)
 314     FNEG  s r1 r2               -> FNEG    s   (env r1) (env r2)
 315     FSQRT s r1 r2               -> FSQRT   s   (env r1) (env r2)
 316     FSUB  s r1 r2 r3            -> FSUB    s   (env r1) (env r2) (env r3)
 317     FxTOy s1 s2 r1 r2           -> FxTOy s1 s2 (env r1) (env r2)
 318
 319     JMP     addr                -> JMP     (fixAddr addr)
 320     JMP_TBL addr ids            -> JMP_TBL (fixAddr addr) ids
 321
 322     CALL  (Left i) n t          -> CALL (Left i) n t
 323     CALL  (Right r) n t         -> CALL (Right (env r)) n t
 324     _                           -> instr
 325
 326   where
 327     fixAddr (AddrRegReg r1 r2)  = AddrRegReg   (env r1) (env r2)
 328     fixAddr (AddrRegImm r1 i)   = AddrRegImm   (env r1) i
 329
 330     fixRI (RIReg r)             = RIReg (env r)
 331     fixRI other                 = other
 332
 333
 334 --------------------------------------------------------------------------------
 335 sparc_isJumpishInstr :: Instr -> Bool
 336 sparc_isJumpishInstr instr
 337  = case instr of
 338         BI{}            -> True
 339         BF{}            -> True
 340         JMP{}           -> True
 341         JMP_TBL{}       -> True
 342         CALL{}          -> True
 343         _               -> False
 344
 345 sparc_jumpDestsOfInstr :: Instr -> [BlockId]
 346 sparc_jumpDestsOfInstr insn
 347   = case insn of
 348         BI   _ _ id     -> [id]
 349         BF   _ _ id     -> [id]
 350         JMP_TBL _ ids   -> ids
 351         _               -> []
 352
 353
 354 sparc_patchJumpInstr :: Instr -> (BlockId -> BlockId) -> Instr
 355 sparc_patchJumpInstr insn patchF
 356   = case insn of
 357         BI cc annul id  -> BI cc annul (patchF id)
 358         BF cc annul id  -> BF cc annul (patchF id)
 359         _               -> insn
 360
 361
 362 --------------------------------------------------------------------------------
 363 -- | Make a spill instruction.
 364 --      On SPARC we spill below frame pointer leaving 2 words/spill
 365 sparc_mkSpillInstr
 366         :: Reg          -- ^ register to spill
 367         -> Int          -- ^ current stack delta
 368         -> Int          -- ^ spill slot to use
 369         -> Instr
 370
 371 sparc_mkSpillInstr reg _ slot
 372  = let  off     = spillSlotToOffset slot
 373         off_w   = 1 + (off `div` 4)
 374         sz      = case targetClassOfReg reg of
 375                         RcInteger -> II32
 376                         RcFloat   -> FF32
 377                         RcDouble  -> FF64
 378
 379     in ST sz reg (fpRel (negate off_w))
 380
 381
 382 -- | Make a spill reload instruction.
 383 sparc_mkLoadInstr
 384         :: Reg          -- ^ register to load into
 385         -> Int          -- ^ current stack delta
 386         -> Int          -- ^ spill slot to use
 387         -> Instr
 388
 389 sparc_mkLoadInstr reg _ slot
 390   = let off     = spillSlotToOffset slot
 391         off_w   = 1 + (off `div` 4)
 392         sz      = case targetClassOfReg reg of
 393                         RcInteger -> II32
 394                         RcFloat   -> FF32
 395                         RcDouble  -> FF64
 396
 397         in LD sz (fpRel (- off_w)) reg
 398
 399
 400 --------------------------------------------------------------------------------
 401 -- | See if this instruction is telling us the current C stack delta
 402 sparc_takeDeltaInstr
 403         :: Instr
 404         -> Maybe Int
 405
 406 sparc_takeDeltaInstr instr
 407  = case instr of
 408         DELTA i         -> Just i
 409         _               -> Nothing
 410
 411
 412 sparc_isMetaInstr
 413         :: Instr
 414         -> Bool
 415
 416 sparc_isMetaInstr instr
 417  = case instr of
 418         COMMENT{}       -> True
 419         LDATA{}         -> True
 420         NEWBLOCK{}      -> True
 421         DELTA{}         -> True
 422         _               -> False
 423
 424
 425 -- | Make a reg-reg move instruction.
 426 --      On SPARC v8 there are no instructions to move directly between
 427 --      floating point and integer regs. If we need to do that then we
 428 --      have to go via memory.
 429 --
 430 sparc_mkRegRegMoveInstr
 431         :: Reg
 432         -> Reg
 433         -> Instr
 434
 435 sparc_mkRegRegMoveInstr src dst
 436         | srcClass      <- targetClassOfReg src
 437         , dstClass      <- targetClassOfReg dst
 438         , srcClass == dstClass
 439         = case srcClass of
 440                 RcInteger -> ADD  False False src (RIReg g0) dst
 441                 RcDouble  -> FMOV FF64 src dst
 442                 RcFloat   -> FMOV FF32 src dst
 443
 444         | otherwise
 445         = panic "SPARC.Instr.mkRegRegMoveInstr: classes of src and dest not the same"
 446
 447
 448 -- | Check whether an instruction represents a reg-reg move.
 449 --      The register allocator attempts to eliminate reg->reg moves whenever it can,
 450 --      by assigning the src and dest temporaries to the same real register.
 451 --
 452 sparc_takeRegRegMoveInstr :: Instr -> Maybe (Reg,Reg)
 453 sparc_takeRegRegMoveInstr instr
 454  = case instr of
 455         ADD False False src (RIReg src2) dst
 456          | g0 == src2           -> Just (src, dst)
 457
 458         FMOV FF64 src dst       -> Just (src, dst)
 459         FMOV FF32  src dst      -> Just (src, dst)
 460         _                       -> Nothing
 461
 462
 463 -- | Make an unconditional branch instruction.
 464 sparc_mkJumpInstr
 465         :: BlockId
 466         -> [Instr]
 467
 468 sparc_mkJumpInstr id
 469  =       [BI ALWAYS False id
 470         , NOP]                  -- fill the branch delay slot.
 471