compiler/nativeGen/SPARC/Ppr.hs

   1 -----------------------------------------------------------------------------
   2 --
   3 -- Pretty-printing assembly language
   4 --
   5 -- (c) The University of Glasgow 1993-2005
   6 --
   7 -----------------------------------------------------------------------------
   8
   9 module SPARC.Ppr (
  10         pprNatCmmTop,
  11         pprBasicBlock,
  12         pprSectionHeader,
  13         pprData,
  14         pprInstr,
  15         pprUserReg,
  16         pprSize,
  17         pprImm,
  18         pprDataItem
  19 )
  20
  21 where
  22
  23 #include "HsVersions.h"
  24 #include "nativeGen/NCG.h"
  25
  26 import SPARC.Regs
  27 import SPARC.Instr
  28 import SPARC.Cond
  29 import SPARC.Imm
  30 import SPARC.AddrMode
  31 import SPARC.Base
  32 import Instruction
  33 import Reg
  34 import Size
  35 import PprBase
  36
  37 import BlockId
  38 import Cmm
  39 import CLabel
  40
  41 import Unique           ( pprUnique )
  42 import qualified Outputable
  43 import Outputable       (Outputable, panic)
  44 import Pretty
  45 import FastString
  46 import Data.Word
  47
  48 -- -----------------------------------------------------------------------------
  49 -- Printing this stuff out
  50
  51 pprNatCmmTop :: NatCmmTop Instr -> Doc
  52 pprNatCmmTop (CmmData section dats) =
  53   pprSectionHeader section $$ vcat (map pprData dats)
  54
  55  -- special case for split markers:
  56 pprNatCmmTop (CmmProc [] lbl _ (ListGraph [])) = pprLabel lbl
  57
  58 pprNatCmmTop (CmmProc info lbl _ (ListGraph blocks)) =
  59   pprSectionHeader Text $$
  60   (if null info then -- blocks guaranteed not null, so label needed
  61        pprLabel lbl
  62    else
  63 #if HAVE_SUBSECTIONS_VIA_SYMBOLS
  64             pprCLabel_asm (mkDeadStripPreventer $ entryLblToInfoLbl lbl)
  65                 <> char ':' $$
  66 #endif
  67        vcat (map pprData info) $$
  68        pprLabel (entryLblToInfoLbl lbl)
  69   ) $$
  70   vcat (map pprBasicBlock blocks)
  71      -- above: Even the first block gets a label, because with branch-chain
  72      -- elimination, it might be the target of a goto.
  73 #if HAVE_SUBSECTIONS_VIA_SYMBOLS
  74         -- If we are using the .subsections_via_symbols directive
  75         -- (available on recent versions of Darwin),
  76         -- we have to make sure that there is some kind of reference
  77         -- from the entry code to a label on the _top_ of of the info table,
  78         -- so that the linker will not think it is unreferenced and dead-strip
  79         -- it. That's why the label is called a DeadStripPreventer (_dsp).
  80   $$ if not (null info)
  81                     then text "\t.long "
  82                       <+> pprCLabel_asm (entryLblToInfoLbl lbl)
  83                       <+> char '-'
  84                       <+> pprCLabel_asm (mkDeadStripPreventer $ entryLblToInfoLbl lbl)
  85                     else empty
  86 #endif
  87
  88
  89 pprBasicBlock :: NatBasicBlock Instr -> Doc
  90 pprBasicBlock (BasicBlock (BlockId id) instrs) =
  91   pprLabel (mkAsmTempLabel id) $$
  92   vcat (map pprInstr instrs)
  93
  94
  95 pprData :: CmmStatic -> Doc
  96 pprData (CmmAlign bytes)         = pprAlign bytes
  97 pprData (CmmDataLabel lbl)       = pprLabel lbl
  98 pprData (CmmString str)          = pprASCII str
  99 pprData (CmmUninitialised bytes) = ptext (sLit ".skip ") <> int bytes
 100 pprData (CmmStaticLit lit)       = pprDataItem lit
 101
 102 pprGloblDecl :: CLabel -> Doc
 103 pprGloblDecl lbl
 104   | not (externallyVisibleCLabel lbl) = empty
 105   | otherwise = ptext IF_ARCH_sparc((sLit ".global "),
 106                                     (sLit ".globl ")) <>
 107                 pprCLabel_asm lbl
 108
 109 pprTypeAndSizeDecl :: CLabel -> Doc
 110 #if linux_TARGET_OS
 111 pprTypeAndSizeDecl lbl
 112   | not (externallyVisibleCLabel lbl) = empty
 113   | otherwise = ptext (sLit ".type ") <>
 114                 pprCLabel_asm lbl <> ptext (sLit ", @object")
 115 #else
 116 pprTypeAndSizeDecl _
 117   = empty
 118 #endif
 119
 120 pprLabel :: CLabel -> Doc
 121 pprLabel lbl = pprGloblDecl lbl $$ pprTypeAndSizeDecl lbl $$ (pprCLabel_asm lbl <> char ':')
 122
 123
 124 pprASCII :: [Word8] -> Doc
 125 pprASCII str
 126   = vcat (map do1 str) $$ do1 0
 127     where
 128        do1 :: Word8 -> Doc
 129        do1 w = ptext (sLit "\t.byte\t") <> int (fromIntegral w)
 130
 131 pprAlign :: Int -> Doc
 132 pprAlign bytes =
 133         ptext (sLit ".align ") <> int bytes
 134
 135
 136 -- -----------------------------------------------------------------------------
 137 -- pprInstr: print an 'Instr'
 138
 139 instance Outputable Instr where
 140     ppr  instr  = Outputable.docToSDoc $ pprInstr instr
 141
 142
 143 -- | Pretty print a register.
 144 --      This is an alias of pprReg for legacy reasons, should remove it.
 145 pprUserReg :: Reg -> Doc
 146 pprUserReg = pprReg
 147
 148
 149 -- | Pretty print a register.
 150 pprReg :: Reg -> Doc
 151 pprReg reg
 152  = case reg of
 153         RegVirtual vr
 154          -> case vr of
 155                 VirtualRegI  u  -> text "%vI_"  <> asmSDoc (pprUnique u)
 156                 VirtualRegHi u  -> text "%vHi_" <> asmSDoc (pprUnique u)
 157                 VirtualRegF  u  -> text "%vF_"  <> asmSDoc (pprUnique u)
 158                 VirtualRegD  u  -> text "%vD_"  <> asmSDoc (pprUnique u)
 159
 160         RegReal rr
 161          -> case rr of
 162                 RealRegSingle r1
 163                  -> pprReg_ofRegNo r1
 164
 165                 RealRegPair   r1 r2
 166                  -> text "("    <> pprReg_ofRegNo r1
 167                  <> text "|"    <> pprReg_ofRegNo r2
 168                  <> text ")"
 169
 170
 171
 172 -- | Pretty print a register name, based on this register number.
 173 --      The definition has been unfolded so we get a jump-table in the
 174 --      object code. This function is called quite a lot when emitting the asm file..
 175 --
 176 pprReg_ofRegNo :: Int -> Doc
 177 pprReg_ofRegNo i
 178  = ptext
 179     (case i of {
 180          0 -> sLit "%g0";   1 -> sLit "%g1";
 181          2 -> sLit "%g2";   3 -> sLit "%g3";
 182          4 -> sLit "%g4";   5 -> sLit "%g5";
 183          6 -> sLit "%g6";   7 -> sLit "%g7";
 184          8 -> sLit "%o0";   9 -> sLit "%o1";
 185         10 -> sLit "%o2";  11 -> sLit "%o3";
 186         12 -> sLit "%o4";  13 -> sLit "%o5";
 187         14 -> sLit "%o6";  15 -> sLit "%o7";
 188         16 -> sLit "%l0";  17 -> sLit "%l1";
 189         18 -> sLit "%l2";  19 -> sLit "%l3";
 190         20 -> sLit "%l4";  21 -> sLit "%l5";
 191         22 -> sLit "%l6";  23 -> sLit "%l7";
 192         24 -> sLit "%i0";  25 -> sLit "%i1";
 193         26 -> sLit "%i2";  27 -> sLit "%i3";
 194         28 -> sLit "%i4";  29 -> sLit "%i5";
 195         30 -> sLit "%i6";  31 -> sLit "%i7";
 196         32 -> sLit "%f0";  33 -> sLit "%f1";
 197         34 -> sLit "%f2";  35 -> sLit "%f3";
 198         36 -> sLit "%f4";  37 -> sLit "%f5";
 199         38 -> sLit "%f6";  39 -> sLit "%f7";
 200         40 -> sLit "%f8";  41 -> sLit "%f9";
 201         42 -> sLit "%f10"; 43 -> sLit "%f11";
 202         44 -> sLit "%f12"; 45 -> sLit "%f13";
 203         46 -> sLit "%f14"; 47 -> sLit "%f15";
 204         48 -> sLit "%f16"; 49 -> sLit "%f17";
 205         50 -> sLit "%f18"; 51 -> sLit "%f19";
 206         52 -> sLit "%f20"; 53 -> sLit "%f21";
 207         54 -> sLit "%f22"; 55 -> sLit "%f23";
 208         56 -> sLit "%f24"; 57 -> sLit "%f25";
 209         58 -> sLit "%f26"; 59 -> sLit "%f27";
 210         60 -> sLit "%f28"; 61 -> sLit "%f29";
 211         62 -> sLit "%f30"; 63 -> sLit "%f31";
 212         _  -> sLit "very naughty sparc register" })
 213
 214
 215 -- | Pretty print a size for an instruction suffix.
 216 pprSize :: Size -> Doc
 217 pprSize x
 218  = ptext
 219     (case x of
 220         II8     -> sLit "ub"
 221         II16    -> sLit "uh"
 222         II32    -> sLit ""
 223         II64    -> sLit "d"
 224         FF32    -> sLit ""
 225         FF64    -> sLit "d"
 226         _       -> panic "SPARC.Ppr.pprSize: no match")
 227
 228
 229 -- | Pretty print a size for an instruction suffix.
 230 --      eg LD is 32bit on sparc, but LDD is 64 bit.
 231 pprStSize :: Size -> Doc
 232 pprStSize x
 233  = ptext
 234     (case x of
 235         II8   -> sLit "b"
 236         II16  -> sLit "h"
 237         II32  -> sLit ""
 238         II64  -> sLit "x"
 239         FF32  -> sLit ""
 240         FF64  -> sLit "d"
 241         _       -> panic "SPARC.Ppr.pprSize: no match")
 242
 243
 244 -- | Pretty print a condition code.
 245 pprCond :: Cond -> Doc
 246 pprCond c
 247  = ptext
 248     (case c of
 249         ALWAYS  -> sLit ""
 250         NEVER   -> sLit "n"
 251         GEU     -> sLit "geu"
 252         LU      -> sLit "lu"
 253         EQQ     -> sLit "e"
 254         GTT     -> sLit "g"
 255         GE      -> sLit "ge"
 256         GU      -> sLit "gu"
 257         LTT     -> sLit "l"
 258         LE      -> sLit "le"
 259         LEU     -> sLit "leu"
 260         NE      -> sLit "ne"
 261         NEG     -> sLit "neg"
 262         POS     -> sLit "pos"
 263         VC      -> sLit "vc"
 264         VS      -> sLit "vs")
 265
 266
 267 -- | Pretty print an address mode.
 268 pprAddr :: AddrMode -> Doc
 269 pprAddr am
 270  = case am of
 271         AddrRegReg r1 (RegReal (RealRegSingle 0))
 272          -> pprReg r1
 273
 274         AddrRegReg r1 r2
 275          -> hcat [ pprReg r1, char '+', pprReg r2 ]
 276
 277         AddrRegImm r1 (ImmInt i)
 278          | i == 0               -> pprReg r1
 279          | not (fits13Bits i)   -> largeOffsetError i
 280          | otherwise            -> hcat [ pprReg r1, pp_sign, int i ]
 281          where
 282                 pp_sign = if i > 0 then char '+' else empty
 283
 284         AddrRegImm r1 (ImmInteger i)
 285          | i == 0               -> pprReg r1
 286          | not (fits13Bits i)   -> largeOffsetError i
 287          | otherwise            -> hcat [ pprReg r1, pp_sign, integer i ]
 288          where
 289                 pp_sign = if i > 0 then char '+' else empty
 290
 291         AddrRegImm r1 imm
 292          -> hcat [ pprReg r1, char '+', pprImm imm ]
 293
 294
 295 -- | Pretty print an immediate value.
 296 pprImm :: Imm -> Doc
 297 pprImm imm
 298  = case imm of
 299         ImmInt i        -> int i
 300         ImmInteger i    -> integer i
 301         ImmCLbl l       -> pprCLabel_asm l
 302         ImmIndex l i    -> pprCLabel_asm l <> char '+' <> int i
 303         ImmLit s        -> s
 304
 305         ImmConstantSum a b
 306          -> pprImm a <> char '+' <> pprImm b
 307
 308         ImmConstantDiff a b
 309          -> pprImm a <> char '-' <> lparen <> pprImm b <> rparen
 310
 311         LO i
 312          -> hcat [ text "%lo(", pprImm i, rparen ]
 313
 314         HI i
 315          -> hcat [ text "%hi(", pprImm i, rparen ]
 316
 317         -- these should have been converted to bytes and placed
 318         --      in the data section.
 319         ImmFloat _      -> ptext (sLit "naughty float immediate")
 320         ImmDouble _     -> ptext (sLit "naughty double immediate")
 321
 322
 323 -- | Pretty print a section \/ segment header.
 324 --      On SPARC all the data sections must be at least 8 byte aligned
 325 --      incase we store doubles in them.
 326 --
 327 pprSectionHeader :: Section -> Doc
 328 pprSectionHeader seg
 329  = case seg of
 330         Text                    -> ptext (sLit ".text\n\t.align 4")
 331         Data                    -> ptext (sLit ".data\n\t.align 8")
 332         ReadOnlyData            -> ptext (sLit ".text\n\t.align 8")
 333         RelocatableReadOnlyData -> ptext (sLit ".text\n\t.align 8")
 334         UninitialisedData       -> ptext (sLit ".bss\n\t.align 8")
 335         ReadOnlyData16          -> ptext (sLit ".data\n\t.align 16")
 336         OtherSection _          -> panic "PprMach.pprSectionHeader: unknown section"
 337
 338
 339 -- | Pretty print a data item.
 340 pprDataItem :: CmmLit -> Doc
 341 pprDataItem lit
 342   = vcat (ppr_item (cmmTypeSize $ cmmLitType lit) lit)
 343     where
 344         imm = litToImm lit
 345
 346         ppr_item II8   _        = [ptext (sLit "\t.byte\t") <> pprImm imm]
 347         ppr_item II32  _        = [ptext (sLit "\t.long\t") <> pprImm imm]
 348
 349         ppr_item FF32  (CmmFloat r _)
 350          = let bs = floatToBytes (fromRational r)
 351            in  map (\b -> ptext (sLit "\t.byte\t") <> pprImm (ImmInt b)) bs
 352
 353         ppr_item FF64 (CmmFloat r _)
 354          = let bs = doubleToBytes (fromRational r)
 355            in  map (\b -> ptext (sLit "\t.byte\t") <> pprImm (ImmInt b)) bs
 356
 357         ppr_item II16  _        = [ptext (sLit "\t.short\t") <> pprImm imm]
 358         ppr_item II64  _        = [ptext (sLit "\t.quad\t") <> pprImm imm]
 359         ppr_item _ _            = panic "SPARC.Ppr.pprDataItem: no match"
 360
 361
 362 -- | Pretty print an instruction.
 363 pprInstr :: Instr -> Doc
 364
 365 -- nuke comments.
 366 pprInstr (COMMENT _)
 367         = empty
 368
 369 pprInstr (DELTA d)
 370         = pprInstr (COMMENT (mkFastString ("\tdelta = " ++ show d)))
 371
 372 -- Newblocks and LData should have been slurped out before producing the .s file.
 373 pprInstr (NEWBLOCK _)
 374         = panic "X86.Ppr.pprInstr: NEWBLOCK"
 375
 376 pprInstr (LDATA _ _)
 377         = panic "PprMach.pprInstr: LDATA"
 378
 379 -- 64 bit FP loads are expanded into individual instructions in CodeGen.Expand
 380 pprInstr (LD FF64 _ reg)
 381         | RegReal (RealRegSingle{})     <- reg
 382         = panic "SPARC.Ppr: not emitting potentially misaligned LD FF64 instr"
 383
 384 pprInstr (LD size addr reg)
 385         = hcat [
 386                ptext (sLit "\tld"),
 387                pprSize size,
 388                char '\t',
 389                lbrack,
 390                pprAddr addr,
 391                pp_rbracket_comma,
 392                pprReg reg
 393             ]
 394
 395 -- 64 bit FP storees are expanded into individual instructions in CodeGen.Expand
 396 pprInstr (ST FF64 reg _)
 397         | RegReal (RealRegSingle{})     <- reg
 398         = panic "SPARC.Ppr: not emitting potentially misaligned ST FF64 instr"
 399
 400 -- no distinction is made between signed and unsigned bytes on stores for the
 401 -- Sparc opcodes (at least I cannot see any, and gas is nagging me --SOF),
 402 -- so we call a special-purpose pprSize for ST..
 403 pprInstr (ST size reg addr)
 404         = hcat [
 405                ptext (sLit "\tst"),
 406                pprStSize size,
 407                char '\t',
 408                pprReg reg,
 409                pp_comma_lbracket,
 410                pprAddr addr,
 411                rbrack
 412             ]
 413
 414
 415 pprInstr (ADD x cc reg1 ri reg2)
 416         | not x && not cc && riZero ri
 417         = hcat [ ptext (sLit "\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
 418
 419         | otherwise
 420         = pprRegRIReg (if x then sLit "addx" else sLit "add") cc reg1 ri reg2
 421
 422
 423 pprInstr (SUB x cc reg1 ri reg2)
 424         | not x && cc && reg2 == g0
 425         = hcat [ ptext (sLit "\tcmp\t"), pprReg reg1, comma, pprRI ri ]
 426
 427         | not x && not cc && riZero ri
 428         = hcat [ ptext (sLit "\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
 429
 430         | otherwise
 431         = pprRegRIReg (if x then sLit "subx" else sLit "sub") cc reg1 ri reg2
 432
 433 pprInstr (AND  b reg1 ri reg2)  = pprRegRIReg (sLit "and")  b reg1 ri reg2
 434
 435 pprInstr (ANDN b reg1 ri reg2)  = pprRegRIReg (sLit "andn") b reg1 ri reg2
 436
 437 pprInstr (OR b reg1 ri reg2)
 438         | not b && reg1 == g0
 439         = let doit = hcat [ ptext (sLit "\tmov\t"), pprRI ri, comma, pprReg reg2 ]
 440           in  case ri of
 441                    RIReg rrr | rrr == reg2 -> empty
 442                    _                       -> doit
 443
 444         | otherwise
 445         = pprRegRIReg (sLit "or") b reg1 ri reg2
 446
 447 pprInstr (ORN b reg1 ri reg2)   = pprRegRIReg (sLit "orn") b reg1 ri reg2
 448
 449 pprInstr (XOR  b reg1 ri reg2)  = pprRegRIReg (sLit "xor")  b reg1 ri reg2
 450 pprInstr (XNOR b reg1 ri reg2)  = pprRegRIReg (sLit "xnor") b reg1 ri reg2
 451
 452 pprInstr (SLL reg1 ri reg2)     = pprRegRIReg (sLit "sll") False reg1 ri reg2
 453 pprInstr (SRL reg1 ri reg2)     = pprRegRIReg (sLit "srl") False reg1 ri reg2
 454 pprInstr (SRA reg1 ri reg2)     = pprRegRIReg (sLit "sra") False reg1 ri reg2
 455
 456 pprInstr (RDY rd)               = ptext (sLit "\trd\t%y,") <> pprReg rd
 457 pprInstr (WRY reg1 reg2)
 458         = ptext (sLit "\twr\t")
 459                 <> pprReg reg1
 460                 <> char ','
 461                 <> pprReg reg2
 462                 <> char ','
 463                 <> ptext (sLit "%y")
 464
 465 pprInstr (SMUL b reg1 ri reg2)  = pprRegRIReg (sLit "smul")  b reg1 ri reg2
 466 pprInstr (UMUL b reg1 ri reg2)  = pprRegRIReg (sLit "umul")  b reg1 ri reg2
 467 pprInstr (SDIV b reg1 ri reg2)  = pprRegRIReg (sLit "sdiv")  b reg1 ri reg2
 468 pprInstr (UDIV b reg1 ri reg2)  = pprRegRIReg (sLit "udiv")  b reg1 ri reg2
 469
 470 pprInstr (SETHI imm reg)
 471   = hcat [
 472         ptext (sLit "\tsethi\t"),
 473         pprImm imm,
 474         comma,
 475         pprReg reg
 476     ]
 477
 478 pprInstr NOP
 479         = ptext (sLit "\tnop")
 480
 481 pprInstr (FABS size reg1 reg2)
 482         = pprSizeRegReg (sLit "fabs") size reg1 reg2
 483
 484 pprInstr (FADD size reg1 reg2 reg3)
 485         = pprSizeRegRegReg (sLit "fadd") size reg1 reg2 reg3
 486
 487 pprInstr (FCMP e size reg1 reg2)
 488         = pprSizeRegReg (if e then sLit "fcmpe" else sLit "fcmp") size reg1 reg2
 489
 490 pprInstr (FDIV size reg1 reg2 reg3)
 491         = pprSizeRegRegReg (sLit "fdiv") size reg1 reg2 reg3
 492
 493 pprInstr (FMOV size reg1 reg2)
 494         = pprSizeRegReg (sLit "fmov") size reg1 reg2
 495
 496 pprInstr (FMUL size reg1 reg2 reg3)
 497         = pprSizeRegRegReg (sLit "fmul") size reg1 reg2 reg3
 498
 499 pprInstr (FNEG size reg1 reg2)
 500         = pprSizeRegReg (sLit "fneg") size reg1 reg2
 501
 502 pprInstr (FSQRT size reg1 reg2)
 503         = pprSizeRegReg (sLit "fsqrt") size reg1 reg2
 504
 505 pprInstr (FSUB size reg1 reg2 reg3)
 506         = pprSizeRegRegReg (sLit "fsub") size reg1 reg2 reg3
 507
 508 pprInstr (FxTOy size1 size2 reg1 reg2)
 509   = hcat [
 510         ptext (sLit "\tf"),
 511         ptext
 512         (case size1 of
 513             II32  -> sLit "ito"
 514             FF32  -> sLit "sto"
 515             FF64  -> sLit "dto"
 516             _     -> panic "SPARC.Ppr.pprInstr.FxToY: no match"),
 517         ptext
 518         (case size2 of
 519             II32  -> sLit "i\t"
 520             II64  -> sLit "x\t"
 521             FF32  -> sLit "s\t"
 522             FF64  -> sLit "d\t"
 523             _     -> panic "SPARC.Ppr.pprInstr.FxToY: no match"),
 524         pprReg reg1, comma, pprReg reg2
 525     ]
 526
 527
 528 pprInstr (BI cond b (BlockId id))
 529   = hcat [
 530         ptext (sLit "\tb"), pprCond cond,
 531         if b then pp_comma_a else empty,
 532         char '\t',
 533         pprCLabel_asm (mkAsmTempLabel id)
 534     ]
 535
 536 pprInstr (BF cond b (BlockId id))
 537   = hcat [
 538         ptext (sLit "\tfb"), pprCond cond,
 539         if b then pp_comma_a else empty,
 540         char '\t',
 541         pprCLabel_asm (mkAsmTempLabel id)
 542     ]
 543
 544 pprInstr (JMP addr) = (<>) (ptext (sLit "\tjmp\t")) (pprAddr addr)
 545 pprInstr (JMP_TBL op _)  = pprInstr (JMP op)
 546
 547 pprInstr (CALL (Left imm) n _)
 548   = hcat [ ptext (sLit "\tcall\t"), pprImm imm, comma, int n ]
 549
 550 pprInstr (CALL (Right reg) n _)
 551   = hcat [ ptext (sLit "\tcall\t"), pprReg reg, comma, int n ]
 552
 553
 554 -- | Pretty print a RI
 555 pprRI :: RI -> Doc
 556 pprRI (RIReg r) = pprReg r
 557 pprRI (RIImm r) = pprImm r
 558
 559
 560 -- | Pretty print a two reg instruction.
 561 pprSizeRegReg :: LitString -> Size -> Reg -> Reg -> Doc
 562 pprSizeRegReg name size reg1 reg2
 563   = hcat [
 564         char '\t',
 565         ptext name,
 566         (case size of
 567             FF32 -> ptext (sLit "s\t")
 568             FF64 -> ptext (sLit "d\t")
 569             _    -> panic "SPARC.Ppr.pprSizeRegReg: no match"),
 570
 571         pprReg reg1,
 572         comma,
 573         pprReg reg2
 574     ]
 575
 576
 577 -- | Pretty print a three reg instruction.
 578 pprSizeRegRegReg :: LitString -> Size -> Reg -> Reg -> Reg -> Doc
 579 pprSizeRegRegReg name size reg1 reg2 reg3
 580   = hcat [
 581         char '\t',
 582         ptext name,
 583         (case size of
 584             FF32  -> ptext (sLit "s\t")
 585             FF64  -> ptext (sLit "d\t")
 586             _    -> panic "SPARC.Ppr.pprSizeRegReg: no match"),
 587         pprReg reg1,
 588         comma,
 589         pprReg reg2,
 590         comma,
 591         pprReg reg3
 592     ]
 593
 594
 595 -- | Pretty print an instruction of two regs and a ri.
 596 pprRegRIReg :: LitString -> Bool -> Reg -> RI -> Reg -> Doc
 597 pprRegRIReg name b reg1 ri reg2
 598   = hcat [
 599         char '\t',
 600         ptext name,
 601         if b then ptext (sLit "cc\t") else char '\t',
 602         pprReg reg1,
 603         comma,
 604         pprRI ri,
 605         comma,
 606         pprReg reg2
 607     ]
 608
 609 {-
 610 pprRIReg :: LitString -> Bool -> RI -> Reg -> Doc
 611 pprRIReg name b ri reg1
 612   = hcat [
 613         char '\t',
 614         ptext name,
 615         if b then ptext (sLit "cc\t") else char '\t',
 616         pprRI ri,
 617         comma,
 618         pprReg reg1
 619     ]
 620 -}
 621
 622 {-
 623 pp_ld_lbracket :: Doc
 624 pp_ld_lbracket    = ptext (sLit "\tld\t[")
 625 -}
 626
 627 pp_rbracket_comma :: Doc
 628 pp_rbracket_comma = text "],"
 629
 630
 631 pp_comma_lbracket :: Doc
 632 pp_comma_lbracket = text ",["
 633
 634
 635 pp_comma_a :: Doc
 636 pp_comma_a        = text ",a"
 637