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