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 Stix ( CodeSegment(..) )
26 import Char ( chr, ord )
27 import Maybe ( isJust )
30 %************************************************************************
32 \subsection{@pprReg@: print a @Reg@}
34 %************************************************************************
36 For x86, the way we print a register name depends
37 on which bit of it we care about. Yurgh.
39 pprUserReg:: Reg -> SDoc
40 pprUserReg = pprReg IF_ARCH_i386(L,)
43 pprReg :: IF_ARCH_i386(Size ->,) Reg -> SDoc
45 pprReg IF_ARCH_i386(s,) r
47 RealReg i -> ppr_reg_no IF_ARCH_i386(s,) i
48 VirtualRegI u -> text "%vI_" <> ppr u
49 VirtualRegF u -> text "%vF_" <> ppr u
52 ppr_reg_no :: Int -> SDoc
55 0 -> SLIT("$0"); 1 -> SLIT("$1");
56 2 -> SLIT("$2"); 3 -> SLIT("$3");
57 4 -> SLIT("$4"); 5 -> SLIT("$5");
58 6 -> SLIT("$6"); 7 -> SLIT("$7");
59 8 -> SLIT("$8"); 9 -> SLIT("$9");
60 10 -> SLIT("$10"); 11 -> SLIT("$11");
61 12 -> SLIT("$12"); 13 -> SLIT("$13");
62 14 -> SLIT("$14"); 15 -> SLIT("$15");
63 16 -> SLIT("$16"); 17 -> SLIT("$17");
64 18 -> SLIT("$18"); 19 -> SLIT("$19");
65 20 -> SLIT("$20"); 21 -> SLIT("$21");
66 22 -> SLIT("$22"); 23 -> SLIT("$23");
67 24 -> SLIT("$24"); 25 -> SLIT("$25");
68 26 -> SLIT("$26"); 27 -> SLIT("$27");
69 28 -> SLIT("$28"); 29 -> SLIT("$29");
70 30 -> SLIT("$30"); 31 -> SLIT("$31");
71 32 -> SLIT("$f0"); 33 -> SLIT("$f1");
72 34 -> SLIT("$f2"); 35 -> SLIT("$f3");
73 36 -> SLIT("$f4"); 37 -> SLIT("$f5");
74 38 -> SLIT("$f6"); 39 -> SLIT("$f7");
75 40 -> SLIT("$f8"); 41 -> SLIT("$f9");
76 42 -> SLIT("$f10"); 43 -> SLIT("$f11");
77 44 -> SLIT("$f12"); 45 -> SLIT("$f13");
78 46 -> SLIT("$f14"); 47 -> SLIT("$f15");
79 48 -> SLIT("$f16"); 49 -> SLIT("$f17");
80 50 -> SLIT("$f18"); 51 -> SLIT("$f19");
81 52 -> SLIT("$f20"); 53 -> SLIT("$f21");
82 54 -> SLIT("$f22"); 55 -> SLIT("$f23");
83 56 -> SLIT("$f24"); 57 -> SLIT("$f25");
84 58 -> SLIT("$f26"); 59 -> SLIT("$f27");
85 60 -> SLIT("$f28"); 61 -> SLIT("$f29");
86 62 -> SLIT("$f30"); 63 -> SLIT("$f31");
87 _ -> SLIT("very naughty alpha register")
91 ppr_reg_no :: Size -> Int -> SDoc
94 0 -> SLIT("%al"); 1 -> SLIT("%bl");
95 2 -> SLIT("%cl"); 3 -> SLIT("%dl");
96 _ -> SLIT("very naughty I386 byte register")
99 ppr_reg_no _ i = ptext
101 0 -> SLIT("%eax"); 1 -> SLIT("%ebx");
102 2 -> SLIT("%ecx"); 3 -> SLIT("%edx");
103 4 -> SLIT("%esi"); 5 -> SLIT("%edi");
104 6 -> SLIT("%ebp"); 7 -> SLIT("%esp");
105 8 -> SLIT("%fake0"); 9 -> SLIT("%fake1");
106 10 -> SLIT("%fake2"); 11 -> SLIT("%fake3");
107 12 -> SLIT("%fake4"); 13 -> SLIT("%fake5");
108 _ -> SLIT("very naughty I386 register")
111 #if sparc_TARGET_ARCH
112 ppr_reg_no :: Int -> SDoc
115 0 -> SLIT("%g0"); 1 -> SLIT("%g1");
116 2 -> SLIT("%g2"); 3 -> SLIT("%g3");
117 4 -> SLIT("%g4"); 5 -> SLIT("%g5");
118 6 -> SLIT("%g6"); 7 -> SLIT("%g7");
119 8 -> SLIT("%o0"); 9 -> SLIT("%o1");
120 10 -> SLIT("%o2"); 11 -> SLIT("%o3");
121 12 -> SLIT("%o4"); 13 -> SLIT("%o5");
122 14 -> SLIT("%o6"); 15 -> SLIT("%o7");
123 16 -> SLIT("%l0"); 17 -> SLIT("%l1");
124 18 -> SLIT("%l2"); 19 -> SLIT("%l3");
125 20 -> SLIT("%l4"); 21 -> SLIT("%l5");
126 22 -> SLIT("%l6"); 23 -> SLIT("%l7");
127 24 -> SLIT("%i0"); 25 -> SLIT("%i1");
128 26 -> SLIT("%i2"); 27 -> SLIT("%i3");
129 28 -> SLIT("%i4"); 29 -> SLIT("%i5");
130 30 -> SLIT("%i6"); 31 -> SLIT("%i7");
131 32 -> SLIT("%f0"); 33 -> SLIT("%f1");
132 34 -> SLIT("%f2"); 35 -> SLIT("%f3");
133 36 -> SLIT("%f4"); 37 -> SLIT("%f5");
134 38 -> SLIT("%f6"); 39 -> SLIT("%f7");
135 40 -> SLIT("%f8"); 41 -> SLIT("%f9");
136 42 -> SLIT("%f10"); 43 -> SLIT("%f11");
137 44 -> SLIT("%f12"); 45 -> SLIT("%f13");
138 46 -> SLIT("%f14"); 47 -> SLIT("%f15");
139 48 -> SLIT("%f16"); 49 -> SLIT("%f17");
140 50 -> SLIT("%f18"); 51 -> SLIT("%f19");
141 52 -> SLIT("%f20"); 53 -> SLIT("%f21");
142 54 -> SLIT("%f22"); 55 -> SLIT("%f23");
143 56 -> SLIT("%f24"); 57 -> SLIT("%f25");
144 58 -> SLIT("%f26"); 59 -> SLIT("%f27");
145 60 -> SLIT("%f28"); 61 -> SLIT("%f29");
146 62 -> SLIT("%f30"); 63 -> SLIT("%f31");
147 _ -> SLIT("very naughty sparc register")
152 %************************************************************************
154 \subsection{@pprSize@: print a @Size@}
156 %************************************************************************
159 pprSize :: Size -> SDoc
161 pprSize x = ptext (case x of
162 #if alpha_TARGET_ARCH
165 -- W -> SLIT("w") UNUSED
166 -- WU -> SLIT("wu") UNUSED
169 -- FF -> SLIT("f") UNUSED
170 -- DF -> SLIT("d") UNUSED
171 -- GF -> SLIT("g") UNUSED
172 -- SF -> SLIT("s") UNUSED
177 -- HB -> SLIT("b") UNUSED
178 -- S -> SLIT("w") UNUSED
184 #if sparc_TARGET_ARCH
187 -- HW -> SLIT("hw") UNUSED
188 -- HWU -> SLIT("uhw") UNUSED
191 -- D -> SLIT("d") UNUSED
194 pprStSize :: Size -> SDoc
195 pprStSize x = ptext (case x of
198 -- HW -> SLIT("hw") UNUSED
199 -- HWU -> SLIT("uhw") UNUSED
202 -- D -> SLIT("d") UNUSED
208 %************************************************************************
210 \subsection{@pprCond@: print a @Cond@}
212 %************************************************************************
215 pprCond :: Cond -> SDoc
217 pprCond c = ptext (case c of {
218 #if alpha_TARGET_ARCH
229 GEU -> SLIT("ae"); LU -> SLIT("b");
230 EQQ -> SLIT("e"); GTT -> SLIT("g");
231 GE -> SLIT("ge"); GU -> SLIT("a");
232 LTT -> SLIT("l"); LE -> SLIT("le");
233 LEU -> SLIT("be"); NE -> SLIT("ne");
234 NEG -> SLIT("s"); POS -> SLIT("ns");
235 ALWAYS -> SLIT("mp") -- hack
237 #if sparc_TARGET_ARCH
238 ALWAYS -> SLIT(""); NEVER -> SLIT("n");
239 GEU -> SLIT("geu"); LU -> SLIT("lu");
240 EQQ -> SLIT("e"); GTT -> SLIT("g");
241 GE -> SLIT("ge"); GU -> SLIT("gu");
242 LTT -> SLIT("l"); LE -> SLIT("le");
243 LEU -> SLIT("leu"); NE -> SLIT("ne");
244 NEG -> SLIT("neg"); POS -> SLIT("pos");
245 VC -> SLIT("vc"); VS -> SLIT("vs")
250 %************************************************************************
252 \subsection{@pprImm@: print an @Imm@}
254 %************************************************************************
257 pprImm :: Imm -> SDoc
259 pprImm (ImmInt i) = int i
260 pprImm (ImmInteger i) = integer i
261 pprImm (ImmCLbl l) = (if labelDynamic l then text "__imp_" else empty)
263 pprImm (ImmIndex l i) = (if labelDynamic l then text "__imp_" else empty)
264 <> pprCLabel_asm l <> char '+' <> int i
265 pprImm (ImmLit s) = s
267 pprImm (ImmLab dll s) = (if underscorePrefix then char '_' else empty)
268 <> (if dll then text "_imp__" else empty)
271 #if sparc_TARGET_ARCH
273 = hcat [ pp_lo, pprImm i, rparen ]
278 = hcat [ pp_hi, pprImm i, rparen ]
284 %************************************************************************
286 \subsection{@pprAddr@: print an @Addr@}
288 %************************************************************************
291 pprAddr :: MachRegsAddr -> SDoc
293 #if alpha_TARGET_ARCH
294 pprAddr (AddrReg r) = parens (pprReg r)
295 pprAddr (AddrImm i) = pprImm i
296 pprAddr (AddrRegImm r1 i)
297 = (<>) (pprImm i) (parens (pprReg r1))
303 pprAddr (ImmAddr imm off)
304 = let pp_imm = pprImm imm
308 else if (off < 0) then
311 pp_imm <> char '+' <> int off
313 pprAddr (AddrBaseIndex base index displacement)
315 pp_disp = ppr_disp displacement
316 pp_off p = pp_disp <> char '(' <> p <> char ')'
317 pp_reg r = pprReg L r
320 (Nothing, Nothing) -> pp_disp
321 (Just b, Nothing) -> pp_off (pp_reg b)
322 (Nothing, Just (r,i)) -> pp_off (pp_reg r <> comma <> int i)
323 (Just b, Just (r,i)) -> pp_off (pp_reg b <> comma <> pp_reg r
326 ppr_disp (ImmInt 0) = empty
327 ppr_disp imm = pprImm imm
332 #if sparc_TARGET_ARCH
333 pprAddr (AddrRegReg r1 (RealReg 0)) = pprReg r1
335 pprAddr (AddrRegReg r1 r2)
336 = hcat [ pprReg r1, char '+', pprReg r2 ]
338 pprAddr (AddrRegImm r1 (ImmInt i))
340 | not (fits13Bits i) = largeOffsetError i
341 | otherwise = hcat [ pprReg r1, pp_sign, int i ]
343 pp_sign = if i > 0 then char '+' else empty
345 pprAddr (AddrRegImm r1 (ImmInteger i))
347 | not (fits13Bits i) = largeOffsetError i
348 | otherwise = hcat [ pprReg r1, pp_sign, integer i ]
350 pp_sign = if i > 0 then char '+' else empty
352 pprAddr (AddrRegImm r1 imm)
353 = hcat [ pprReg r1, char '+', pprImm imm ]
357 %************************************************************************
359 \subsection{@pprInstr@: print an @Instr@}
361 %************************************************************************
364 pprInstr :: Instr -> SDoc
366 --pprInstr (COMMENT s) = empty -- nuke 'em
368 = IF_ARCH_alpha( ((<>) (ptext SLIT("\t# ")) (ptext s))
369 ,IF_ARCH_sparc( ((<>) (ptext SLIT("! ")) (ptext s))
370 ,IF_ARCH_i386( ((<>) (ptext SLIT("# ")) (ptext s))
374 = pprInstr (COMMENT (_PK_ ("\tdelta = " ++ show d)))
376 pprInstr (SEGMENT TextSegment)
377 = IF_ARCH_alpha(ptext SLIT("\t.text\n\t.align 3") {-word boundary-}
378 ,IF_ARCH_sparc(ptext SLIT(".text\n\t.align 4") {-word boundary-}
379 ,IF_ARCH_i386((text ".text\n\t.align 4,0x90") {-needs per-OS variation!-}
382 pprInstr (SEGMENT DataSegment)
384 IF_ARCH_alpha(SLIT("\t.data\n\t.align 3")
385 ,IF_ARCH_sparc(SLIT(".data\n\t.align 8") {-<8 will break double constants -}
386 ,IF_ARCH_i386(SLIT(".data\n\t.align 4")
389 pprInstr (LABEL clab)
391 pp_lab = pprCLabel_asm clab
394 if not (externallyVisibleCLabel clab) then
398 IF_ARCH_alpha(SLIT("\t.globl\t")
399 ,IF_ARCH_i386(SLIT(".globl ")
400 ,IF_ARCH_sparc(SLIT(".global\t")
402 , pp_lab, char '\n'],
407 pprInstr (ASCII False{-no backslash conversion-} str)
408 = hcat [ ptext SLIT("\t.asciz "), char '\"', text str, char '"' ]
410 pprInstr (ASCII True str)
411 = vcat (map do1 (str ++ [chr 0]))
414 do1 c = ptext SLIT("\t.byte\t0x") <> hshow (ord c)
417 hshow n | n >= 0 && n <= 255
418 = char (tab !! (n `div` 16)) <> char (tab !! (n `mod` 16))
419 tab = "0123456789ABCDEF"
423 = vcat (concatMap (ppr_item s) xs)
426 #if alpha_TARGET_ARCH
427 ppr_item = error "ppr_item on Alpha"
429 #if sparc_TARGET_ARCH
430 -- copy n paste of x86 version
431 ppr_item B x = [ptext SLIT("\t.byte\t") <> pprImm x]
432 ppr_item W x = [ptext SLIT("\t.long\t") <> pprImm x]
433 ppr_item F (ImmFloat r)
434 = let bs = floatToBytes (fromRational r)
435 in map (\b -> ptext SLIT("\t.byte\t") <> pprImm (ImmInt b)) bs
436 ppr_item DF (ImmDouble r)
437 = let bs = doubleToBytes (fromRational r)
438 in map (\b -> ptext SLIT("\t.byte\t") <> pprImm (ImmInt b)) bs
441 ppr_item B x = [ptext SLIT("\t.byte\t") <> pprImm x]
442 ppr_item L x = [ptext SLIT("\t.long\t") <> pprImm x]
443 ppr_item F (ImmFloat r)
444 = let bs = floatToBytes (fromRational r)
445 in map (\b -> ptext SLIT("\t.byte\t") <> pprImm (ImmInt b)) bs
446 ppr_item DF (ImmDouble r)
447 = let bs = doubleToBytes (fromRational r)
448 in map (\b -> ptext SLIT("\t.byte\t") <> pprImm (ImmInt b)) bs
451 -- floatToBytes and doubleToBytes convert to the host's byte
452 -- order. Providing that we're not cross-compiling for a
453 -- target with the opposite endianness, this should work ok
455 floatToBytes :: Float -> [Int]
458 arr <- newFloatArray ((0::Int),3)
459 writeFloatArray arr 0 f
460 i0 <- readCharArray arr 0
461 i1 <- readCharArray arr 1
462 i2 <- readCharArray arr 2
463 i3 <- readCharArray arr 3
464 return (map ord [i0,i1,i2,i3])
467 doubleToBytes :: Double -> [Int]
470 arr <- newDoubleArray ((0::Int),7)
471 writeDoubleArray arr 0 d
472 i0 <- readCharArray arr 0
473 i1 <- readCharArray arr 1
474 i2 <- readCharArray arr 2
475 i3 <- readCharArray arr 3
476 i4 <- readCharArray arr 4
477 i5 <- readCharArray arr 5
478 i6 <- readCharArray arr 6
479 i7 <- readCharArray arr 7
480 return (map ord [i0,i1,i2,i3,i4,i5,i6,i7])
483 -- fall through to rest of (machine-specific) pprInstr...
486 %************************************************************************
488 \subsubsection{@pprInstr@ for an Alpha}
490 %************************************************************************
493 #if alpha_TARGET_ARCH
495 pprInstr (LD size reg addr)
505 pprInstr (LDA reg addr)
507 ptext SLIT("\tlda\t"),
513 pprInstr (LDAH reg addr)
515 ptext SLIT("\tldah\t"),
521 pprInstr (LDGP reg addr)
523 ptext SLIT("\tldgp\t"),
529 pprInstr (LDI size reg imm)
539 pprInstr (ST size reg addr)
551 ptext SLIT("\tclr\t"),
555 pprInstr (ABS size ri reg)
565 pprInstr (NEG size ov ri reg)
569 if ov then ptext SLIT("v\t") else char '\t',
575 pprInstr (ADD size ov reg1 ri reg2)
579 if ov then ptext SLIT("v\t") else char '\t',
587 pprInstr (SADD size scale reg1 ri reg2)
589 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
600 pprInstr (SUB size ov reg1 ri reg2)
604 if ov then ptext SLIT("v\t") else char '\t',
612 pprInstr (SSUB size scale reg1 ri reg2)
614 ptext (case scale of {{-UNUSED:L -> SLIT("\ts4");-} Q -> SLIT("\ts8")}),
625 pprInstr (MUL size ov reg1 ri reg2)
629 if ov then ptext SLIT("v\t") else char '\t',
637 pprInstr (DIV size uns reg1 ri reg2)
641 if uns then ptext SLIT("u\t") else char '\t',
649 pprInstr (REM size uns reg1 ri reg2)
653 if uns then ptext SLIT("u\t") else char '\t',
661 pprInstr (NOT ri reg)
670 pprInstr (AND reg1 ri reg2) = pprRegRIReg SLIT("and") reg1 ri reg2
671 pprInstr (ANDNOT reg1 ri reg2) = pprRegRIReg SLIT("andnot") reg1 ri reg2
672 pprInstr (OR reg1 ri reg2) = pprRegRIReg SLIT("or") reg1 ri reg2
673 pprInstr (ORNOT reg1 ri reg2) = pprRegRIReg SLIT("ornot") reg1 ri reg2
674 pprInstr (XOR reg1 ri reg2) = pprRegRIReg SLIT("xor") reg1 ri reg2
675 pprInstr (XORNOT reg1 ri reg2) = pprRegRIReg SLIT("xornot") reg1 ri reg2
677 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") reg1 ri reg2
678 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") reg1 ri reg2
679 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") reg1 ri reg2
681 pprInstr (ZAP reg1 ri reg2) = pprRegRIReg SLIT("zap") reg1 ri reg2
682 pprInstr (ZAPNOT reg1 ri reg2) = pprRegRIReg SLIT("zapnot") reg1 ri reg2
684 pprInstr (NOP) = ptext SLIT("\tnop")
686 pprInstr (CMP cond reg1 ri reg2)
700 ptext SLIT("\tfclr\t"),
704 pprInstr (FABS reg1 reg2)
706 ptext SLIT("\tfabs\t"),
712 pprInstr (FNEG size reg1 reg2)
722 pprInstr (FADD size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("add") size reg1 reg2 reg3
723 pprInstr (FDIV size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("div") size reg1 reg2 reg3
724 pprInstr (FMUL size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("mul") size reg1 reg2 reg3
725 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("sub") size reg1 reg2 reg3
727 pprInstr (CVTxy size1 size2 reg1 reg2)
731 case size2 of {Q -> ptext SLIT("qc"); _ -> pprSize size2},
738 pprInstr (FCMP size cond reg1 reg2 reg3)
751 pprInstr (FMOV reg1 reg2)
753 ptext SLIT("\tfmov\t"),
759 pprInstr (BI ALWAYS reg lab) = pprInstr (BR lab)
761 pprInstr (BI NEVER reg lab) = empty
763 pprInstr (BI cond reg lab)
773 pprInstr (BF cond reg lab)
784 = (<>) (ptext SLIT("\tbr\t")) (pprImm lab)
786 pprInstr (JMP reg addr hint)
788 ptext SLIT("\tjmp\t"),
797 = (<>) (ptext SLIT("\tbsr\t")) (pprImm imm)
799 pprInstr (JSR reg addr n)
801 ptext SLIT("\tjsr\t"),
807 pprInstr (FUNBEGIN clab)
809 if (externallyVisibleCLabel clab) then
810 hcat [ptext SLIT("\t.globl\t"), pp_lab, char '\n']
813 ptext SLIT("\t.ent "),
822 pp_lab = pprCLabel_asm clab
824 -- NEVER use commas within those string literals, cpp will ruin your day
825 pp_ldgp = hcat [ ptext SLIT(":\n\tldgp $29"), char ',', ptext SLIT("0($27)\n") ]
826 pp_frame = hcat [ ptext SLIT("..ng:\n\t.frame $30"), char ',',
827 ptext SLIT("4240"), char ',',
828 ptext SLIT("$26"), char ',',
829 ptext SLIT("0\n\t.prologue 1") ]
831 pprInstr (FUNEND clab)
832 = (<>) (ptext SLIT("\t.align 4\n\t.end ")) (pprCLabel_asm clab)
835 Continue with Alpha-only printing bits and bobs:
839 pprRI (RIReg r) = pprReg r
840 pprRI (RIImm r) = pprImm r
842 pprRegRIReg :: FAST_STRING -> Reg -> RI -> Reg -> SDoc
844 pprRegRIReg name reg1 ri reg2
856 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
858 pprSizeRegRegReg name size reg1 reg2 reg3
871 #endif {-alpha_TARGET_ARCH-}
874 %************************************************************************
876 \subsubsection{@pprInstr@ for an I386}
878 %************************************************************************
883 pprInstr v@(MOV size s@(OpReg src) d@(OpReg dst)) -- hack
886 #if 0 /* #ifdef DEBUG */
887 (<>) (ptext SLIT("# warning: ")) (pprSizeOpOp SLIT("mov") size s d)
891 pprInstr (MOV size src dst)
892 = pprSizeOpOp SLIT("mov") size src dst
893 pprInstr (MOVZxL sizes src dst) = pprSizeOpOpCoerce SLIT("movz") sizes L src dst
894 pprInstr (MOVSxL sizes src dst) = pprSizeOpOpCoerce SLIT("movs") sizes L src dst
896 -- here we do some patching, since the physical registers are only set late
897 -- in the code generation.
898 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
900 = pprSizeOpOp SLIT("add") size (OpReg reg2) dst
901 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) (Just (reg2,1)) (ImmInt 0))) dst@(OpReg reg3))
903 = pprSizeOpOp SLIT("add") size (OpReg reg1) dst
904 pprInstr (LEA size (OpAddr (AddrBaseIndex src1@(Just reg1) Nothing displ)) dst@(OpReg reg3))
906 = pprInstr (ADD size (OpImm displ) dst)
907 pprInstr (LEA size src dst) = pprSizeOpOp SLIT("lea") size src dst
909 pprInstr (ADD size (OpImm (ImmInt (-1))) dst)
910 = pprSizeOp SLIT("dec") size dst
911 pprInstr (ADD size (OpImm (ImmInt 1)) dst)
912 = pprSizeOp SLIT("inc") size dst
913 pprInstr (ADD size src dst)
914 = pprSizeOpOp SLIT("add") size src dst
915 pprInstr (SUB size src dst) = pprSizeOpOp SLIT("sub") size src dst
916 pprInstr (IMUL size op1 op2) = pprSizeOpOp SLIT("imul") size op1 op2
918 pprInstr (AND size src dst) = pprSizeOpOp SLIT("and") size src dst
919 pprInstr (OR size src dst) = pprSizeOpOp SLIT("or") size src dst
920 pprInstr (XOR size src dst) = pprSizeOpOp SLIT("xor") size src dst
921 pprInstr (NOT size op) = pprSizeOp SLIT("not") size op
922 pprInstr (NEGI size op) = pprSizeOp SLIT("neg") size op
924 pprInstr (SHL size imm dst) = pprSizeImmOp SLIT("shl") size imm dst
925 pprInstr (SAR size imm dst) = pprSizeImmOp SLIT("sar") size imm dst
926 pprInstr (SHR size imm dst) = pprSizeImmOp SLIT("shr") size imm dst
927 pprInstr (BT size imm src) = pprSizeImmOp SLIT("bt") size imm src
929 pprInstr (CMP size src dst) = pprSizeOpOp SLIT("cmp") size src dst
930 pprInstr (TEST size src dst) = pprSizeOpOp SLIT("test") size src dst
931 pprInstr (PUSH size op) = pprSizeOp SLIT("push") size op
932 pprInstr (POP size op) = pprSizeOp SLIT("pop") size op
933 pprInstr PUSHA = ptext SLIT("\tpushal")
934 pprInstr POPA = ptext SLIT("\tpopal")
936 pprInstr (NOP) = ptext SLIT("\tnop")
937 pprInstr (CLTD) = ptext SLIT("\tcltd")
939 pprInstr (SETCC cond op) = pprCondInstr SLIT("set") cond (pprOperand B op)
941 pprInstr (JXX cond lab) = pprCondInstr SLIT("j") cond (pprCLabel_asm lab)
943 pprInstr (JMP dsts (OpImm imm)) = (<>) (ptext SLIT("\tjmp ")) (pprImm imm)
944 pprInstr (JMP dsts op) = (<>) (ptext SLIT("\tjmp *")) (pprOperand L op)
945 pprInstr (CALL imm) = (<>) (ptext SLIT("\tcall ")) (pprImm imm)
947 pprInstr (IQUOT sz src dst) = pprInstr_quotRem True sz src dst
948 pprInstr (IREM sz src dst) = pprInstr_quotRem False sz src dst
950 -- Simulating a flat register set on the x86 FP stack is tricky.
951 -- you have to free %st(7) before pushing anything on the FP reg stack
952 -- so as to preclude the possibility of a FP stack overflow exception.
953 pprInstr g@(GMOV src dst)
957 = pprG g (hcat [gtab, gpush src 0, gsemi, gpop dst 1])
959 -- GLD sz addr dst ==> FFREE %st(7) ; FLDsz addr ; FSTP (dst+1)
960 pprInstr g@(GLD sz addr dst)
961 = pprG g (hcat [gtab, text "ffree %st(7) ; fld", pprSize sz, gsp,
962 pprAddr addr, gsemi, gpop dst 1])
964 -- GST sz src addr ==> FFREE %st(7) ; FLD dst ; FSTPsz addr
965 pprInstr g@(GST sz src addr)
966 = pprG g (hcat [gtab, gpush src 0, gsemi,
967 text "fstp", pprSize sz, gsp, pprAddr addr])
969 pprInstr g@(GLDZ dst)
970 = pprG g (hcat [gtab, text "ffree %st(7) ; fldz ; ", gpop dst 1])
971 pprInstr g@(GLD1 dst)
972 = pprG g (hcat [gtab, text "ffree %st(7) ; fld1 ; ", gpop dst 1])
974 pprInstr g@(GFTOD src dst)
976 pprInstr g@(GFTOI src dst)
979 pprInstr g@(GDTOF src dst)
981 pprInstr g@(GDTOI src dst)
984 pprInstr g@(GITOF src dst)
985 = pprInstr (GITOD src dst)
986 pprInstr g@(GITOD src dst)
987 = pprG g (hcat [gtab, text "pushl ", pprReg L src,
988 text " ; ffree %st(7); fildl (%esp) ; ",
989 gpop dst 1, text " ; addl $4,%esp"])
991 pprInstr g@(GCMP sz src1 src2)
992 = pprG g (hcat [gtab, text "pushl %eax ; ",gpush src1 0]
994 hcat [gtab, text "fcomp ", greg src2 1,
995 text "; fstsw %ax ; sahf ; popl %eax"])
997 pprInstr g@(GABS sz src dst)
998 = pprG g (hcat [gtab, gpush src 0, text " ; fabs ; ", gpop dst 1])
999 pprInstr g@(GNEG sz src dst)
1000 = pprG g (hcat [gtab, gpush src 0, text " ; fchs ; ", gpop dst 1])
1002 pprInstr g@(GSQRT sz src dst)
1003 = pprG g (hcat [gtab, gpush src 0, text " ; fsqrt"] $$
1004 hcat [gtab, gcoerceto sz, gpop dst 1])
1005 pprInstr g@(GSIN sz src dst)
1006 = pprG g (hcat [gtab, gpush src 0, text " ; fsin"] $$
1007 hcat [gtab, gcoerceto sz, gpop dst 1])
1008 pprInstr g@(GCOS sz src dst)
1009 = pprG g (hcat [gtab, gpush src 0, text " ; fcos"] $$
1010 hcat [gtab, gcoerceto sz, gpop dst 1])
1011 pprInstr g@(GTAN sz src dst)
1012 = pprG g (hcat [gtab, text "ffree %st(6) ; ",
1013 gpush src 0, text " ; fptan ; ",
1014 text " fstp %st(0)"] $$
1015 hcat [gtab, gcoerceto sz, gpop dst 1])
1017 -- In the translations for GADD, GMUL, GSUB and GDIV,
1018 -- the first two cases are mere optimisations. The otherwise clause
1019 -- generates correct code under all circumstances.
1021 pprInstr g@(GADD sz src1 src2 dst)
1023 = pprG g (text "\t#GADD-xxxcase1" $$
1024 hcat [gtab, gpush src2 0,
1025 text " ; faddp %st(0),", greg src1 1])
1027 = pprG g (text "\t#GADD-xxxcase2" $$
1028 hcat [gtab, gpush src1 0,
1029 text " ; faddp %st(0),", greg src2 1])
1031 = pprG g (hcat [gtab, gpush src1 0,
1032 text " ; fadd ", greg src2 1, text ",%st(0)",
1036 pprInstr g@(GMUL sz src1 src2 dst)
1038 = pprG g (text "\t#GMUL-xxxcase1" $$
1039 hcat [gtab, gpush src2 0,
1040 text " ; fmulp %st(0),", greg src1 1])
1042 = pprG g (text "\t#GMUL-xxxcase2" $$
1043 hcat [gtab, gpush src1 0,
1044 text " ; fmulp %st(0),", greg src2 1])
1046 = pprG g (hcat [gtab, gpush src1 0,
1047 text " ; fmul ", greg src2 1, text ",%st(0)",
1051 pprInstr g@(GSUB sz src1 src2 dst)
1053 = pprG g (text "\t#GSUB-xxxcase1" $$
1054 hcat [gtab, gpush src2 0,
1055 text " ; fsubrp %st(0),", greg src1 1])
1057 = pprG g (text "\t#GSUB-xxxcase2" $$
1058 hcat [gtab, gpush src1 0,
1059 text " ; fsubp %st(0),", greg src2 1])
1061 = pprG g (hcat [gtab, gpush src1 0,
1062 text " ; fsub ", greg src2 1, text ",%st(0)",
1066 pprInstr g@(GDIV sz src1 src2 dst)
1068 = pprG g (text "\t#GDIV-xxxcase1" $$
1069 hcat [gtab, gpush src2 0,
1070 text " ; fdivrp %st(0),", greg src1 1])
1072 = pprG g (text "\t#GDIV-xxxcase2" $$
1073 hcat [gtab, gpush src1 0,
1074 text " ; fdivp %st(0),", greg src2 1])
1076 = pprG g (hcat [gtab, gpush src1 0,
1077 text " ; fdiv ", greg src2 1, text ",%st(0)",
1082 = vcat [ ptext SLIT("\tffree %st(0) ;ffree %st(1) ;ffree %st(2) ;ffree %st(3)"),
1083 ptext SLIT("\tffree %st(4) ;ffree %st(5) ;ffree %st(6) ;ffree %st(7)")
1087 pprInstr_quotRem isQuot sz src dst
1088 | case sz of L -> False; _ -> True
1089 = panic "pprInstr_quotRem: dunno how to do non-32bit operands"
1092 (text "\t# BEGIN " <> fakeInsn),
1093 (text "\tpushl $0; pushl %eax; pushl %edx; pushl " <> pprOperand sz src),
1094 (text "\tmovl " <> pprOperand sz dst <> text ",%eax; xorl %edx,%edx; cltd"),
1095 (text "\tdivl 0(%esp); movl " <> text resReg <> text ",12(%esp)"),
1096 (text "\tpopl %edx; popl %edx; popl %eax; popl " <> pprOperand sz dst),
1097 (text "\t# END " <> fakeInsn)
1100 resReg = if isQuot then "%eax" else "%edx"
1101 opStr = if isQuot then "IQUOT" else "IREM"
1102 fakeInsn = text opStr <+> pprOperand sz src <> char ',' <+> pprOperand sz dst
1104 --------------------------
1106 -- coerce %st(0) to the specified size
1107 gcoerceto DF = empty
1108 gcoerceto F = text "subl $4,%esp ; fstps (%esp) ; flds (%esp) ; addl $4,%esp ; "
1111 = hcat [text "ffree %st(7) ; fld ", greg reg offset]
1113 = hcat [text "fstp ", greg reg offset]
1115 bogus = text "\tbogus"
1116 greg reg offset = text "%st(" <> int (gregno reg - 8+offset) <> char ')'
1121 gregno (RealReg i) = i
1122 gregno other = --pprPanic "gregno" (ppr other)
1123 999 -- bogus; only needed for debug printing
1125 pprG :: Instr -> SDoc -> SDoc
1127 = (char '#' <> pprGInstr fake) $$ actual
1129 pprGInstr (GMOV src dst) = pprSizeRegReg SLIT("gmov") DF src dst
1130 pprGInstr (GLD sz src dst) = pprSizeAddrReg SLIT("gld") sz src dst
1131 pprGInstr (GST sz src dst) = pprSizeRegAddr SLIT("gst") sz src dst
1133 pprGInstr (GLDZ dst) = pprSizeReg SLIT("gldz") DF dst
1134 pprGInstr (GLD1 dst) = pprSizeReg SLIT("gld1") DF dst
1136 pprGInstr (GFTOD src dst) = pprSizeSizeRegReg SLIT("gftod") F DF src dst
1137 pprGInstr (GFTOI src dst) = pprSizeSizeRegReg SLIT("gftoi") F L src dst
1139 pprGInstr (GDTOF src dst) = pprSizeSizeRegReg SLIT("gdtof") DF F src dst
1140 pprGInstr (GDTOI src dst) = pprSizeSizeRegReg SLIT("gdtoi") DF L src dst
1142 pprGInstr (GITOF src dst) = pprSizeSizeRegReg SLIT("gitof") L F src dst
1143 pprGInstr (GITOD src dst) = pprSizeSizeRegReg SLIT("gitod") L DF src dst
1145 pprGInstr (GCMP sz src dst) = pprSizeRegReg SLIT("gcmp") sz src dst
1146 pprGInstr (GABS sz src dst) = pprSizeRegReg SLIT("gabs") sz src dst
1147 pprGInstr (GNEG sz src dst) = pprSizeRegReg SLIT("gneg") sz src dst
1148 pprGInstr (GSQRT sz src dst) = pprSizeRegReg SLIT("gsqrt") sz src dst
1149 pprGInstr (GSIN sz src dst) = pprSizeRegReg SLIT("gsin") sz src dst
1150 pprGInstr (GCOS sz src dst) = pprSizeRegReg SLIT("gcos") sz src dst
1151 pprGInstr (GTAN sz src dst) = pprSizeRegReg SLIT("gtan") sz src dst
1153 pprGInstr (GADD sz src1 src2 dst) = pprSizeRegRegReg SLIT("gadd") sz src1 src2 dst
1154 pprGInstr (GSUB sz src1 src2 dst) = pprSizeRegRegReg SLIT("gsub") sz src1 src2 dst
1155 pprGInstr (GMUL sz src1 src2 dst) = pprSizeRegRegReg SLIT("gmul") sz src1 src2 dst
1156 pprGInstr (GDIV sz src1 src2 dst) = pprSizeRegRegReg SLIT("gdiv") sz src1 src2 dst
1159 Continue with I386-only printing bits and bobs:
1161 pprDollImm :: Imm -> SDoc
1163 pprDollImm i = ptext SLIT("$") <> pprImm i
1165 pprOperand :: Size -> Operand -> SDoc
1166 pprOperand s (OpReg r) = pprReg s r
1167 pprOperand s (OpImm i) = pprDollImm i
1168 pprOperand s (OpAddr ea) = pprAddr ea
1170 pprSizeImmOp :: FAST_STRING -> Size -> Imm -> Operand -> SDoc
1171 pprSizeImmOp name size imm op1
1183 pprSizeOp :: FAST_STRING -> Size -> Operand -> SDoc
1184 pprSizeOp name size op1
1193 pprSizeOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1194 pprSizeOpOp name size op1 op2
1200 pprOperand size op1,
1205 pprSizeByteOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1206 pprSizeByteOpOp name size op1 op2
1217 pprSizeOpReg :: FAST_STRING -> Size -> Operand -> Reg -> SDoc
1218 pprSizeOpReg name size op1 reg
1224 pprOperand size op1,
1229 pprSizeReg :: FAST_STRING -> Size -> Reg -> SDoc
1230 pprSizeReg name size reg1
1239 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1240 pprSizeRegReg name size reg1 reg2
1251 pprSizeSizeRegReg :: FAST_STRING -> Size -> Size -> Reg -> Reg -> SDoc
1252 pprSizeSizeRegReg name size1 size2 reg1 reg2
1264 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1265 pprSizeRegRegReg name size reg1 reg2 reg3
1278 pprSizeAddr :: FAST_STRING -> Size -> MachRegsAddr -> SDoc
1279 pprSizeAddr name size op
1288 pprSizeAddrReg :: FAST_STRING -> Size -> MachRegsAddr -> Reg -> SDoc
1289 pprSizeAddrReg name size op dst
1300 pprSizeRegAddr :: FAST_STRING -> Size -> Reg -> MachRegsAddr -> SDoc
1301 pprSizeRegAddr name size src op
1312 pprOpOp :: FAST_STRING -> Size -> Operand -> Operand -> SDoc
1313 pprOpOp name size op1 op2
1317 pprOperand size op1,
1322 pprSizeOpOpCoerce :: FAST_STRING -> Size -> Size -> Operand -> Operand -> SDoc
1323 pprSizeOpOpCoerce name size1 size2 op1 op2
1324 = hcat [ char '\t', ptext name, pprSize size1, pprSize size2, space,
1325 pprOperand size1 op1,
1327 pprOperand size2 op2
1330 pprCondInstr :: FAST_STRING -> Cond -> SDoc -> SDoc
1331 pprCondInstr name cond arg
1332 = hcat [ char '\t', ptext name, pprCond cond, space, arg]
1334 #endif {-i386_TARGET_ARCH-}
1337 %************************************************************************
1339 \subsubsection{@pprInstr@ for a SPARC}
1341 %************************************************************************
1344 #if sparc_TARGET_ARCH
1346 -- a clumsy hack for now, to handle possible double alignment problems
1348 -- even clumsier, to allow for RegReg regs that show when doing indexed
1349 -- reads (bytearrays).
1352 -- Translate to the following:
1355 -- ld [g1+4],%f(n+1)
1356 -- sub g1,g2,g1 -- to restore g1
1357 pprInstr (LD DF (AddrRegReg g1 g2) reg)
1359 hcat [ptext SLIT("\tadd\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1],
1360 hcat [pp_ld_lbracket, pprReg g1, pp_rbracket_comma, pprReg reg],
1361 hcat [pp_ld_lbracket, pprReg g1, ptext SLIT("+4]"), comma, pprReg (fPair reg)],
1362 hcat [ptext SLIT("\tsub\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1]
1367 -- ld [addr+4],%f(n+1)
1368 pprInstr (LD DF addr reg) | isJust off_addr
1370 hcat [pp_ld_lbracket, pprAddr addr, pp_rbracket_comma, pprReg reg],
1371 hcat [pp_ld_lbracket, pprAddr addr2, pp_rbracket_comma,pprReg (fPair reg)]
1374 off_addr = addrOffset addr 4
1375 addr2 = case off_addr of Just x -> x
1378 pprInstr (LD size addr reg)
1389 -- The same clumsy hack as above
1391 -- Translate to the following:
1394 -- st %f(n+1),[g1+4]
1395 -- sub g1,g2,g1 -- to restore g1
1396 pprInstr (ST DF reg (AddrRegReg g1 g2))
1398 hcat [ptext SLIT("\tadd\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1],
1399 hcat [ptext SLIT("\tst\t"), pprReg reg, pp_comma_lbracket,
1401 hcat [ptext SLIT("\tst\t"), pprReg (fPair reg), pp_comma_lbracket,
1402 pprReg g1, ptext SLIT("+4]")],
1403 hcat [ptext SLIT("\tsub\t"), pprReg g1,comma,pprReg g2,comma,pprReg g1]
1408 -- st %f(n+1),[addr+4]
1409 pprInstr (ST DF reg addr) | isJust off_addr
1411 hcat [ptext SLIT("\tst\t"), pprReg reg, pp_comma_lbracket,
1412 pprAddr addr, rbrack],
1413 hcat [ptext SLIT("\tst\t"), pprReg (fPair reg), pp_comma_lbracket,
1414 pprAddr addr2, rbrack]
1417 off_addr = addrOffset addr 4
1418 addr2 = case off_addr of Just x -> x
1420 -- no distinction is made between signed and unsigned bytes on stores for the
1421 -- Sparc opcodes (at least I cannot see any, and gas is nagging me --SOF),
1422 -- so we call a special-purpose pprSize for ST..
1424 pprInstr (ST size reg addr)
1435 pprInstr (ADD x cc reg1 ri reg2)
1436 | not x && not cc && riZero ri
1437 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1439 = pprRegRIReg (if x then SLIT("addx") else SLIT("add")) cc reg1 ri reg2
1441 pprInstr (SUB x cc reg1 ri reg2)
1442 | not x && cc && reg2 == g0
1443 = hcat [ ptext SLIT("\tcmp\t"), pprReg reg1, comma, pprRI ri ]
1444 | not x && not cc && riZero ri
1445 = hcat [ ptext SLIT("\tmov\t"), pprReg reg1, comma, pprReg reg2 ]
1447 = pprRegRIReg (if x then SLIT("subx") else SLIT("sub")) cc reg1 ri reg2
1449 pprInstr (AND b reg1 ri reg2) = pprRegRIReg SLIT("and") b reg1 ri reg2
1450 pprInstr (ANDN b reg1 ri reg2) = pprRegRIReg SLIT("andn") b reg1 ri reg2
1452 pprInstr (OR b reg1 ri reg2)
1453 | not b && reg1 == g0
1454 = hcat [ ptext SLIT("\tmov\t"), pprRI ri, comma, pprReg reg2 ]
1456 = pprRegRIReg SLIT("or") b reg1 ri reg2
1458 pprInstr (ORN b reg1 ri reg2) = pprRegRIReg SLIT("orn") b reg1 ri reg2
1460 pprInstr (XOR b reg1 ri reg2) = pprRegRIReg SLIT("xor") b reg1 ri reg2
1461 pprInstr (XNOR b reg1 ri reg2) = pprRegRIReg SLIT("xnor") b reg1 ri reg2
1463 pprInstr (SLL reg1 ri reg2) = pprRegRIReg SLIT("sll") False reg1 ri reg2
1464 pprInstr (SRL reg1 ri reg2) = pprRegRIReg SLIT("srl") False reg1 ri reg2
1465 pprInstr (SRA reg1 ri reg2) = pprRegRIReg SLIT("sra") False reg1 ri reg2
1467 pprInstr (SETHI imm reg)
1469 ptext SLIT("\tsethi\t"),
1475 pprInstr NOP = ptext SLIT("\tnop")
1477 pprInstr (FABS F reg1 reg2) = pprSizeRegReg SLIT("fabs") F reg1 reg2
1478 pprInstr (FABS DF reg1 reg2)
1479 = (<>) (pprSizeRegReg SLIT("fabs") F reg1 reg2)
1480 (if (reg1 == reg2) then empty
1481 else (<>) (char '\n')
1482 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1484 pprInstr (FADD size reg1 reg2 reg3)
1485 = pprSizeRegRegReg SLIT("fadd") size reg1 reg2 reg3
1486 pprInstr (FCMP e size reg1 reg2)
1487 = pprSizeRegReg (if e then SLIT("fcmpe") else SLIT("fcmp")) size reg1 reg2
1488 pprInstr (FDIV size reg1 reg2 reg3)
1489 = pprSizeRegRegReg SLIT("fdiv") size reg1 reg2 reg3
1491 pprInstr (FMOV F reg1 reg2) = pprSizeRegReg SLIT("fmov") F reg1 reg2
1492 pprInstr (FMOV DF reg1 reg2)
1493 = (<>) (pprSizeRegReg SLIT("fmov") F reg1 reg2)
1494 (if (reg1 == reg2) then empty
1495 else (<>) (char '\n')
1496 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1498 pprInstr (FMUL size reg1 reg2 reg3)
1499 = pprSizeRegRegReg SLIT("fmul") size reg1 reg2 reg3
1501 pprInstr (FNEG F reg1 reg2) = pprSizeRegReg SLIT("fneg") F reg1 reg2
1502 pprInstr (FNEG DF reg1 reg2)
1503 = (<>) (pprSizeRegReg SLIT("fneg") F reg1 reg2)
1504 (if (reg1 == reg2) then empty
1505 else (<>) (char '\n')
1506 (pprSizeRegReg SLIT("fmov") F (fPair reg1) (fPair reg2)))
1508 pprInstr (FSQRT size reg1 reg2) = pprSizeRegReg SLIT("fsqrt") size reg1 reg2
1509 pprInstr (FSUB size reg1 reg2 reg3) = pprSizeRegRegReg SLIT("fsub") size reg1 reg2 reg3
1510 pprInstr (FxTOy size1 size2 reg1 reg2)
1523 pprReg reg1, comma, pprReg reg2
1527 pprInstr (BI cond b lab)
1529 ptext SLIT("\tb"), pprCond cond,
1530 if b then pp_comma_a else empty,
1535 pprInstr (BF cond b lab)
1537 ptext SLIT("\tfb"), pprCond cond,
1538 if b then pp_comma_a else empty,
1543 pprInstr (JMP dsts addr) = (<>) (ptext SLIT("\tjmp\t")) (pprAddr addr)
1545 pprInstr (CALL imm n _)
1546 = hcat [ ptext SLIT("\tcall\t"), pprImm imm, comma, int n ]
1549 Continue with SPARC-only printing bits and bobs:
1552 pprRI (RIReg r) = pprReg r
1553 pprRI (RIImm r) = pprImm r
1555 pprSizeRegReg :: FAST_STRING -> Size -> Reg -> Reg -> SDoc
1556 pprSizeRegReg name size reg1 reg2
1561 F -> ptext SLIT("s\t")
1562 DF -> ptext SLIT("d\t")),
1568 pprSizeRegRegReg :: FAST_STRING -> Size -> Reg -> Reg -> Reg -> SDoc
1569 pprSizeRegRegReg name size reg1 reg2 reg3
1574 F -> ptext SLIT("s\t")
1575 DF -> ptext SLIT("d\t")),
1583 pprRegRIReg :: FAST_STRING -> Bool -> Reg -> RI -> Reg -> SDoc
1584 pprRegRIReg name b reg1 ri reg2
1588 if b then ptext SLIT("cc\t") else char '\t',
1596 pprRIReg :: FAST_STRING -> Bool -> RI -> Reg -> SDoc
1597 pprRIReg name b ri reg1
1601 if b then ptext SLIT("cc\t") else char '\t',
1607 pp_ld_lbracket = ptext SLIT("\tld\t[")
1608 pp_rbracket_comma = text "],"
1609 pp_comma_lbracket = text ",["
1610 pp_comma_a = text ",a"
1612 #endif {-sparc_TARGET_ARCH-}