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