2 % (c) The AQUA Project, Glasgow University, 1996-1998
4 \section[PprMach]{Pretty-printing assembly language}
6 We start with the @pprXXX@s with some cross-platform commonality
7 (e.g., @pprReg@); we conclude with the no-commonality monster,
11 #include "nativeGen/NCG.h"
13 module PprMach ( pprInstr, pprSize, pprUserReg ) where
15 #include "HsVersions.h"
17 import MachRegs -- may differ per-platform
20 import CLabel ( pprCLabel_asm, externallyVisibleCLabel, labelDynamic )
21 import CStrings ( charToC )
22 import Maybes ( maybeToBool )
23 import Stix ( CodeSegment(..), StixTree(..) )
24 import Char ( isPrint, isDigit )
32 %************************************************************************
34 \subsection{@pprReg@: print a @Reg@}
36 %************************************************************************
38 For x86, the way we print a register name depends
39 on which bit of it we care about. Yurgh.
41 pprUserReg:: Reg -> SDoc
42 pprUserReg = pprReg IF_ARCH_i386(L,)
45 pprReg :: IF_ARCH_i386(Size ->,) Reg -> SDoc
47 pprReg IF_ARCH_i386(s,) r
49 RealReg (I# i) -> ppr_reg_no IF_ARCH_i386(s,) i
50 VirtualRegI u -> text "%vI_" <> ppr u
51 VirtualRegF u -> text "%vF_" <> ppr u
54 ppr_reg_no :: FAST_REG_NO -> SDoc
57 ILIT( 0) -> SLIT("$0"); ILIT( 1) -> SLIT("$1");
58 ILIT( 2) -> SLIT("$2"); ILIT( 3) -> SLIT("$3");
59 ILIT( 4) -> SLIT("$4"); ILIT( 5) -> SLIT("$5");
60 ILIT( 6) -> SLIT("$6"); ILIT( 7) -> SLIT("$7");
61 ILIT( 8) -> SLIT("$8"); ILIT( 9) -> SLIT("$9");
62 ILIT(10) -> SLIT("$10"); ILIT(11) -> SLIT("$11");
63 ILIT(12) -> SLIT("$12"); ILIT(13) -> SLIT("$13");
64 ILIT(14) -> SLIT("$14"); ILIT(15) -> SLIT("$15");
65 ILIT(16) -> SLIT("$16"); ILIT(17) -> SLIT("$17");
66 ILIT(18) -> SLIT("$18"); ILIT(19) -> SLIT("$19");
67 ILIT(20) -> SLIT("$20"); ILIT(21) -> SLIT("$21");
68 ILIT(22) -> SLIT("$22"); ILIT(23) -> SLIT("$23");
69 ILIT(24) -> SLIT("$24"); ILIT(25) -> SLIT("$25");
70 ILIT(26) -> SLIT("$26"); ILIT(27) -> SLIT("$27");
71 ILIT(28) -> SLIT("$28"); ILIT(29) -> SLIT("$29");
72 ILIT(30) -> SLIT("$30"); ILIT(31) -> SLIT("$31");
73 ILIT(32) -> SLIT("$f0"); ILIT(33) -> SLIT("$f1");
74 ILIT(34) -> SLIT("$f2"); ILIT(35) -> SLIT("$f3");
75 ILIT(36) -> SLIT("$f4"); ILIT(37) -> SLIT("$f5");
76 ILIT(38) -> SLIT("$f6"); ILIT(39) -> SLIT("$f7");
77 ILIT(40) -> SLIT("$f8"); ILIT(41) -> SLIT("$f9");
78 ILIT(42) -> SLIT("$f10"); ILIT(43) -> SLIT("$f11");
79 ILIT(44) -> SLIT("$f12"); ILIT(45) -> SLIT("$f13");
80 ILIT(46) -> SLIT("$f14"); ILIT(47) -> SLIT("$f15");
81 ILIT(48) -> SLIT("$f16"); ILIT(49) -> SLIT("$f17");
82 ILIT(50) -> SLIT("$f18"); ILIT(51) -> SLIT("$f19");
83 ILIT(52) -> SLIT("$f20"); ILIT(53) -> SLIT("$f21");
84 ILIT(54) -> SLIT("$f22"); ILIT(55) -> SLIT("$f23");
85 ILIT(56) -> SLIT("$f24"); ILIT(57) -> SLIT("$f25");
86 ILIT(58) -> SLIT("$f26"); ILIT(59) -> SLIT("$f27");
87 ILIT(60) -> SLIT("$f28"); ILIT(61) -> SLIT("$f29");
88 ILIT(62) -> SLIT("$f30"); ILIT(63) -> SLIT("$f31");
89 _ -> SLIT("very naughty alpha register")
93 ppr_reg_no :: Size -> FAST_REG_NO -> SDoc
96 ILIT( 0) -> SLIT("%al"); ILIT( 1) -> SLIT("%bl");
97 ILIT( 2) -> SLIT("%cl"); ILIT( 3) -> SLIT("%dl");
98 _ -> SLIT("very naughty I386 byte register")
101 ppr_reg_no _ i = ptext
103 ILIT( 0) -> SLIT("%eax"); ILIT( 1) -> SLIT("%ebx");
104 ILIT( 2) -> SLIT("%ecx"); ILIT( 3) -> SLIT("%edx");
105 ILIT( 4) -> SLIT("%esi"); ILIT( 5) -> SLIT("%edi");
106 ILIT( 6) -> SLIT("%ebp"); ILIT( 7) -> SLIT("%esp");
107 ILIT( 8) -> SLIT("%fake0"); ILIT( 9) -> SLIT("%fake1");
108 ILIT(10) -> SLIT("%fake2"); ILIT(11) -> SLIT("%fake3");
109 ILIT(12) -> SLIT("%fake4"); ILIT(13) -> SLIT("%fake5");
110 _ -> SLIT("very naughty I386 register")
113 #if sparc_TARGET_ARCH
114 ppr_reg_no :: FAST_REG_NO -> SDoc
117 ILIT( 0) -> SLIT("%g0"); ILIT( 1) -> SLIT("%g1");
118 ILIT( 2) -> SLIT("%g2"); ILIT( 3) -> SLIT("%g3");
119 ILIT( 4) -> SLIT("%g4"); ILIT( 5) -> SLIT("%g5");
120 ILIT( 6) -> SLIT("%g6"); ILIT( 7) -> SLIT("%g7");
121 ILIT( 8) -> SLIT("%o0"); ILIT( 9) -> SLIT("%o1");
122 ILIT(10) -> SLIT("%o2"); ILIT(11) -> SLIT("%o3");
123 ILIT(12) -> SLIT("%o4"); ILIT(13) -> SLIT("%o5");
124 ILIT(14) -> SLIT("%o6"); ILIT(15) -> SLIT("%o7");
125 ILIT(16) -> SLIT("%l0"); ILIT(17) -> SLIT("%l1");
126 ILIT(18) -> SLIT("%l2"); ILIT(19) -> SLIT("%l3");
127 ILIT(20) -> SLIT("%l4"); ILIT(21) -> SLIT("%l5");
128 ILIT(22) -> SLIT("%l6"); ILIT(23) -> SLIT("%l7");
129 ILIT(24) -> SLIT("%i0"); ILIT(25) -> SLIT("%i1");
130 ILIT(26) -> SLIT("%i2"); ILIT(27) -> SLIT("%i3");
131 ILIT(28) -> SLIT("%i4"); ILIT(29) -> SLIT("%i5");
132 ILIT(30) -> SLIT("%i6"); ILIT(31) -> SLIT("%i7");
133 ILIT(32) -> SLIT("%f0"); ILIT(33) -> SLIT("%f1");
134 ILIT(34) -> SLIT("%f2"); ILIT(35) -> SLIT("%f3");
135 ILIT(36) -> SLIT("%f4"); ILIT(37) -> SLIT("%f5");
136 ILIT(38) -> SLIT("%f6"); ILIT(39) -> SLIT("%f7");
137 ILIT(40) -> SLIT("%f8"); ILIT(41) -> SLIT("%f9");
138 ILIT(42) -> SLIT("%f10"); ILIT(43) -> SLIT("%f11");
139 ILIT(44) -> SLIT("%f12"); ILIT(45) -> SLIT("%f13");
140 ILIT(46) -> SLIT("%f14"); ILIT(47) -> SLIT("%f15");
141 ILIT(48) -> SLIT("%f16"); ILIT(49) -> SLIT("%f17");
142 ILIT(50) -> SLIT("%f18"); ILIT(51) -> SLIT("%f19");
143 ILIT(52) -> SLIT("%f20"); ILIT(53) -> SLIT("%f21");
144 ILIT(54) -> SLIT("%f22"); ILIT(55) -> SLIT("%f23");
145 ILIT(56) -> SLIT("%f24"); ILIT(57) -> SLIT("%f25");
146 ILIT(58) -> SLIT("%f26"); ILIT(59) -> SLIT("%f27");
147 ILIT(60) -> SLIT("%f28"); ILIT(61) -> SLIT("%f29");
148 ILIT(62) -> SLIT("%f30"); ILIT(63) -> SLIT("%f31");
149 _ -> SLIT("very naughty sparc register")
154 %************************************************************************
156 \subsection{@pprSize@: print a @Size@}
158 %************************************************************************
161 pprSize :: Size -> SDoc
163 pprSize x = ptext (case x of
164 #if alpha_TARGET_ARCH
167 -- W -> SLIT("w") UNUSED
168 -- WU -> SLIT("wu") UNUSED
169 -- L -> SLIT("l") UNUSED
171 -- FF -> SLIT("f") UNUSED
172 -- DF -> SLIT("d") UNUSED
173 -- GF -> SLIT("g") UNUSED
174 -- SF -> SLIT("s") UNUSED
179 -- HB -> SLIT("b") UNUSED
180 -- S -> SLIT("w") UNUSED
186 #if sparc_TARGET_ARCH
189 -- HW -> SLIT("hw") UNUSED
190 -- HWU -> SLIT("uhw") UNUSED
193 -- D -> SLIT("d") UNUSED
196 pprStSize :: Size -> SDoc
197 pprStSize x = ptext (case x of
200 -- HW -> SLIT("hw") UNUSED
201 -- HWU -> SLIT("uhw") UNUSED
204 -- D -> SLIT("d") UNUSED
210 %************************************************************************
212 \subsection{@pprCond@: print a @Cond@}
214 %************************************************************************
217 pprCond :: Cond -> SDoc
219 pprCond c = ptext (case c of {
220 #if alpha_TARGET_ARCH
231 GEU -> SLIT("ae"); LU -> SLIT("b");
232 EQQ -> SLIT("e"); GTT -> SLIT("g");
233 GE -> SLIT("ge"); GU -> SLIT("a");
234 LTT -> SLIT("l"); LE -> SLIT("le");
235 LEU -> SLIT("be"); NE -> SLIT("ne");
236 NEG -> SLIT("s"); POS -> SLIT("ns");
237 ALWAYS -> SLIT("mp") -- hack
239 #if sparc_TARGET_ARCH
240 ALWAYS -> SLIT(""); NEVER -> SLIT("n");
241 GEU -> SLIT("geu"); LU -> SLIT("lu");
242 EQQ -> SLIT("e"); GTT -> SLIT("g");
243 GE -> SLIT("ge"); GU -> SLIT("gu");
244 LTT -> SLIT("l"); LE -> SLIT("le");
245 LEU -> SLIT("leu"); NE -> SLIT("ne");
246 NEG -> SLIT("neg"); POS -> SLIT("pos");
247 VC -> SLIT("vc"); VS -> SLIT("vs")
252 %************************************************************************
254 \subsection{@pprImm@: print an @Imm@}
256 %************************************************************************
259 pprImm :: Imm -> SDoc
261 pprImm (ImmInt i) = int i
262 pprImm (ImmInteger i) = integer i
263 pprImm (ImmCLbl l) = (if labelDynamic l then text "__imp_" else empty)
265 pprImm (ImmIndex l i) = (if labelDynamic l then text "__imp_" else empty)
266 <> pprCLabel_asm l <> char '+' <> int i
267 pprImm (ImmLit s) = s
269 pprImm (ImmLab dll s) = (if underscorePrefix then char '_' else empty)
270 <> (if dll then text "_imp__" else empty)
273 #if sparc_TARGET_ARCH
275 = hcat [ pp_lo, pprImm i, rparen ]
280 = hcat [ pp_hi, pprImm i, rparen ]
286 %************************************************************************
288 \subsection{@pprAddr@: print an @Addr@}
290 %************************************************************************
293 pprAddr :: MachRegsAddr -> SDoc
295 #if alpha_TARGET_ARCH
296 pprAddr (AddrReg r) = parens (pprReg r)
297 pprAddr (AddrImm i) = pprImm i
298 pprAddr (AddrRegImm r1 i)
299 = (<>) (pprImm i) (parens (pprReg r1))
305 pprAddr (ImmAddr imm off)
306 = let pp_imm = pprImm imm
310 else if (off < 0) then
313 pp_imm <> char '+' <> int off
315 pprAddr (AddrBaseIndex base index displacement)
317 pp_disp = ppr_disp displacement
318 pp_off p = pp_disp <> char '(' <> p <> char ')'
319 pp_reg r = pprReg L r
322 (Nothing, Nothing) -> pp_disp
323 (Just b, Nothing) -> pp_off (pp_reg b)
324 (Nothing, Just (r,i)) -> pp_off (pp_reg r <> comma <> int i)
325 (Just b, Just (r,i)) -> pp_off (pp_reg b <> comma <> pp_reg r
328 ppr_disp (ImmInt 0) = empty
329 ppr_disp imm = pprImm imm
334 #if sparc_TARGET_ARCH
335 pprAddr (AddrRegReg r1 (FixedReg ILIT(0))) = pprReg r1
337 pprAddr (AddrRegReg r1 r2)
338 = hcat [ pprReg r1, char '+', pprReg r2 ]
340 pprAddr (AddrRegImm r1 (ImmInt i))
342 | not (fits13Bits i) = largeOffsetError i
343 | otherwise = hcat [ pprReg r1, pp_sign, int i ]
345 pp_sign = if i > 0 then char '+' else empty
347 pprAddr (AddrRegImm r1 (ImmInteger i))
349 | not (fits13Bits i) = largeOffsetError i
350 | otherwise = hcat [ pprReg r1, pp_sign, integer i ]
352 pp_sign = if i > 0 then char '+' else empty
354 pprAddr (AddrRegImm r1 imm)
355 = hcat [ pprReg r1, char '+', pprImm imm ]
359 %************************************************************************
361 \subsection{@pprInstr@: print an @Instr@}
363 %************************************************************************
366 pprInstr :: Instr -> SDoc
368 --pprInstr (COMMENT s) = empty -- nuke 'em
370 = IF_ARCH_alpha( ((<>) (ptext SLIT("\t# ")) (ptext s))
371 ,IF_ARCH_sparc( ((<>) (ptext SLIT("! ")) (ptext s))
372 ,IF_ARCH_i386( ((<>) (ptext SLIT("# ")) (ptext s))
376 = pprInstr (COMMENT (_PK_ ("\tdelta = " ++ show d)))
378 pprInstr (SEGMENT TextSegment)
379 = IF_ARCH_alpha(ptext SLIT("\t.text\n\t.align 3") {-word boundary-}
380 ,IF_ARCH_sparc(ptext SLIT("\t.text\n\t.align 4") {-word boundary-}
381 ,IF_ARCH_i386((text ".text\n\t.align 4,0x90") {-needs per-OS variation!-}
384 pprInstr (SEGMENT DataSegment)
386 IF_ARCH_alpha(SLIT("\t.data\n\t.align 3")
387 ,IF_ARCH_sparc(SLIT("\t.data\n\t.align 8") {-<8 will break double constants -}
388 ,IF_ARCH_i386(SLIT(".data\n\t.align 4")
391 pprInstr (LABEL clab)
393 pp_lab = pprCLabel_asm clab
396 if not (externallyVisibleCLabel clab) then
400 IF_ARCH_alpha(SLIT("\t.globl\t")
401 ,IF_ARCH_i386(SLIT(".globl ")
402 ,IF_ARCH_sparc(SLIT("\t.global\t")
404 , pp_lab, char '\n'],
409 pprInstr (ASCII False{-no backslash conversion-} str)
410 = hcat [ ptext SLIT("\t.asciz "), char '\"', text str, char '"' ]
412 pprInstr (ASCII True str)
415 asciify :: String -> SDoc
416 asciify "" = text "\t.ascii \"\\0\""
418 = let fst = take 16 str
420 this = text ("\t.ascii \""
421 ++ concat (map asciify_char fst)
423 in this $$ asciify rest
424 asciify_char :: Char -> String
425 asciify_char c = '\\' : 'x' : hshow (ord c)
427 hshow :: Int -> String
428 hshow n | n >= 0 && n <= 255
429 = [ tab !! (n `div` 16), tab !! (n `mod` 16)]
430 tab = "0123456789abcdef"
435 = vcat (concatMap (ppr_item s) xs)
437 #if alpha_TARGET_ARCH
438 ppr_item = error "ppr_item on Alpha"
440 This needs to be fixed.
441 B -> SLIT("\t.byte\t")
442 BU -> SLIT("\t.byte\t")
443 Q -> SLIT("\t.quad\t")
444 TF -> SLIT("\t.t_floating\t")
447 #if sparc_TARGET_ARCH
448 ppr_item = error "ppr_item on Sparc"
450 This needs to be fixed.
451 B -> SLIT("\t.byte\t")
452 BU -> SLIT("\t.byte\t")
453 W -> SLIT("\t.word\t")
454 DF -> SLIT("\t.double\t")
458 ppr_item B x = [text "\t.byte\t" <> pprImm x]
459 ppr_item L x = [text "\t.long\t" <> pprImm x]
460 ppr_item F (ImmDouble r)
461 = let bs = floatToBytes (fromRational r)
462 in map (\b -> text "\t.byte\t" <> pprImm (ImmInt b)) bs
463 ppr_item DF (ImmDouble r)
464 = let bs = doubleToBytes (fromRational r)
465 in map (\b -> text "\t.byte\t" <> pprImm (ImmInt b)) bs
467 floatToBytes :: Float -> [Int]
470 arr <- newFloatArray ((0::Int),3)
471 writeFloatArray arr 0 f
472 i0 <- readCharArray arr 0
473 i1 <- readCharArray arr 1
474 i2 <- readCharArray arr 2
475 i3 <- readCharArray arr 3
476 return (map ord [i0,i1,i2,i3])
479 doubleToBytes :: Double -> [Int]
482 arr <- newDoubleArray ((0::Int),7)
483 writeDoubleArray arr 0 d
484 i0 <- readCharArray arr 0
485 i1 <- readCharArray arr 1
486 i2 <- readCharArray arr 2
487 i3 <- readCharArray arr 3
488 i4 <- readCharArray arr 4
489 i5 <- readCharArray arr 5
490 i6 <- readCharArray arr 6
491 i7 <- readCharArray arr 7
492 return (map ord [i0,i1,i2,i3,i4,i5,i6,i7])
497 -- fall through to rest of (machine-specific) pprInstr...
500 %************************************************************************
502 \subsubsection{@pprInstr@ for an Alpha}
504 %************************************************************************
507 #if alpha_TARGET_ARCH
509 pprInstr (LD size reg addr)
519 pprInstr (LDA reg addr)
521 ptext SLIT("\tlda\t"),
527 pprInstr (LDAH reg addr)
529 ptext SLIT("\tldah\t"),
535 pprInstr (LDGP reg addr)
537 ptext SLIT("\tldgp\t"),
543 pprInstr (LDI size reg imm)
553 pprInstr (ST size reg addr)
565 ptext SLIT("\tclr\t"),
569 pprInstr (ABS size ri reg)
579 pprInstr (NEG size ov ri reg)
583 if ov then ptext SLIT("v\t") else char '\t',
589 pprInstr (ADD size ov reg1 ri reg2)
593 if ov then ptext SLIT("v\t") else char '\t',
601 pprInstr (SADD size scale reg1 ri reg2)
603 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
614 pprInstr (SUB size ov reg1 ri reg2)
618 if ov then ptext SLIT("v\t") else char '\t',
626 pprInstr (SSUB size scale reg1 ri reg2)
628 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
639 pprInstr (MUL size ov reg1 ri reg2)
643 if ov then ptext SLIT("v\t") else char '\t',
651 pprInstr (DIV size uns reg1 ri reg2)
655 if uns then ptext SLIT("u\t") else char '\t',
663 pprInstr (REM size uns reg1 ri reg2)
667 if uns then ptext SLIT("u\t") else char '\t',
675 pprInstr (NOT ri reg)
684 pprInstr (AND reg1 ri reg2) = pprRegRIReg SLIT("and") reg1 ri reg2
685 pprInstr (ANDNOT reg1 ri reg2) = pprRegRIReg SLIT("andnot") reg1 ri reg2
686 pprInstr (OR reg1 ri reg2) = pprRegRIReg SLIT("or") reg1 ri reg2
687 pprInstr (ORNOT reg1 ri reg2) = pprRegRIReg SLIT("ornot") reg1 ri reg2
688 pprInstr (XOR reg1 ri reg2) = pprRegRIReg SLIT("xor") reg1 ri reg2
689 pprInstr (XORNOT reg1 ri reg2) = pprRegRIReg SLIT("xornot") reg1 ri reg2
691 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") reg1 ri reg2
692 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") reg1 ri reg2
693 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") reg1 ri reg2
695 pprInstr (ZAP reg1 ri reg2) = pprRegRIReg SLIT("zap") reg1 ri reg2
696 pprInstr (ZAPNOT reg1 ri reg2) = pprRegRIReg SLIT("zapnot") reg1 ri reg2
698 pprInstr (NOP) = ptext SLIT("\tnop")
700 pprInstr (CMP cond reg1 ri reg2)
714 ptext SLIT("\tfclr\t"),
718 pprInstr (FABS reg1 reg2)
720 ptext SLIT("\tfabs\t"),
726 pprInstr (FNEG size reg1 reg2)
736 pprInstr (FADD size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("add") size reg1 reg2 reg3
737 pprInstr (FDIV size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("div") size reg1 reg2 reg3
738 pprInstr (FMUL size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("mul") size reg1 reg2 reg3
739 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("sub") size reg1 reg2 reg3
741 pprInstr (CVTxy size1 size2 reg1 reg2)
745 case size2 of {Q -> ptext SLIT("qc"); _ -> pprSize size2},
752 pprInstr (FCMP size cond reg1 reg2 reg3)
765 pprInstr (FMOV reg1 reg2)
767 ptext SLIT("\tfmov\t"),
773 pprInstr (BI ALWAYS reg lab) = pprInstr (BR lab)
775 pprInstr (BI NEVER reg lab) = empty
777 pprInstr (BI cond reg lab)
787 pprInstr (BF cond reg lab)
798 = (<>) (ptext SLIT("\tbr\t")) (pprImm lab)
800 pprInstr (JMP reg addr hint)
802 ptext SLIT("\tjmp\t"),
811 = (<>) (ptext SLIT("\tbsr\t")) (pprImm imm)
813 pprInstr (JSR reg addr n)
815 ptext SLIT("\tjsr\t"),
821 pprInstr (FUNBEGIN clab)
823 if (externallyVisibleCLabel clab) then
824 hcat [ptext SLIT("\t.globl\t"), pp_lab, char '\n']
827 ptext SLIT("\t.ent "),
836 pp_lab = pprCLabel_asm clab
838 -- NEVER use commas within those string literals, cpp will ruin your day
839 pp_ldgp = hcat [ ptext SLIT(":\n\tldgp $29"), char ',', ptext SLIT("0($27)\n") ]
840 pp_frame = hcat [ ptext SLIT("..ng:\n\t.frame $30"), char ',',
841 ptext SLIT("4240"), char ',',
842 ptext SLIT("$26"), char ',',
843 ptext SLIT("0\n\t.prologue 1") ]
845 pprInstr (FUNEND clab)
846 = (<>) (ptext SLIT("\t.align 4\n\t.end ")) (pprCLabel_asm clab)
849 Continue with Alpha-only printing bits and bobs:
853 pprRI (RIReg r) = pprReg r
854 pprRI (RIImm r) = pprImm r
856 pprRegRIReg :: FAST_STRING -> Reg -> RI -> Reg -> SDoc
858 pprRegRIReg name reg1 ri reg2
870 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
872 pprSizeRegRegReg name size reg1 reg2 reg3
885 #endif {-alpha_TARGET_ARCH-}
888 %************************************************************************
890 \subsubsection{@pprInstr@ for an I386}
892 %************************************************************************
897 pprInstr v@(MOV size s@(OpReg src) d@(OpReg dst)) -- hack
900 #if 0 /* #ifdef DEBUG */
901 (<>) (ptext SLIT("# warning: ")) (pprSizeOpOp SLIT("mov") size s d)
905 pprInstr (MOV size src dst)
906 = pprSizeOpOp SLIT("mov") size src dst
907 pprInstr (MOVZxL sizes src dst) = pprSizeOpOpCoerce SLIT("movz") sizes L src dst
908 pprInstr (MOVSxL sizes src dst) = pprSizeOpOpCoerce SLIT("movs") sizes L src dst
910 -- here we do some patching, since the physical registers are only set late
911 -- in the code generation.
912 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
914 = pprSizeOpOp SLIT("add") size (OpReg reg2) dst
915 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
917 = pprSizeOpOp SLIT("add") size (OpReg reg1) dst
918 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) Nothing displ)) dst@(OpReg reg3))
920 = pprInstr (ADD size (OpImm displ) dst)
921 pprInstr (LEA size src dst) = pprSizeOpOp SLIT("lea") size src dst
923 pprInstr (ADD size (OpImm (ImmInt (-1))) dst)
924 = pprSizeOp SLIT("dec") size dst
925 pprInstr (ADD size (OpImm (ImmInt 1)) dst)
926 = pprSizeOp SLIT("inc") size dst
927 pprInstr (ADD size src dst)
928 = pprSizeOpOp SLIT("add") size src dst
929 pprInstr (SUB size src dst) = pprSizeOpOp SLIT("sub") size src dst
930 pprInstr (IMUL size op1 op2) = pprSizeOpOp SLIT("imul") size op1 op2
931 pprInstr (IDIV size op) = pprSizeOp SLIT("idiv") size op
933 pprInstr (AND size src dst) = pprSizeOpOp SLIT("and") size src dst
934 pprInstr (OR size src dst) = pprSizeOpOp SLIT("or") size src dst
935 pprInstr (XOR size src dst) = pprSizeOpOp SLIT("xor") size src dst
936 pprInstr (NOT size op) = pprSizeOp SLIT("not") size op
937 pprInstr (NEGI size op) = pprSizeOp SLIT("neg") size op
939 pprInstr (SHL size imm dst) = pprSizeImmOp SLIT("shl") size imm dst
940 pprInstr (SAR size imm dst) = pprSizeImmOp SLIT("sar") size imm dst
941 pprInstr (SHR size imm dst) = pprSizeImmOp SLIT("shr") size imm dst
942 pprInstr (BT size imm src) = pprSizeImmOp SLIT("bt") size imm src
944 pprInstr (CMP size src dst) = pprSizeOpOp SLIT("cmp") size src dst
945 pprInstr (TEST size src dst) = pprSizeOpOp SLIT("test") size src dst
946 pprInstr (PUSH size op) = pprSizeOp SLIT("push") size op
947 pprInstr (POP size op) = pprSizeOp SLIT("pop") size op
948 pprInstr PUSHA = ptext SLIT("\tpushal")
949 pprInstr POPA = ptext SLIT("\tpopal")
951 pprInstr (NOP) = ptext SLIT("\tnop")
952 pprInstr (CLTD) = ptext SLIT("\tcltd")
954 pprInstr (SETCC cond op) = pprCondInstr SLIT("set") cond (pprOperand B op)
956 pprInstr (JXX cond lab) = pprCondInstr SLIT("j") cond (pprCLabel_asm lab)
958 pprInstr (JMP (OpImm imm)) = (<>) (ptext SLIT("\tjmp ")) (pprImm imm)
959 pprInstr (JMP op) = (<>) (ptext SLIT("\tjmp *")) (pprOperand L op)
961 = (<>) (ptext SLIT("\tcall ")) (pprImm imm)
964 -- Simulating a flat register set on the x86 FP stack is tricky.
965 -- you have to free %st(7) before pushing anything on the FP reg stack
966 -- so as to preclude the possibility of a FP stack overflow exception.
967 pprInstr g@(GMOV src dst)
971 = pprG g (hcat [gtab, gpush src 0, gsemi, gpop dst 1])
973 -- GLD sz addr dst ==> FFREE %st(7) ; FLDsz addr ; FSTP (dst+1)
974 pprInstr g@(GLD sz addr dst)
975 = pprG g (hcat [gtab, text "ffree %st(7) ; fld", pprSize sz, gsp,
976 pprAddr addr, gsemi, gpop dst 1])
978 -- GST sz src addr ==> FFREE %st(7) ; FLD dst ; FSTPsz addr
979 pprInstr g@(GST sz src addr)
980 = pprG g (hcat [gtab, gpush src 0, gsemi,
981 text "fstp", pprSize sz, gsp, pprAddr addr])
983 pprInstr g@(GLDZ dst)
984 = pprG g (hcat [gtab, text "ffree %st(7) ; fldz ; ", gpop dst 1])
985 pprInstr g@(GLD1 dst)
986 = pprG g (hcat [gtab, text "ffree %st(7) ; fld1 ; ", gpop dst 1])
988 pprInstr g@(GFTOD src dst)
990 pprInstr g@(GFTOI src dst)
993 pprInstr g@(GDTOF src dst)
995 pprInstr g@(GDTOI src dst)
998 pprInstr g@(GITOF src dst)
999 = pprInstr (GITOD src dst)
1000 pprInstr g@(GITOD src dst)
1001 = pprG g (hcat [gtab, text "pushl ", pprReg L src,
1002 text " ; ffree %st(7); fildl (%esp) ; ",
1003 gpop dst 1, text " ; addl $4,%esp"])
1005 pprInstr g@(GCMP sz src1 src2)
1006 = pprG g (hcat [gtab, text "pushl %eax ; ",gpush src1 0]
1008 hcat [gtab, text "fcomp ", greg src2 1,
1009 text "; fstsw %ax ; sahf ; popl %eax"])
1011 pprInstr g@(GABS sz src dst)
1012 = pprG g (hcat [gtab, gpush src 0, text " ; fabs ; ", gpop dst 1])
1013 pprInstr g@(GNEG sz src dst)
1014 = pprG g (hcat [gtab, gpush src 0, text " ; fchs ; ", gpop dst 1])
1016 pprInstr g@(GSQRT sz src dst)
1017 = pprG g (hcat [gtab, gpush src 0, text " ; fsqrt"] $$
1018 hcat [gtab, gcoerceto sz, gpop dst 1])
1019 pprInstr g@(GSIN sz src dst)
1020 = pprG g (hcat [gtab, gpush src 0, text " ; fsin"] $$
1021 hcat [gtab, gcoerceto sz, gpop dst 1])
1022 pprInstr g@(GCOS sz src dst)
1023 = pprG g (hcat [gtab, gpush src 0, text " ; fcos"] $$
1024 hcat [gtab, gcoerceto sz, gpop dst 1])
1025 pprInstr g@(GTAN sz src dst)
1026 = pprG g (hcat [gtab, text "ffree %st(6) ; ",
1027 gpush src 0, text " ; fptan ; ",
1028 text " fstp %st(0)"] $$
1029 hcat [gtab, gcoerceto sz, gpop dst 1])
1031 -- In the translations for GADD, GMUL, GSUB and GDIV,
1032 -- the first two cases are mere optimisations. The otherwise clause
1033 -- generates correct code under all circumstances.
1035 pprInstr g@(GADD sz src1 src2 dst)
1037 = pprG g (text "\t#GADD-xxxcase1" $$
1038 hcat [gtab, gpush src2 0,
1039 text " ; faddp %st(0),", greg src1 1])
1041 = pprG g (text "\t#GADD-xxxcase2" $$
1042 hcat [gtab, gpush src1 0,
1043 text " ; faddp %st(0),", greg src2 1])
1045 = pprG g (hcat [gtab, gpush src1 0,
1046 text " ; fadd ", greg src2 1, text ",%st(0)",
1050 pprInstr g@(GMUL sz src1 src2 dst)
1052 = pprG g (text "\t#GMUL-xxxcase1" $$
1053 hcat [gtab, gpush src2 0,
1054 text " ; fmulp %st(0),", greg src1 1])
1056 = pprG g (text "\t#GMUL-xxxcase2" $$
1057 hcat [gtab, gpush src1 0,
1058 text " ; fmulp %st(0),", greg src2 1])
1060 = pprG g (hcat [gtab, gpush src1 0,
1061 text " ; fmul ", greg src2 1, text ",%st(0)",
1065 pprInstr g@(GSUB sz src1 src2 dst)
1067 = pprG g (text "\t#GSUB-xxxcase1" $$
1068 hcat [gtab, gpush src2 0,
1069 text " ; fsubrp %st(0),", greg src1 1])
1071 = pprG g (text "\t#GSUB-xxxcase2" $$
1072 hcat [gtab, gpush src1 0,
1073 text " ; fsubp %st(0),", greg src2 1])
1075 = pprG g (hcat [gtab, gpush src1 0,
1076 text " ; fsub ", greg src2 1, text ",%st(0)",
1080 pprInstr g@(GDIV sz src1 src2 dst)
1082 = pprG g (text "\t#GDIV-xxxcase1" $$
1083 hcat [gtab, gpush src2 0,
1084 text " ; fdivrp %st(0),", greg src1 1])
1086 = pprG g (text "\t#GDIV-xxxcase2" $$
1087 hcat [gtab, gpush src1 0,
1088 text " ; fdivp %st(0),", greg src2 1])
1090 = pprG g (hcat [gtab, gpush src1 0,
1091 text " ; fdiv ", greg src2 1, text ",%st(0)",
1096 = vcat [ ptext SLIT("\tffree %st(0) ;ffree %st(1) ;ffree %st(2) ;ffree %st(3)"),
1097 ptext SLIT("\tffree %st(4) ;ffree %st(5) ;ffree %st(6) ;ffree %st(7)")
1100 --------------------------
1102 -- coerce %st(0) to the specified size
1103 gcoerceto DF = empty
1104 gcoerceto F = text "subl $4,%esp ; fstps (%esp) ; flds (%esp) ; addl $4,%esp ; "
1107 = hcat [text "ffree %st(7) ; fld ", greg reg offset]
1109 = hcat [text "fstp ", greg reg offset]
1111 bogus = text "\tbogus"
1112 greg reg offset = text "%st(" <> int (gregno reg - 8+offset) <> char ')'
1117 gregno (RealReg i) = i
1118 gregno other = --pprPanic "gregno" (ppr other)
1119 999 -- bogus; only needed for debug printing
1121 pprG :: Instr -> SDoc -> SDoc
1123 = (char '#' <> pprGInstr fake) $$ actual
1125 pprGInstr (GMOV src dst) = pprSizeRegReg SLIT("gmov") DF src dst
1126 pprGInstr (GLD sz src dst) = pprSizeAddrReg SLIT("gld") sz src dst
1127 pprGInstr (GST sz src dst) = pprSizeRegAddr SLIT("gst") sz src dst
1129 pprGInstr (GLDZ dst) = pprSizeReg SLIT("gldz") DF dst
1130 pprGInstr (GLD1 dst) = pprSizeReg SLIT("gld1") DF dst
1132 pprGInstr (GFTOD src dst) = pprSizeSizeRegReg SLIT("gftod") F DF src dst
1133 pprGInstr (GFTOI src dst) = pprSizeSizeRegReg SLIT("gftoi") F L src dst
1135 pprGInstr (GDTOF src dst) = pprSizeSizeRegReg SLIT("gdtof") DF F src dst
1136 pprGInstr (GDTOI src dst) = pprSizeSizeRegReg SLIT("gdtoi") DF L src dst
1138 pprGInstr (GITOF src dst) = pprSizeSizeRegReg SLIT("gitof") L F src dst
1139 pprGInstr (GITOD src dst) = pprSizeSizeRegReg SLIT("gitod") L DF src dst
1141 pprGInstr (GCMP sz src dst) = pprSizeRegReg SLIT("gcmp") sz src dst
1142 pprGInstr (GABS sz src dst) = pprSizeRegReg SLIT("gabs") sz src dst
1143 pprGInstr (GNEG sz src dst) = pprSizeRegReg SLIT("gneg") sz src dst
1144 pprGInstr (GSQRT sz src dst) = pprSizeRegReg SLIT("gsqrt") sz src dst
1145 pprGInstr (GSIN sz src dst) = pprSizeRegReg SLIT("gsin") sz src dst
1146 pprGInstr (GCOS sz src dst) = pprSizeRegReg SLIT("gcos") sz src dst
1147 pprGInstr (GTAN sz src dst) = pprSizeRegReg SLIT("gtan") sz src dst
1149 pprGInstr (GADD sz src1 src2 dst) = pprSizeRegRegReg SLIT("gadd") sz src1 src2 dst
1150 pprGInstr (GSUB sz src1 src2 dst) = pprSizeRegRegReg SLIT("gsub") sz src1 src2 dst
1151 pprGInstr (GMUL sz src1 src2 dst) = pprSizeRegRegReg SLIT("gmul") sz src1 src2 dst
1152 pprGInstr (GDIV sz src1 src2 dst) = pprSizeRegRegReg SLIT("gdiv") sz src1 src2 dst
1155 Continue with I386-only printing bits and bobs:
1157 pprDollImm :: Imm -> SDoc
1159 pprDollImm i = ptext SLIT("$") <> pprImm i
1161 pprOperand :: Size -> Operand -> SDoc
1162 pprOperand s (OpReg r) = pprReg s r
1163 pprOperand s (OpImm i) = pprDollImm i
1164 pprOperand s (OpAddr ea) = pprAddr ea
1166 pprSizeImmOp :: FAST_STRING -> Size -> Imm -> Operand -> SDoc
1167 pprSizeImmOp name size imm op1
1179 pprSizeOp :: FAST_STRING -> Size -> Operand -> SDoc
1180 pprSizeOp name size op1
1189 pprSizeOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1190 pprSizeOpOp name size op1 op2
1196 pprOperand size op1,
1201 pprSizeByteOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1202 pprSizeByteOpOp name size op1 op2
1213 pprSizeOpReg :: FAST_STRING -> Size -> Operand -> Reg -> SDoc
1214 pprSizeOpReg name size op1 reg
1220 pprOperand size op1,
1225 pprSizeReg :: FAST_STRING -> Size -> Reg -> SDoc
1226 pprSizeReg name size reg1
1235 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1236 pprSizeRegReg name size reg1 reg2
1247 pprSizeSizeRegReg :: FAST_STRING -> Size -> Size -> Reg -> Reg -> SDoc
1248 pprSizeSizeRegReg name size1 size2 reg1 reg2
1260 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1261 pprSizeRegRegReg name size reg1 reg2 reg3
1274 pprSizeAddr :: FAST_STRING -> Size -> MachRegsAddr -> SDoc
1275 pprSizeAddr name size op
1284 pprSizeAddrReg :: FAST_STRING -> Size -> MachRegsAddr -> Reg -> SDoc
1285 pprSizeAddrReg name size op dst
1296 pprSizeRegAddr :: FAST_STRING -> Size -> Reg -> MachRegsAddr -> SDoc
1297 pprSizeRegAddr name size src op
1308 pprOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1309 pprOpOp name size op1 op2
1313 pprOperand size op1,
1318 pprSizeOpOpCoerce :: FAST_STRING -> Size -> Size -> Operand -> Operand -> SDoc
1319 pprSizeOpOpCoerce name size1 size2 op1 op2
1320 = hcat [ char '\t', ptext name, pprSize size1, pprSize size2, space,
1321 pprOperand size1 op1,
1323 pprOperand size2 op2
1326 pprCondInstr :: FAST_STRING -> Cond -> SDoc -> SDoc
1327 pprCondInstr name cond arg
1328 = hcat [ char '\t', ptext name, pprCond cond, space, arg]
1330 #endif {-i386_TARGET_ARCH-}
1333 %************************************************************************
1335 \subsubsection{@pprInstr@ for a SPARC}
1337 %************************************************************************
1340 #if sparc_TARGET_ARCH
1342 -- a clumsy hack for now, to handle possible double alignment problems
1344 -- even clumsier, to allow for RegReg regs that show when doing indexed
1345 -- reads (bytearrays).
1347 pprInstr (LD DF (AddrRegReg g1 g2) reg)
1349 ptext SLIT("\tadd\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1, char '\n',
1350 pp_ld_lbracket, pprReg g1, pp_rbracket_comma, pprReg reg, char '\n',
1351 pp_ld_lbracket, pprReg g1, ptext SLIT("+4]"), comma, pprReg (fPair reg)
1354 pprInstr (LD DF addr reg) | maybeToBool off_addr
1368 off_addr = addrOffset addr 4
1369 addr2 = case off_addr of Just x -> x
1371 pprInstr (LD size addr reg)
1382 -- The same clumsy hack as above
1384 pprInstr (ST DF reg (AddrRegReg g1 g2))
1386 ptext SLIT("\tadd\t"),
1387 pprReg g1,comma,pprReg g2,comma,pprReg g1, char '\n',
1388 ptext SLIT("\tst\t"),
1389 pprReg reg, pp_comma_lbracket, pprReg g1,
1390 ptext SLIT("]\n\tst\t"),
1391 pprReg (fPair reg), pp_comma_lbracket, pprReg g1, ptext SLIT("+4]")
1394 pprInstr (ST DF reg addr) | maybeToBool off_addr
1396 ptext SLIT("\tst\t"),
1397 pprReg reg, pp_comma_lbracket, pprAddr addr,
1399 ptext SLIT("]\n\tst\t"),
1400 pprReg (fPair reg), pp_comma_lbracket,
1401 pprAddr addr2, rbrack
1404 off_addr = addrOffset addr 4
1405 addr2 = case off_addr of Just x -> x
1407 -- no distinction is made between signed and unsigned bytes on stores for the
1408 -- Sparc opcodes (at least I cannot see any, and gas is nagging me --SOF),
1409 -- so we call a special-purpose pprSize for ST..
1411 pprInstr (ST size reg addr)
1422 pprInstr (ADD x cc reg1 ri reg2)
1423 | not x && not cc && riZero ri
1424 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1426 = pprRegRIReg (if x then SLIT("addx") else SLIT("add")) cc reg1 ri reg2
1428 pprInstr (SUB x cc reg1 ri reg2)
1429 | not x && cc && reg2 == g0
1430 = hcat [ ptext SLIT("\tcmp\t"), pprReg reg1, comma, pprRI ri ]
1431 | not x && not cc && riZero ri
1432 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1434 = pprRegRIReg (if x then SLIT("subx") else SLIT("sub")) cc reg1 ri reg2
1436 pprInstr (AND b reg1 ri reg2) = pprRegRIReg SLIT("and") b reg1 ri reg2
1437 pprInstr (ANDN b reg1 ri reg2) = pprRegRIReg SLIT("andn") b reg1 ri reg2
1439 pprInstr (OR b reg1 ri reg2)
1440 | not b && reg1 == g0
1441 = hcat [ ptext SLIT("\tmov\t"), pprRI ri, comma, pprReg reg2 ]
1443 = pprRegRIReg SLIT("or") b reg1 ri reg2
1445 pprInstr (ORN b reg1 ri reg2) = pprRegRIReg SLIT("orn") b reg1 ri reg2
1447 pprInstr (XOR b reg1 ri reg2) = pprRegRIReg SLIT("xor") b reg1 ri reg2
1448 pprInstr (XNOR b reg1 ri reg2) = pprRegRIReg SLIT("xnor") b reg1 ri reg2
1450 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") False reg1 ri reg2
1451 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") False reg1 ri reg2
1452 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") False reg1 ri reg2
1454 pprInstr (SETHI imm reg)
1456 ptext SLIT("\tsethi\t"),
1462 pprInstr NOP = ptext SLIT("\tnop")
1464 pprInstr (FABS F reg1 reg2) = pprSizeRegReg SLIT("fabs") F reg1 reg2
1465 pprInstr (FABS DF reg1 reg2)
1466 = (<>) (pprSizeRegReg SLIT("fabs") F reg1 reg2)
1467 (if (reg1 == reg2) then empty
1468 else (<>) (char '\n')
1469 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1471 pprInstr (FADD size reg1 reg2 reg3)
1472 = pprSizeRegRegReg SLIT("fadd") size reg1 reg2 reg3
1473 pprInstr (FCMP e size reg1 reg2)
1474 = pprSizeRegReg (if e then SLIT("fcmpe") else SLIT("fcmp")) size reg1 reg2
1475 pprInstr (FDIV size reg1 reg2 reg3)
1476 = pprSizeRegRegReg SLIT("fdiv") size reg1 reg2 reg3
1478 pprInstr (FMOV F reg1 reg2) = pprSizeRegReg SLIT("fmov") F reg1 reg2
1479 pprInstr (FMOV DF reg1 reg2)
1480 = (<>) (pprSizeRegReg SLIT("fmov") F reg1 reg2)
1481 (if (reg1 == reg2) then empty
1482 else (<>) (char '\n')
1483 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1485 pprInstr (FMUL size reg1 reg2 reg3)
1486 = pprSizeRegRegReg SLIT("fmul") size reg1 reg2 reg3
1488 pprInstr (FNEG F reg1 reg2) = pprSizeRegReg SLIT("fneg") F reg1 reg2
1489 pprInstr (FNEG DF reg1 reg2)
1490 = (<>) (pprSizeRegReg SLIT("fneg") F reg1 reg2)
1491 (if (reg1 == reg2) then empty
1492 else (<>) (char '\n')
1493 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1495 pprInstr (FSQRT size reg1 reg2) = pprSizeRegReg SLIT("fsqrt") size reg1 reg2
1496 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("fsub") size reg1 reg2 reg3
1497 pprInstr (FxTOy size1 size2 reg1 reg2)
1510 pprReg reg1, comma, pprReg reg2
1514 pprInstr (BI cond b lab)
1516 ptext SLIT("\tb"), pprCond cond,
1517 if b then pp_comma_a else empty,
1522 pprInstr (BF cond b lab)
1524 ptext SLIT("\tfb"), pprCond cond,
1525 if b then pp_comma_a else empty,
1530 pprInstr (JMP addr) = (<>) (ptext SLIT("\tjmp\t")) (pprAddr addr)
1532 pprInstr (CALL imm n _)
1533 = hcat [ ptext SLIT("\tcall\t"), pprImm imm, comma, int n ]
1536 Continue with SPARC-only printing bits and bobs:
1539 pprRI (RIReg r) = pprReg r
1540 pprRI (RIImm r) = pprImm r
1542 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1543 pprSizeRegReg name size reg1 reg2
1548 F -> ptext SLIT("s\t")
1549 DF -> ptext SLIT("d\t")),
1555 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1556 pprSizeRegRegReg name size reg1 reg2 reg3
1561 F -> ptext SLIT("s\t")
1562 DF -> ptext SLIT("d\t")),
1570 pprRegRIReg :: FAST_STRING -> Bool -> Reg -> RI -> Reg -> SDoc
1571 pprRegRIReg name b reg1 ri reg2
1575 if b then ptext SLIT("cc\t") else char '\t',
1583 pprRIReg :: FAST_STRING -> Bool -> RI -> Reg -> SDoc
1584 pprRIReg name b ri reg1
1588 if b then ptext SLIT("cc\t") else char '\t',
1594 pp_ld_lbracket = ptext SLIT("\tld\t[")
1595 pp_rbracket_comma = text "],"
1596 pp_comma_lbracket = text ",["
1597 pp_comma_a = text ",a"
1599 #endif {-sparc_TARGET_ARCH-}