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 FixedReg i -> ppr_reg_no IF_ARCH_i386(s,) i
50 MappedReg i -> ppr_reg_no IF_ARCH_i386(s,) i
51 other -> text (show other) -- should only happen when debugging
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
94 ppr_reg_no B i = ptext
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)
413 = --(<>) (text "\t.ascii \"") (asciify 60 str)
416 asciify :: String -> SDoc
417 asciify "" = text "\t.ascii \"\\0\""
419 = let fst = take 16 str
421 this = text ("\t.ascii \""
422 ++ concat (map asciify_char fst)
424 in this $$ asciify rest
425 asciify_char :: Char -> String
426 asciify_char c = '\\' : 'x' : hshow (ord c)
428 hshow :: Int -> String
429 hshow n | n >= 0 && n <= 255
430 = [ tab !! (n `div` 16), tab !! (n `mod` 16)]
431 tab = "0123456789abcdef"
434 asciify :: String -> Int -> SDoc
435 asciify [] _ = text "\\0\""
436 asciify s n | n <= 0 = (<>) (text "\"\n\t.ascii \"") (asciify s 60)
437 asciify ('\\':cs) n = (<>) (text "\\\\") (asciify cs (n-1))
438 asciify ('\"':cs) n = (<>) (text "\\\"") (asciify cs (n-1))
439 asciify (c:cs) n | isPrint c = (<>) (char c) (asciify cs (n-1))
440 asciify [c] _ = (<>) (text (charToC c)) (text ("\\0\"")){-"-}
441 asciify (c:(cs@(d:_))) n
442 | isDigit d = (<>) (text (charToC c)) (asciify cs 0)
443 | otherwise = (<>) (text (charToC c)) (asciify cs (n-1))
444 asciify [] _ = text "\\0\
449 = vcat [(<>) (ptext pp_size) (pprImm x) | x <- xs]
452 #if alpha_TARGET_ARCH
453 B -> SLIT("\t.byte\t")
454 BU -> SLIT("\t.byte\t")
455 Q -> SLIT("\t.quad\t")
456 TF -> SLIT("\t.t_floating\t")
459 B -> SLIT("\t.byte\t")
460 L -> SLIT("\t.long\t")
461 F -> SLIT("\t.float\t")
462 DF -> SLIT("\t.double\t")
464 #if sparc_TARGET_ARCH
465 B -> SLIT("\t.byte\t")
466 BU -> SLIT("\t.byte\t")
467 W -> SLIT("\t.word\t")
468 DF -> SLIT("\t.double\t")
474 = vcat (concatMap (ppr_item s) xs)
476 #if alpha_TARGET_ARCH
477 ppr_item = error "ppr_item on Alpha"
479 This needs to be fixed.
480 B -> SLIT("\t.byte\t")
481 BU -> SLIT("\t.byte\t")
482 Q -> SLIT("\t.quad\t")
483 TF -> SLIT("\t.t_floating\t")
486 #if sparc_TARGET_ARCH
487 ppr_item = error "ppr_item on Sparc"
489 This needs to be fixed.
490 B -> SLIT("\t.byte\t")
491 BU -> SLIT("\t.byte\t")
492 W -> SLIT("\t.word\t")
493 DF -> SLIT("\t.double\t")
497 ppr_item B x = [text "\t.byte\t" <> pprImm x]
498 ppr_item L x = [text "\t.long\t" <> pprImm x]
499 ppr_item F (ImmDouble r)
500 = let bs = floatToBytes (fromRational r)
501 in map (\b -> text "\t.byte\t" <> pprImm (ImmInt b)) bs
502 ppr_item DF (ImmDouble r)
503 = let bs = doubleToBytes (fromRational r)
504 in map (\b -> text "\t.byte\t" <> pprImm (ImmInt b)) bs
506 floatToBytes :: Float -> [Int]
509 arr <- newFloatArray ((0::Int),3)
510 writeFloatArray arr 0 f
511 i0 <- readCharArray arr 0
512 i1 <- readCharArray arr 1
513 i2 <- readCharArray arr 2
514 i3 <- readCharArray arr 3
515 return (map ord [i0,i1,i2,i3])
518 doubleToBytes :: Double -> [Int]
521 arr <- newDoubleArray ((0::Int),7)
522 writeDoubleArray arr 0 d
523 i0 <- readCharArray arr 0
524 i1 <- readCharArray arr 1
525 i2 <- readCharArray arr 2
526 i3 <- readCharArray arr 3
527 i4 <- readCharArray arr 4
528 i5 <- readCharArray arr 5
529 i6 <- readCharArray arr 6
530 i7 <- readCharArray arr 7
531 return (map ord [i0,i1,i2,i3,i4,i5,i6,i7])
536 -- fall through to rest of (machine-specific) pprInstr...
539 %************************************************************************
541 \subsubsection{@pprInstr@ for an Alpha}
543 %************************************************************************
546 #if alpha_TARGET_ARCH
548 pprInstr (LD size reg addr)
558 pprInstr (LDA reg addr)
560 ptext SLIT("\tlda\t"),
566 pprInstr (LDAH reg addr)
568 ptext SLIT("\tldah\t"),
574 pprInstr (LDGP reg addr)
576 ptext SLIT("\tldgp\t"),
582 pprInstr (LDI size reg imm)
592 pprInstr (ST size reg addr)
604 ptext SLIT("\tclr\t"),
608 pprInstr (ABS size ri reg)
618 pprInstr (NEG size ov ri reg)
622 if ov then ptext SLIT("v\t") else char '\t',
628 pprInstr (ADD size ov reg1 ri reg2)
632 if ov then ptext SLIT("v\t") else char '\t',
640 pprInstr (SADD size scale reg1 ri reg2)
642 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
653 pprInstr (SUB size ov reg1 ri reg2)
657 if ov then ptext SLIT("v\t") else char '\t',
665 pprInstr (SSUB size scale reg1 ri reg2)
667 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
678 pprInstr (MUL size ov reg1 ri reg2)
682 if ov then ptext SLIT("v\t") else char '\t',
690 pprInstr (DIV size uns reg1 ri reg2)
694 if uns then ptext SLIT("u\t") else char '\t',
702 pprInstr (REM size uns reg1 ri reg2)
706 if uns then ptext SLIT("u\t") else char '\t',
714 pprInstr (NOT ri reg)
723 pprInstr (AND reg1 ri reg2) = pprRegRIReg SLIT("and") reg1 ri reg2
724 pprInstr (ANDNOT reg1 ri reg2) = pprRegRIReg SLIT("andnot") reg1 ri reg2
725 pprInstr (OR reg1 ri reg2) = pprRegRIReg SLIT("or") reg1 ri reg2
726 pprInstr (ORNOT reg1 ri reg2) = pprRegRIReg SLIT("ornot") reg1 ri reg2
727 pprInstr (XOR reg1 ri reg2) = pprRegRIReg SLIT("xor") reg1 ri reg2
728 pprInstr (XORNOT reg1 ri reg2) = pprRegRIReg SLIT("xornot") reg1 ri reg2
730 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") reg1 ri reg2
731 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") reg1 ri reg2
732 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") reg1 ri reg2
734 pprInstr (ZAP reg1 ri reg2) = pprRegRIReg SLIT("zap") reg1 ri reg2
735 pprInstr (ZAPNOT reg1 ri reg2) = pprRegRIReg SLIT("zapnot") reg1 ri reg2
737 pprInstr (NOP) = ptext SLIT("\tnop")
739 pprInstr (CMP cond reg1 ri reg2)
753 ptext SLIT("\tfclr\t"),
757 pprInstr (FABS reg1 reg2)
759 ptext SLIT("\tfabs\t"),
765 pprInstr (FNEG size reg1 reg2)
775 pprInstr (FADD size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("add") size reg1 reg2 reg3
776 pprInstr (FDIV size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("div") size reg1 reg2 reg3
777 pprInstr (FMUL size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("mul") size reg1 reg2 reg3
778 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("sub") size reg1 reg2 reg3
780 pprInstr (CVTxy size1 size2 reg1 reg2)
784 case size2 of {Q -> ptext SLIT("qc"); _ -> pprSize size2},
791 pprInstr (FCMP size cond reg1 reg2 reg3)
804 pprInstr (FMOV reg1 reg2)
806 ptext SLIT("\tfmov\t"),
812 pprInstr (BI ALWAYS reg lab) = pprInstr (BR lab)
814 pprInstr (BI NEVER reg lab) = empty
816 pprInstr (BI cond reg lab)
826 pprInstr (BF cond reg lab)
837 = (<>) (ptext SLIT("\tbr\t")) (pprImm lab)
839 pprInstr (JMP reg addr hint)
841 ptext SLIT("\tjmp\t"),
850 = (<>) (ptext SLIT("\tbsr\t")) (pprImm imm)
852 pprInstr (JSR reg addr n)
854 ptext SLIT("\tjsr\t"),
860 pprInstr (FUNBEGIN clab)
862 if (externallyVisibleCLabel clab) then
863 hcat [ptext SLIT("\t.globl\t"), pp_lab, char '\n']
866 ptext SLIT("\t.ent "),
875 pp_lab = pprCLabel_asm clab
877 -- NEVER use commas within those string literals, cpp will ruin your day
878 pp_ldgp = hcat [ ptext SLIT(":\n\tldgp $29"), char ',', ptext SLIT("0($27)\n") ]
879 pp_frame = hcat [ ptext SLIT("..ng:\n\t.frame $30"), char ',',
880 ptext SLIT("4240"), char ',',
881 ptext SLIT("$26"), char ',',
882 ptext SLIT("0\n\t.prologue 1") ]
884 pprInstr (FUNEND clab)
885 = (<>) (ptext SLIT("\t.align 4\n\t.end ")) (pprCLabel_asm clab)
888 Continue with Alpha-only printing bits and bobs:
892 pprRI (RIReg r) = pprReg r
893 pprRI (RIImm r) = pprImm r
895 pprRegRIReg :: FAST_STRING -> Reg -> RI -> Reg -> SDoc
897 pprRegRIReg name reg1 ri reg2
909 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
911 pprSizeRegRegReg name size reg1 reg2 reg3
924 #endif {-alpha_TARGET_ARCH-}
927 %************************************************************************
929 \subsubsection{@pprInstr@ for an I386}
931 %************************************************************************
936 pprInstr v@(MOV size s@(OpReg src) d@(OpReg dst)) -- hack
940 (<>) (ptext SLIT("# warning: ")) (pprSizeOpOp SLIT("mov") size s d)
944 pprInstr (MOV size src dst)
945 = pprSizeOpOp SLIT("mov") size src dst
946 pprInstr (MOVZxL sizes src dst) = pprSizeOpOpCoerce SLIT("movz") sizes L src dst
947 pprInstr (MOVSxL sizes src dst) = pprSizeOpOpCoerce SLIT("movs") sizes L src dst
949 -- here we do some patching, since the physical registers are only set late
950 -- in the code generation.
951 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
953 = pprSizeOpOp SLIT("add") size (OpReg reg2) dst
954 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
956 = pprSizeOpOp SLIT("add") size (OpReg reg1) dst
957 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) Nothing displ)) dst@(OpReg reg3))
959 = pprInstr (ADD size (OpImm displ) dst)
960 pprInstr (LEA size src dst) = pprSizeOpOp SLIT("lea") size src dst
962 pprInstr (ADD size (OpImm (ImmInt (-1))) dst)
963 = pprSizeOp SLIT("dec") size dst
964 pprInstr (ADD size (OpImm (ImmInt 1)) dst)
965 = pprSizeOp SLIT("inc") size dst
966 pprInstr (ADD size src dst)
967 = pprSizeOpOp SLIT("add") size src dst
968 pprInstr (SUB size src dst) = pprSizeOpOp SLIT("sub") size src dst
969 pprInstr (IMUL size op1 op2) = pprSizeOpOp SLIT("imul") size op1 op2
970 pprInstr (IDIV size op) = pprSizeOp SLIT("idiv") size op
972 pprInstr (AND size src dst) = pprSizeOpOp SLIT("and") size src dst
973 pprInstr (OR size src dst) = pprSizeOpOp SLIT("or") size src dst
974 pprInstr (XOR size src dst) = pprSizeOpOp SLIT("xor") size src dst
975 pprInstr (NOT size op) = pprSizeOp SLIT("not") size op
976 pprInstr (NEGI size op) = pprSizeOp SLIT("neg") size op
978 pprInstr (SHL size imm dst) = pprSizeImmOp SLIT("shl") size imm dst
979 pprInstr (SAR size imm dst) = pprSizeImmOp SLIT("sar") size imm dst
980 pprInstr (SHR size imm dst) = pprSizeImmOp SLIT("shr") size imm dst
981 pprInstr (BT size imm src) = pprSizeImmOp SLIT("bt") size imm src
983 pprInstr (CMP size src dst) = pprSizeOpOp SLIT("cmp") size src dst
984 pprInstr (TEST size src dst) = pprSizeOpOp SLIT("test") size src dst
985 pprInstr (PUSH size op) = pprSizeOp SLIT("push") size op
986 pprInstr (POP size op) = pprSizeOp SLIT("pop") size op
987 pprInstr PUSHA = ptext SLIT("\tpushal")
988 pprInstr POPA = ptext SLIT("\tpopal")
990 pprInstr (NOP) = ptext SLIT("\tnop")
991 pprInstr (CLTD) = ptext SLIT("\tcltd")
993 pprInstr (SETCC cond op) = pprCondInstr SLIT("set") cond (pprOperand B op)
995 pprInstr (JXX cond lab) = pprCondInstr SLIT("j") cond (pprCLabel_asm lab)
997 pprInstr (JMP (OpImm imm)) = (<>) (ptext SLIT("\tjmp ")) (pprImm imm)
998 pprInstr (JMP op) = (<>) (ptext SLIT("\tjmp *")) (pprOperand L op)
1000 = (<>) (ptext SLIT("\tcall ")) (pprImm imm)
1003 -- Simulating a flat register set on the x86 FP stack is tricky.
1004 -- you have to free %st(7) before pushing anything on the FP reg stack
1005 -- so as to preclude the possibility of a FP stack overflow exception.
1006 pprInstr g@(GMOV src dst)
1010 = pprG g (hcat [gtab, gpush src 0, gsemi, gpop dst 1])
1012 -- GLD sz addr dst ==> FFREE %st(7) ; FLDsz addr ; FSTP (dst+1)
1013 pprInstr g@(GLD sz addr dst)
1014 = pprG g (hcat [gtab, text "ffree %st(7) ; fld", pprSize sz, gsp,
1015 pprAddr addr, gsemi, gpop dst 1])
1017 -- GST sz src addr ==> FFREE %st(7) ; FLD dst ; FSTPsz addr
1018 pprInstr g@(GST sz src addr)
1019 = pprG g (hcat [gtab, gpush src 0, gsemi,
1020 text "fstp", pprSize sz, gsp, pprAddr addr])
1022 pprInstr g@(GLDZ dst)
1023 = pprG g (hcat [gtab, text "ffree %st(7) ; fldz ; ", gpop dst 1])
1024 pprInstr g@(GLD1 dst)
1025 = pprG g (hcat [gtab, text "ffree %st(7) ; fld1 ; ", gpop dst 1])
1027 pprInstr g@(GFTOD src dst)
1029 pprInstr g@(GFTOI src dst)
1032 pprInstr g@(GDTOF src dst)
1034 pprInstr g@(GDTOI src dst)
1037 pprInstr g@(GITOF src dst)
1038 = pprInstr (GITOD src dst)
1039 pprInstr g@(GITOD src dst)
1040 = pprG g (hcat [gtab, text "pushl ", pprReg L src,
1041 text " ; ffree %st(7); fildl (%esp) ; ",
1042 gpop dst 1, text " ; addl $4,%esp"])
1044 pprInstr g@(GCMP sz src1 src2)
1045 = pprG g (hcat [gtab, text "pushl %eax ; ",
1046 gpush src2 0, gsemi, gpush src1 1]
1048 hcat [gtab, text "fcompp ; fstsw %ax ; sahf ; popl %eax"])
1050 pprInstr g@(GABS sz src dst)
1051 = pprG g (hcat [gtab, gpush src 0, text " ; fabs ; ", gpop dst 1])
1052 pprInstr g@(GNEG sz src dst)
1053 = pprG g (hcat [gtab, gpush src 0, text " ; fchs ; ", gpop dst 1])
1055 pprInstr g@(GSQRT sz src dst)
1056 = pprG g (hcat [gtab, gpush src 0, text " ; fsqrt"] $$
1057 hcat [gtab, gcoerceto sz, gpop dst 1])
1058 pprInstr g@(GSIN sz src dst)
1059 = pprG g (hcat [gtab, gpush src 0, text " ; fsin"] $$
1060 hcat [gtab, gcoerceto sz, gpop dst 1])
1061 pprInstr g@(GCOS sz src dst)
1062 = pprG g (hcat [gtab, gpush src 0, text " ; fcos"] $$
1063 hcat [gtab, gcoerceto sz, gpop dst 1])
1064 pprInstr g@(GTAN sz src dst)
1065 = pprG g (hcat [gtab, text "ffree %st(6) ; ",
1066 gpush src 0, text " ; fptan ; ",
1067 text " fstp %st(0)"] $$
1068 hcat [gtab, gcoerceto sz, gpop dst 1])
1070 pprInstr g@(GADD sz src1 src2 dst)
1071 = pprG g (hcat [gtab, gpush src1 0,
1072 text " ; fadd ", greg src2 1, text ",%st(0)",
1074 pprInstr g@(GSUB sz src1 src2 dst)
1075 = pprG g (hcat [gtab, gpush src1 0,
1076 text " ; fsub ", greg src2 1, text ",%st(0)",
1078 pprInstr g@(GMUL sz src1 src2 dst)
1079 = pprG g (hcat [gtab, gpush src1 0,
1080 text " ; fmul ", greg src2 1, text ",%st(0)",
1082 pprInstr g@(GDIV sz src1 src2 dst)
1083 = pprG g (hcat [gtab, gpush src1 0,
1084 text " ; fdiv ", greg src2 1, text ",%st(0)",
1088 = vcat [ ptext SLIT("\tffree %st(0) ;ffree %st(1) ;ffree %st(2) ;ffree %st(3)"),
1089 ptext SLIT("\tffree %st(4) ;ffree %st(5) ;ffree %st(6) ;ffree %st(7)")
1092 --------------------------
1094 -- coerce %st(0) to the specified size
1095 gcoerceto DF = empty
1096 gcoerceto F = text "subl $4,%esp ; fstps (%esp) ; flds (%esp) ; addl $4,%esp ; "
1099 = hcat [text "ffree %st(7) ; fld ", greg reg offset]
1101 = hcat [text "fstp ", greg reg offset]
1103 bogus = text "\tbogus"
1104 greg reg offset = text "%st(" <> int (gregno reg - 8+offset) <> char ')'
1108 gregno (FixedReg i) = I# i
1109 gregno (MappedReg i) = I# i
1110 gregno other = pprPanic "gregno" (text (show other))
1112 pprG :: Instr -> SDoc -> SDoc
1114 = (char '#' <> pprGInstr fake) $$ actual
1116 pprGInstr (GMOV src dst) = pprSizeRegReg SLIT("gmov") DF src dst
1117 pprGInstr (GLD sz src dst) = pprSizeAddrReg SLIT("gld") sz src dst
1118 pprGInstr (GST sz src dst) = pprSizeRegAddr SLIT("gst") sz src dst
1120 pprGInstr (GLDZ dst) = pprSizeReg SLIT("gldz") DF dst
1121 pprGInstr (GLD1 dst) = pprSizeReg SLIT("gld1") DF dst
1123 pprGInstr (GFTOD src dst) = pprSizeSizeRegReg SLIT("gftod") F DF src dst
1124 pprGInstr (GFTOI src dst) = pprSizeSizeRegReg SLIT("gftoi") F L src dst
1126 pprGInstr (GDTOF src dst) = pprSizeSizeRegReg SLIT("gdtof") DF F src dst
1127 pprGInstr (GDTOI src dst) = pprSizeSizeRegReg SLIT("gdtoi") DF L src dst
1129 pprGInstr (GITOF src dst) = pprSizeSizeRegReg SLIT("gitof") L F src dst
1130 pprGInstr (GITOD src dst) = pprSizeSizeRegReg SLIT("gitod") L DF src dst
1132 pprGInstr (GCMP sz src dst) = pprSizeRegReg SLIT("gcmp") sz src dst
1133 pprGInstr (GABS sz src dst) = pprSizeRegReg SLIT("gabs") sz src dst
1134 pprGInstr (GNEG sz src dst) = pprSizeRegReg SLIT("gneg") sz src dst
1135 pprGInstr (GSQRT sz src dst) = pprSizeRegReg SLIT("gsqrt") sz src dst
1136 pprGInstr (GSIN sz src dst) = pprSizeRegReg SLIT("gsin") sz src dst
1137 pprGInstr (GCOS sz src dst) = pprSizeRegReg SLIT("gcos") sz src dst
1138 pprGInstr (GTAN sz src dst) = pprSizeRegReg SLIT("gtan") sz src dst
1140 pprGInstr (GADD sz src1 src2 dst) = pprSizeRegRegReg SLIT("gadd") sz src1 src2 dst
1141 pprGInstr (GSUB sz src1 src2 dst) = pprSizeRegRegReg SLIT("gsub") sz src1 src2 dst
1142 pprGInstr (GMUL sz src1 src2 dst) = pprSizeRegRegReg SLIT("gmul") sz src1 src2 dst
1143 pprGInstr (GDIV sz src1 src2 dst) = pprSizeRegRegReg SLIT("gdiv") sz src1 src2 dst
1146 Continue with I386-only printing bits and bobs:
1148 pprDollImm :: Imm -> SDoc
1150 pprDollImm i = ptext SLIT("$") <> pprImm i
1152 pprOperand :: Size -> Operand -> SDoc
1153 pprOperand s (OpReg r) = pprReg s r
1154 pprOperand s (OpImm i) = pprDollImm i
1155 pprOperand s (OpAddr ea) = pprAddr ea
1157 pprSizeImmOp :: FAST_STRING -> Size -> Imm -> Operand -> SDoc
1158 pprSizeImmOp name size imm op1
1170 pprSizeOp :: FAST_STRING -> Size -> Operand -> SDoc
1171 pprSizeOp name size op1
1180 pprSizeOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1181 pprSizeOpOp name size op1 op2
1187 pprOperand size op1,
1192 pprSizeByteOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1193 pprSizeByteOpOp name size op1 op2
1204 pprSizeOpReg :: FAST_STRING -> Size -> Operand -> Reg -> SDoc
1205 pprSizeOpReg name size op1 reg
1211 pprOperand size op1,
1216 pprSizeReg :: FAST_STRING -> Size -> Reg -> SDoc
1217 pprSizeReg name size reg1
1226 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1227 pprSizeRegReg name size reg1 reg2
1238 pprSizeSizeRegReg :: FAST_STRING -> Size -> Size -> Reg -> Reg -> SDoc
1239 pprSizeSizeRegReg name size1 size2 reg1 reg2
1251 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1252 pprSizeRegRegReg name size reg1 reg2 reg3
1265 pprSizeAddr :: FAST_STRING -> Size -> MachRegsAddr -> SDoc
1266 pprSizeAddr name size op
1275 pprSizeAddrReg :: FAST_STRING -> Size -> MachRegsAddr -> Reg -> SDoc
1276 pprSizeAddrReg name size op dst
1287 pprSizeRegAddr :: FAST_STRING -> Size -> Reg -> MachRegsAddr -> SDoc
1288 pprSizeRegAddr name size src op
1299 pprOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1300 pprOpOp name size op1 op2
1304 pprOperand size op1,
1309 pprSizeOpOpCoerce :: FAST_STRING -> Size -> Size -> Operand -> Operand -> SDoc
1310 pprSizeOpOpCoerce name size1 size2 op1 op2
1311 = hcat [ char '\t', ptext name, pprSize size1, pprSize size2, space,
1312 pprOperand size1 op1,
1314 pprOperand size2 op2
1317 pprCondInstr :: FAST_STRING -> Cond -> SDoc -> SDoc
1318 pprCondInstr name cond arg
1319 = hcat [ char '\t', ptext name, pprCond cond, space, arg]
1321 #endif {-i386_TARGET_ARCH-}
1324 %************************************************************************
1326 \subsubsection{@pprInstr@ for a SPARC}
1328 %************************************************************************
1331 #if sparc_TARGET_ARCH
1333 -- a clumsy hack for now, to handle possible double alignment problems
1335 -- even clumsier, to allow for RegReg regs that show when doing indexed
1336 -- reads (bytearrays).
1338 pprInstr (LD DF (AddrRegReg g1 g2) reg)
1340 ptext SLIT("\tadd\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1, char '\n',
1341 pp_ld_lbracket, pprReg g1, pp_rbracket_comma, pprReg reg, char '\n',
1342 pp_ld_lbracket, pprReg g1, ptext SLIT("+4]"), comma, pprReg (fPair reg)
1345 pprInstr (LD DF addr reg) | maybeToBool off_addr
1359 off_addr = addrOffset addr 4
1360 addr2 = case off_addr of Just x -> x
1362 pprInstr (LD size addr reg)
1373 -- The same clumsy hack as above
1375 pprInstr (ST DF reg (AddrRegReg g1 g2))
1377 ptext SLIT("\tadd\t"),
1378 pprReg g1,comma,pprReg g2,comma,pprReg g1, char '\n',
1379 ptext SLIT("\tst\t"),
1380 pprReg reg, pp_comma_lbracket, pprReg g1,
1381 ptext SLIT("]\n\tst\t"),
1382 pprReg (fPair reg), pp_comma_lbracket, pprReg g1, ptext SLIT("+4]")
1385 pprInstr (ST DF reg addr) | maybeToBool off_addr
1387 ptext SLIT("\tst\t"),
1388 pprReg reg, pp_comma_lbracket, pprAddr addr,
1390 ptext SLIT("]\n\tst\t"),
1391 pprReg (fPair reg), pp_comma_lbracket,
1392 pprAddr addr2, rbrack
1395 off_addr = addrOffset addr 4
1396 addr2 = case off_addr of Just x -> x
1398 -- no distinction is made between signed and unsigned bytes on stores for the
1399 -- Sparc opcodes (at least I cannot see any, and gas is nagging me --SOF),
1400 -- so we call a special-purpose pprSize for ST..
1402 pprInstr (ST size reg addr)
1413 pprInstr (ADD x cc reg1 ri reg2)
1414 | not x && not cc && riZero ri
1415 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1417 = pprRegRIReg (if x then SLIT("addx") else SLIT("add")) cc reg1 ri reg2
1419 pprInstr (SUB x cc reg1 ri reg2)
1420 | not x && cc && reg2 == g0
1421 = hcat [ ptext SLIT("\tcmp\t"), pprReg reg1, comma, pprRI ri ]
1422 | not x && not cc && riZero ri
1423 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1425 = pprRegRIReg (if x then SLIT("subx") else SLIT("sub")) cc reg1 ri reg2
1427 pprInstr (AND b reg1 ri reg2) = pprRegRIReg SLIT("and") b reg1 ri reg2
1428 pprInstr (ANDN b reg1 ri reg2) = pprRegRIReg SLIT("andn") b reg1 ri reg2
1430 pprInstr (OR b reg1 ri reg2)
1431 | not b && reg1 == g0
1432 = hcat [ ptext SLIT("\tmov\t"), pprRI ri, comma, pprReg reg2 ]
1434 = pprRegRIReg SLIT("or") b reg1 ri reg2
1436 pprInstr (ORN b reg1 ri reg2) = pprRegRIReg SLIT("orn") b reg1 ri reg2
1438 pprInstr (XOR b reg1 ri reg2) = pprRegRIReg SLIT("xor") b reg1 ri reg2
1439 pprInstr (XNOR b reg1 ri reg2) = pprRegRIReg SLIT("xnor") b reg1 ri reg2
1441 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") False reg1 ri reg2
1442 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") False reg1 ri reg2
1443 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") False reg1 ri reg2
1445 pprInstr (SETHI imm reg)
1447 ptext SLIT("\tsethi\t"),
1453 pprInstr NOP = ptext SLIT("\tnop")
1455 pprInstr (FABS F reg1 reg2) = pprSizeRegReg SLIT("fabs") F reg1 reg2
1456 pprInstr (FABS DF reg1 reg2)
1457 = (<>) (pprSizeRegReg SLIT("fabs") F reg1 reg2)
1458 (if (reg1 == reg2) then empty
1459 else (<>) (char '\n')
1460 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1462 pprInstr (FADD size reg1 reg2 reg3)
1463 = pprSizeRegRegReg SLIT("fadd") size reg1 reg2 reg3
1464 pprInstr (FCMP e size reg1 reg2)
1465 = pprSizeRegReg (if e then SLIT("fcmpe") else SLIT("fcmp")) size reg1 reg2
1466 pprInstr (FDIV size reg1 reg2 reg3)
1467 = pprSizeRegRegReg SLIT("fdiv") size reg1 reg2 reg3
1469 pprInstr (FMOV F reg1 reg2) = pprSizeRegReg SLIT("fmov") F reg1 reg2
1470 pprInstr (FMOV DF reg1 reg2)
1471 = (<>) (pprSizeRegReg SLIT("fmov") F reg1 reg2)
1472 (if (reg1 == reg2) then empty
1473 else (<>) (char '\n')
1474 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1476 pprInstr (FMUL size reg1 reg2 reg3)
1477 = pprSizeRegRegReg SLIT("fmul") size reg1 reg2 reg3
1479 pprInstr (FNEG F reg1 reg2) = pprSizeRegReg SLIT("fneg") F reg1 reg2
1480 pprInstr (FNEG DF reg1 reg2)
1481 = (<>) (pprSizeRegReg SLIT("fneg") F reg1 reg2)
1482 (if (reg1 == reg2) then empty
1483 else (<>) (char '\n')
1484 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1486 pprInstr (FSQRT size reg1 reg2) = pprSizeRegReg SLIT("fsqrt") size reg1 reg2
1487 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("fsub") size reg1 reg2 reg3
1488 pprInstr (FxTOy size1 size2 reg1 reg2)
1501 pprReg reg1, comma, pprReg reg2
1505 pprInstr (BI cond b lab)
1507 ptext SLIT("\tb"), pprCond cond,
1508 if b then pp_comma_a else empty,
1513 pprInstr (BF cond b lab)
1515 ptext SLIT("\tfb"), pprCond cond,
1516 if b then pp_comma_a else empty,
1521 pprInstr (JMP addr) = (<>) (ptext SLIT("\tjmp\t")) (pprAddr addr)
1523 pprInstr (CALL imm n _)
1524 = hcat [ ptext SLIT("\tcall\t"), pprImm imm, comma, int n ]
1527 Continue with SPARC-only printing bits and bobs:
1530 pprRI (RIReg r) = pprReg r
1531 pprRI (RIImm r) = pprImm r
1533 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1534 pprSizeRegReg name size reg1 reg2
1539 F -> ptext SLIT("s\t")
1540 DF -> ptext SLIT("d\t")),
1546 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1547 pprSizeRegRegReg name size reg1 reg2 reg3
1552 F -> ptext SLIT("s\t")
1553 DF -> ptext SLIT("d\t")),
1561 pprRegRIReg :: FAST_STRING -> Bool -> Reg -> RI -> Reg -> SDoc
1562 pprRegRIReg name b reg1 ri reg2
1566 if b then ptext SLIT("cc\t") else char '\t',
1574 pprRIReg :: FAST_STRING -> Bool -> RI -> Reg -> SDoc
1575 pprRIReg name b ri reg1
1579 if b then ptext SLIT("cc\t") else char '\t',
1585 pp_ld_lbracket = ptext SLIT("\tld\t[")
1586 pp_rbracket_comma = text "],"
1587 pp_comma_lbracket = text ",["
1588 pp_comma_a = text ",a"
1590 #endif {-sparc_TARGET_ARCH-}