OSDN Git Service

* config/ns32k/ns32k.md: Give "*xxx" names to all unnamed insn's.
[pf3gnuchains/gcc-fork.git] / gcc / config / ns32k / ns32k.md
1 ;;- Machine description for GNU compiler, ns32000 Version
2 ;;  Copyright (C) 1988, 1994, 1996, 1998, 1999, 2000, 2001
3 ;;  Free Software Foundation, Inc.
4 ;;  Contributed by Michael Tiemann (tiemann@cygnus.com)
5
6 ;; This file is part of GNU CC.
7
8 ;; GNU CC is free software; you can redistribute it and/or modify
9 ;; it under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation; either version 2, or (at your option)
11 ;; any later version.
12
13 ;; GNU CC is distributed in the hope that it will be useful,
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ;; GNU General Public License for more details.
17
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GNU CC; see the file COPYING.  If not, write to
20 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
21 ;; Boston, MA 02111-1307, USA.
22
23
24 ; BUGS:
25 ;; Insert no-op between an insn with memory read-write operands
26 ;;   following by a scale-indexing operation.
27 ;; The Sequent assembler does not allow addresses to be used
28 ;;   except in insns which explicitly compute an effective address.
29 ;;   I.e., one cannot say "cmpd _p,@_x"
30 ;; Implement unsigned multiplication??
31
32 ;;- Instruction patterns.  When multiple patterns apply,
33 ;;- the first one in the file is chosen.
34 ;;-
35 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
36 ;;-
37 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
38 ;;- updates for most instructions.
39
40 ;; We don't want to allow a constant operand for test insns because
41 ;; (set (cc0) (const_int foo)) has no mode information.  Such insns will
42 ;; be folded while optimizing anyway.
43 ;;
44 ;; In order for pic mode to work we cannot generate, for example
45 ;;
46 ;;   addd _x+5,r1
47 ;;
48 ;; instead we must force gcc to generate something like
49 ;;
50 ;;   addr 5(_x(sb)),r0
51 ;;   addd r0,r1
52 ;;
53 ;; This was done through operand constraints (using "rmn" in place of "g"),
54 ;; but with the proper definition of LEGITIMATE_PIC_OPERAND (ns32k.h)
55 ;; this is unnecessary.
56 ;;
57
58 ;; It seems that in current CVS (2000-01-11), at least with
59 ;; libgcc2.a, that register allocation gets worse when changing
60 ;; "general_operand" "0" to "nonimmediate_operand" "0" (and
61 ;; similar "0"-containing constraints), if operand 0 is (e.g.)
62 ;; "nonimmediate_operand" "=rm".  Revisit and test later.
63
64 (define_insn "tstsi"
65   [(set (cc0)
66         (match_operand:SI 0 "nonimmediate_operand" "rm"))]
67   ""
68   "*
69 { cc_status.flags |= CC_REVERSED;
70   operands[1] = const0_rtx;
71   return \"cmpqd %1,%0\"; }")
72
73 (define_insn "tsthi"
74   [(set (cc0)
75         (match_operand:HI 0 "nonimmediate_operand" "rm"))]
76   ""
77   "*
78 { cc_status.flags |= CC_REVERSED;
79   operands[1] = const0_rtx;
80   return \"cmpqw %1,%0\"; }")
81
82 (define_insn "tstqi"
83   [(set (cc0)
84         (match_operand:QI 0 "nonimmediate_operand" "rm"))]
85   ""
86   "*
87 { cc_status.flags |= CC_REVERSED;
88   operands[1] = const0_rtx;
89   return \"cmpqb %1,%0\"; }")
90
91 (define_insn "tstdf"
92   [(set (cc0)
93         (match_operand:DF 0 "general_operand" "lmF"))]
94   "TARGET_32081"
95   "*
96 { cc_status.flags |= CC_REVERSED;
97   operands[1] = CONST0_RTX (DFmode);
98   return \"cmpl %1,%0\"; }")
99
100 (define_insn "tstsf"
101   [(set (cc0)
102         (match_operand:SF 0 "general_operand" "fmF"))]
103   "TARGET_32081"
104   "*
105 { cc_status.flags |= CC_REVERSED;
106   operands[1] = CONST0_RTX (SFmode);
107   return \"cmpf %1,%0\"; }")
108
109 ;; See note 1
110 (define_insn "cmpsi"
111   [(set (cc0)
112         (compare (match_operand:SI 0 "general_operand" "g")
113                  (match_operand:SI 1 "general_operand" "g")))]
114   ""
115   "*
116 {
117   if (GET_CODE (operands[1]) == CONST_INT)
118     {
119       int i = INTVAL (operands[1]);
120       if (i <= 7 && i >= -8)
121         {
122           cc_status.flags |= CC_REVERSED;
123           return \"cmpqd %1,%0\";
124         }
125     }
126   cc_status.flags &= ~CC_REVERSED;
127   if (GET_CODE (operands[0]) == CONST_INT)
128     {
129       int i = INTVAL (operands[0]);
130       if (i <= 7 && i >= -8)
131         return \"cmpqd %0,%1\";
132     }
133   return \"cmpd %0,%1\";
134 }")
135
136 (define_insn "cmphi"
137   [(set (cc0)
138         (compare (match_operand:HI 0 "general_operand" "g")
139                  (match_operand:HI 1 "general_operand" "g")))]
140   ""
141   "*
142 {
143   if (GET_CODE (operands[1]) == CONST_INT)
144     {
145       short i = INTVAL (operands[1]);
146     if (i <= 7 && i >= -8)
147       {
148         cc_status.flags |= CC_REVERSED;
149         if (INTVAL (operands[1]) > 7)
150           operands[1] = GEN_INT (i);
151         return \"cmpqw %1,%0\";
152       }
153     }
154   cc_status.flags &= ~CC_REVERSED;
155   if (GET_CODE (operands[0]) == CONST_INT)
156     {
157       short i = INTVAL (operands[0]);
158       if (i <= 7 && i >= -8)
159         {
160           if (INTVAL (operands[0]) > 7)
161             operands[0] = GEN_INT (i);
162           return \"cmpqw %0,%1\";
163         }
164     }
165   return \"cmpw %0,%1\";
166 }")
167
168 (define_insn "cmpqi"
169   [(set (cc0)
170         (compare (match_operand:QI 0 "general_operand" "g")
171                  (match_operand:QI 1 "general_operand" "g")))]
172   ""
173   "*
174 {
175   if (GET_CODE (operands[1]) == CONST_INT)
176     {
177       char i = INTVAL (operands[1]);
178       if (i <= 7 && i >= -8)
179         {
180           cc_status.flags |= CC_REVERSED;
181           if (INTVAL (operands[1]) > 7)
182             operands[1] = GEN_INT (i);
183           return \"cmpqb %1,%0\";
184         }
185     }
186   cc_status.flags &= ~CC_REVERSED;
187   if (GET_CODE (operands[0]) == CONST_INT)
188     {
189       char i = INTVAL (operands[0]);
190       if (i <= 7 && i >= -8)
191         {
192           if (INTVAL (operands[0]) > 7)
193             operands[0] = GEN_INT (i);
194           return \"cmpqb %0,%1\";
195         }
196     }
197   return \"cmpb %0,%1\";
198 }")
199
200 (define_insn "cmpdf"
201   [(set (cc0)
202         (compare (match_operand:DF 0 "general_operand" "lmF")
203                  (match_operand:DF 1 "general_operand" "lmF")))]
204   "TARGET_32081"
205   "cmpl %0,%1")
206
207 (define_insn "cmpsf"
208   [(set (cc0)
209         (compare (match_operand:SF 0 "general_operand" "fmF")
210                  (match_operand:SF 1 "general_operand" "fmF")))]
211   "TARGET_32081"
212   "cmpf %0,%1")
213 \f
214 ;; movdf and movsf copy between general and floating registers using
215 ;; the stack. In principle, we could get better code not allowing
216 ;; that case in the constraints and defining SECONDARY_MEMORY_NEEDED
217 ;; in practice, though the stack slots used are not available for
218 ;; optimization.
219 (define_insn "movdf"
220   [(set (match_operand:DF 0 "nonimmediate_operand" "=lrm<")
221         (match_operand:DF 1 "general_operand" "lFg"))]
222   ""
223   "*
224 {
225   if (FP_REG_P (operands[0]))
226     {
227       if (FP_REG_P (operands[1]) || GET_CODE (operands[1]) == CONST_DOUBLE)
228         return \"movl %1,%0\";
229       if (REG_P (operands[1]))
230         {
231           rtx xoperands[2];
232           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
233           output_asm_insn (\"movd %1,tos\", xoperands);
234           output_asm_insn (\"movd %1,tos\", operands);
235           return \"movl tos,%0\";
236         }
237       return \"movl %1,%0\";
238     }
239   else if (FP_REG_P (operands[1]))
240     {
241       if (REG_P (operands[0]))
242         {
243           output_asm_insn (\"movl %1,tos\;movd tos,%0\", operands);
244           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
245           return \"movd tos,%0\";
246         }
247       else
248         return \"movl %1,%0\";
249     }
250   return output_move_double (operands);
251 }")
252
253 (define_insn "movsf"
254   [(set (match_operand:SF 0 "nonimmediate_operand" "=frm<")
255         (match_operand:SF 1 "general_operand" "fFg"))]
256   ""
257   "*
258 {
259   if (FP_REG_P (operands[0]))
260     {
261       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < F0_REGNUM)
262         return \"movd %1,tos\;movf tos,%0\";
263       else
264         return \"movf %1,%0\";
265     }
266   else if (FP_REG_P (operands[1]))
267     {
268       if (REG_P (operands[0]))
269         return \"movf %1,tos\;movd tos,%0\";
270       return \"movf %1,%0\";
271     }
272 #if 0 /* Someone suggested this for the Sequent.  Is it needed?  */
273   else if (GET_CODE (operands[1]) == CONST_DOUBLE)
274     return \"movf %1,%0\";
275 #endif
276 /* There was a #if 0 around this, but that was erroneous
277    for many machines -- rms.  */
278 #ifndef MOVD_FLOAT_OK
279   /* GAS understands floating constants in ordinary movd instructions
280      but other assemblers might object.  */
281   else if (GET_CODE (operands[1]) == CONST_DOUBLE)
282     {
283       union {int i[2]; float f; double d;} convrt;
284       convrt.i[0] = CONST_DOUBLE_LOW (operands[1]);
285       convrt.i[1] = CONST_DOUBLE_HIGH (operands[1]);
286       convrt.f = convrt.d;
287
288       /* Is there a better machine-independent way to to this?  */
289       operands[1] = GEN_INT (convrt.i[0]);
290       return \"movd %1,%0\";
291     }
292 #endif
293   else return \"movd %1,%0\";
294 }")
295
296 (define_insn "*movti"
297   [(set (match_operand:TI 0 "memory_operand" "=m")
298         (match_operand:TI 1 "memory_operand" "m"))]
299   ""
300   "movmd %1,%0,4")
301
302 (define_insn "movdi"
303   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm<,*f,rm")
304         (match_operand:DI 1 "general_operand" "gF,g,*f"))]
305   ""
306   "*
307 {
308   if (FP_REG_P (operands[0]))
309     {
310       if (FP_REG_P (operands[1]) || GET_CODE (operands[1]) == CONST_DOUBLE)
311         return \"movl %1,%0\";
312       if (REG_P (operands[1]))
313         {
314           rtx xoperands[2];
315           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
316           output_asm_insn (\"movd %1,tos\", xoperands);
317           output_asm_insn (\"movd %1,tos\", operands);
318           return \"movl tos,%0\";
319         }
320       return \"movl %1,%0\";
321     }
322   else if (FP_REG_P (operands[1]))
323     {
324       if (REG_P (operands[0]))
325         {
326           output_asm_insn (\"movl %1,tos\;movd tos,%0\", operands);
327           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
328           return \"movd tos,%0\";
329         }
330       else
331         return \"movl %1,%0\";
332     }
333   return output_move_double (operands);
334 }")
335
336 ;; This special case must precede movsi.
337 (define_insn "*ldsp"
338   [(set (reg:SI 25)
339         (match_operand:SI 0 "general_operand" "g"))]
340   ""
341   "lprd sp,%0")
342
343 (define_insn "movsi"
344   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<,rm<,*f,rm,x")
345         (match_operand:SI 1 "general_operand" "g,?xy,g,*f,rmn"))]
346   ""
347   "*
348 {
349   extern int flag_pic;
350
351   if (FP_REG_P (operands[0]))
352     {
353       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < F0_REGNUM)
354         return \"movd %1,tos\;movf tos,%0\";
355       else
356         return \"movf %1,%0\";
357     }
358   else if (FP_REG_P (operands[1]))
359     {
360       if (REG_P (operands[0]))
361         return \"movf %1,tos\;movd tos,%0\";
362       return \"movf %1,%0\";
363     }
364   if (GET_CODE (operands[0]) == REG
365       && REGNO (operands[0]) == FRAME_POINTER_REGNUM)
366     return \"lprd fp,%1\";
367   if (GET_CODE (operands[1]) == CONST_DOUBLE)
368     operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
369   if (GET_CODE (operands[1]) == CONST_INT)
370     {
371       int i = INTVAL (operands[1]);
372       if (! TARGET_32532)
373         {
374           if (i <= 7 && i >= -8)
375             return \"movqd %1,%0\";
376           if (NS32K_DISPLACEMENT_P (i))
377 #if defined (GNX_V3) || defined (UTEK_ASM)
378             return \"addr %c1,%0\";
379 #else
380             return \"addr @%c1,%0\";
381 #endif
382           return \"movd %1,%0\";
383         }
384       else
385         return output_move_dconst(i, \"%1,%0\");
386     }
387   else if (GET_CODE (operands[1]) == CONST && ! flag_pic)
388     {
389         /* Must contain symbols so we don't know how big it is. In
390          * that case addr might lead to overflow. For PIC symbolic
391          * address loads always have to be done with addr.
392          */
393         return \"movd %1,%0\";
394     }
395   else if (GET_CODE (operands[1]) == REG)
396     {
397       if (REGNO (operands[1]) < F0_REGNUM)
398         return \"movd %1,%0\";
399       else if (REGNO (operands[1]) == FRAME_POINTER_REGNUM)
400         {
401           if (GET_CODE(operands[0]) == REG)
402             return \"sprd fp,%0\";
403           else
404             return \"addr 0(fp),%0\" ;
405         }
406       else if (REGNO (operands[1]) == STACK_POINTER_REGNUM)
407         {
408           if (GET_CODE(operands[0]) == REG)
409             return \"sprd sp,%0\";
410           else
411             return \"addr 0(sp),%0\" ;
412         }
413       else abort ();
414     }
415   else if (GET_CODE (operands[1]) == MEM)
416     return \"movd %1,%0\";
417
418   /* Check if this effective address can be
419      calculated faster by pulling it apart.  */
420   if (REG_P (operands[0])
421       && GET_CODE (operands[1]) == MULT
422       && GET_CODE (XEXP (operands[1], 1)) == CONST_INT
423       && (INTVAL (XEXP (operands[1], 1)) == 2
424           || INTVAL (XEXP (operands[1], 1)) == 4))
425     {
426       rtx xoperands[3];
427       xoperands[0] = operands[0];
428       xoperands[1] = XEXP (operands[1], 0);
429       xoperands[2] = GEN_INT (INTVAL (XEXP (operands[1], 1)) >> 1);
430       return output_shift_insn (xoperands);
431     }
432   return \"addr %a1,%0\";
433 }")
434
435 (define_insn "movhi"
436   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<,*f,rm")
437         (match_operand:HI 1 "general_operand" "g,g,*f"))]
438   ""
439   "*
440 {
441   if (GET_CODE (operands[1]) == CONST_INT)
442     {
443       short i = INTVAL (operands[1]);
444       if (i <= 7 && i >= -8)
445         {
446           if (INTVAL (operands[1]) > 7)
447             operands[1] = GEN_INT (i);
448           return \"movqw %1,%0\";
449         }
450         return \"movw %1,%0\";
451     }
452   else if (FP_REG_P (operands[0]))
453     {
454       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < F0_REGNUM)
455         return \"movwf %1,tos\;movf tos,%0\";
456       else
457         return \"movwf %1,%0\";
458     }
459   else if (FP_REG_P (operands[1]))
460     {
461       if (REG_P (operands[0]))
462         return \"movf %1,tos\;movd tos,%0\";
463       return \"movf %1,%0\";
464     }
465   else
466      return \"movw %1,%0\";
467 }")
468
469 (define_insn "movstricthi"
470   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
471         (match_operand:HI 1 "general_operand" "g"))]
472   ""
473   "*
474 {
475   if (GET_CODE (operands[1]) == CONST_INT
476       && INTVAL(operands[1]) <= 7 && INTVAL(operands[1]) >= -8)
477     return \"movqw %1,%0\";
478   return \"movw %1,%0\";
479 }")
480
481 (define_insn "movqi"
482   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<,*f,rm")
483         (match_operand:QI 1 "general_operand" "g,g,*f"))]
484   ""
485   "*
486 { if (GET_CODE (operands[1]) == CONST_INT)
487     {
488       char char_val = (char)INTVAL (operands[1]);
489       if (char_val <= 7 && char_val >= -8)
490         {
491           if (INTVAL (operands[1]) > 7)
492             operands[1] = GEN_INT (char_val);
493           return \"movqb %1,%0\";
494         }
495         return \"movb %1,%0\";
496     }
497   else if (FP_REG_P (operands[0]))
498     {
499       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < F0_REGNUM)
500         return \"movbf %1,tos\;movf tos,%0\";
501       else
502         return \"movbf %1,%0\";
503     }
504   else if (FP_REG_P (operands[1]))
505     {
506       if (REG_P (operands[0]))
507         return \"movf %1,tos\;movd tos,%0\";
508       return \"movf %1,%0\";
509     }
510   else
511      return \"movb %1,%0\";
512 }")
513
514 (define_insn "movstrictqi"
515   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+r"))
516         (match_operand:QI 1 "general_operand" "g"))]
517   ""
518   "*
519 {
520   if (GET_CODE (operands[1]) == CONST_INT
521       && INTVAL(operands[1]) < 8 && INTVAL(operands[1]) > -9)
522     return \"movqb %1,%0\";
523   return \"movb %1,%0\";
524 }")
525 \f
526 ;; Block moves
527 ;; Argument 0 is the destination
528 ;; Argument 1 is the source
529 ;; Argument 2 is the length
530 ;; Argument 3 is the alignment
531 ;;
532 ;; Strategy: Use define_expand to
533 ;; either emit insns directly if it can be done simply or
534 ;; emit rtl to match movstrsi1 which has extra scratch registers
535 ;; which can be used to generate more complex code.
536
537 (define_expand "movstrsi"
538   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
539                    (match_operand:BLK 1 "memory_operand" ""))
540               (use (match_operand:SI 2 "general_operand" ""))
541               (use (match_operand:SI 3 "const_int_operand" ""))])]
542   ""
543   "
544 {
545   if (operands[0])              /* avoid unused code messages */
546     {
547       expand_block_move (operands);
548       DONE;
549     }
550 }")
551
552 ;; Special Registers:
553 ;; r0  count
554 ;; r1  from 
555 ;; r2  to   
556 ;; r3  match
557
558
559 (define_insn "movstrsi1"
560   [(set (mem:BLK (reg:SI 2))
561         (mem:BLK (reg:SI 1)))
562    (use (reg:SI 0))
563    (set (reg:SI 2) (plus:SI (reg:SI 2) (mult:SI (reg:SI 0) (match_operand:SI 0 "const_int_operand" ""))))
564    (set (reg:SI 1) (plus:SI (reg:SI 1) (mult:SI (reg:SI 0) (match_dup 0))))
565    (set (reg:SI 0) (const_int 0))]
566   ""
567   "*
568   {
569      int align = INTVAL(operands[0]);
570      if (align == 4)
571        return \"movsd\";
572      else
573        return \"movsb\";
574   }")
575
576 (define_insn "movstrsi2"
577   [(set (mem:BLK (match_operand:SI 0 "address_operand" "p"))
578         (mem:BLK (match_operand:SI 1 "address_operand" "p")))
579    (use (match_operand 2 "immediate_operand" "i"))]
580   ""
581   "movmd %a1,%a0,%2")
582
583 \f
584 ;; Extension and truncation insns.
585 ;; Those for integer source operand
586 ;; are ordered widest source type first.
587
588 (define_insn "extendhisi2"
589   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
590         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
591   ""
592   "movxwd %1,%0")
593
594 (define_insn "extendqihi2"
595   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
596         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
597   ""
598   "movxbw %1,%0")
599
600 (define_insn "extendqisi2"
601   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
602         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
603   ""
604   "movxbd %1,%0")
605
606 (define_insn "extendsfdf2"
607   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
608         (float_extend:DF (match_operand:SF 1 "general_operand" "fmF")))]
609   "TARGET_32081"
610   "movfl %1,%0")
611
612 (define_insn "truncdfsf2"
613   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
614         (float_truncate:SF (match_operand:DF 1 "general_operand" "lmF")))]
615   "TARGET_32081"
616   "movlf %1,%0")
617
618 (define_insn "zero_extendhisi2"
619   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
620         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "rm")))]
621   ""
622   "movzwd %1,%0")
623
624 (define_insn "zero_extendqihi2"
625   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
626         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
627   ""
628   "movzbw %1,%0")
629
630 (define_insn "zero_extendqisi2"
631   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
632         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rm")))]
633   ""
634   "movzbd %1,%0")
635 \f
636 ;; Fix-to-float conversion insns.
637 ;; Note that the ones that start with SImode come first.
638 ;; That is so that an operand that is a CONST_INT
639 ;; (and therefore lacks a specific machine mode).
640 ;; will be recognized as SImode (which is always valid)
641 ;; rather than as QImode or HImode.
642
643 ;; Rumor has it that the National part does not correctly convert
644 ;; constant ints to floats.  This conversion is therefore disabled.
645 ;; A register must be used to perform the conversion.
646
647 (define_insn "floatsisf2"
648   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
649         (float:SF (match_operand:SI 1 "nonimmediate_operand" "rm")))]
650   "TARGET_32081"
651   "movdf %1,%0")
652
653 (define_insn "floatsidf2"
654   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
655         (float:DF (match_operand:SI 1 "nonimmediate_operand" "rm")))]
656   "TARGET_32081"
657   "movdl %1,%0")
658
659 (define_insn "floathisf2"
660   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
661         (float:SF (match_operand:HI 1 "nonimmediate_operand" "rm")))]
662   "TARGET_32081"
663   "movwf %1,%0")
664
665 (define_insn "floathidf2"
666   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
667         (float:DF (match_operand:HI 1 "nonimmediate_operand" "rm")))]
668   "TARGET_32081"
669   "movwl %1,%0")
670
671 (define_insn "floatqisf2"
672   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
673         (float:SF (match_operand:QI 1 "nonimmediate_operand" "rm")))]
674   "TARGET_32081"
675   "movbf %1,%0")
676
677 ; Some assemblers warn that this insn doesn't work.
678 ; Maybe they know something we don't.
679 ;(define_insn "floatqidf2"
680 ;  [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
681 ;       (float:DF (match_operand:QI 1 "nonimmediate_operand" "rm")))]
682 ;  "TARGET_32081"
683 ;  "movbl %1,%0")
684 \f
685 ;; Float-to-fix conversion insns.
686 ;; The sequent compiler always generates "trunc" insns.
687
688 (define_insn "fixsfqi2"
689   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
690         (fix:QI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
691   "TARGET_32081"
692   "truncfb %1,%0")
693
694 (define_insn "fixsfhi2"
695   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
696         (fix:HI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
697   "TARGET_32081"
698   "truncfw %1,%0")
699
700 (define_insn "fixsfsi2"
701   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
702         (fix:SI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
703   "TARGET_32081"
704   "truncfd %1,%0")
705
706 (define_insn "fixdfqi2"
707   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
708         (fix:QI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
709   "TARGET_32081"
710   "trunclb %1,%0")
711
712 (define_insn "fixdfhi2"
713   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
714         (fix:HI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
715   "TARGET_32081"
716   "trunclw %1,%0")
717
718 (define_insn "fixdfsi2"
719   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
720         (fix:SI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
721   "TARGET_32081"
722   "truncld %1,%0")
723
724 ;; Unsigned
725
726 (define_insn "fixunssfqi2"
727   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
728         (unsigned_fix:QI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
729   "TARGET_32081"
730   "truncfb %1,%0")
731
732 (define_insn "fixunssfhi2"
733   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
734         (unsigned_fix:HI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
735   "TARGET_32081"
736   "truncfw %1,%0")
737
738 (define_insn "fixunssfsi2"
739   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
740         (unsigned_fix:SI (fix:SF (match_operand:SF 1 "nonimmediate_operand" "fm"))))]
741   "TARGET_32081"
742   "truncfd %1,%0")
743
744 (define_insn "fixunsdfqi2"
745   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
746         (unsigned_fix:QI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
747   "TARGET_32081"
748   "trunclb %1,%0")
749
750 (define_insn "fixunsdfhi2"
751   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
752         (unsigned_fix:HI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
753   "TARGET_32081"
754   "trunclw %1,%0")
755
756 (define_insn "fixunsdfsi2"
757   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
758         (unsigned_fix:SI (fix:DF (match_operand:DF 1 "nonimmediate_operand" "lm"))))]
759   "TARGET_32081"
760   "truncld %1,%0")
761
762 ;;; These are not yet used by GCC
763 (define_insn "fix_truncsfqi2"
764   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
765         (fix:QI (match_operand:SF 1 "nonimmediate_operand" "fm")))]
766   "TARGET_32081"
767   "truncfb %1,%0")
768
769 (define_insn "fix_truncsfhi2"
770   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
771         (fix:HI (match_operand:SF 1 "nonimmediate_operand" "fm")))]
772   "TARGET_32081"
773   "truncfw %1,%0")
774
775 (define_insn "fix_truncsfsi2"
776   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
777         (fix:SI (match_operand:SF 1 "nonimmediate_operand" "fm")))]
778   "TARGET_32081"
779   "truncfd %1,%0")
780
781 (define_insn "fix_truncdfqi2"
782   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
783         (fix:QI (match_operand:DF 1 "nonimmediate_operand" "lm")))]
784   "TARGET_32081"
785   "trunclb %1,%0")
786
787 (define_insn "fix_truncdfhi2"
788   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
789         (fix:HI (match_operand:DF 1 "nonimmediate_operand" "lm")))]
790   "TARGET_32081"
791   "trunclw %1,%0")
792
793 (define_insn "fix_truncdfsi2"
794   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
795         (fix:SI (match_operand:DF 1 "nonimmediate_operand" "lm")))]
796   "TARGET_32081"
797   "truncld %1,%0")
798 \f
799 ;; Multiply-add instructions
800 (define_insn "*madddf"
801   [(set (match_operand:DF 0 "nonimmediate_operand" "=v,v,lm")
802         (plus:DF (mult:DF (match_operand:DF 1 "general_operand" "%lmF,0,0")
803                           (match_operand:DF 2 "general_operand" "lmF,lmF,lmF"))
804                  (match_operand:DF 3 "general_operand" "0,lmF,lmF")))]
805   "TARGET_MULT_ADD"
806   "@
807    dotl %1,%2
808    polyl %2,%3
809    mull %2,%0\;addl %3,%0")
810
811 (define_insn "*maddsf"
812   [(set (match_operand:SF 0 "nonimmediate_operand" "=u,u,fm")
813         (plus:SF (mult:SF (match_operand:SF 1 "general_operand" "%fmF,0,0")
814                           (match_operand:SF 2 "general_operand" "fmF,fmF,fmF"))
815                  (match_operand:SF 3 "general_operand" "0,fmF,fmF")))]
816   "TARGET_MULT_ADD"
817   "@
818    dotf %1,%2
819    polyf %2,%3
820    mulf %2,%0\;addf %3,%0")
821
822
823 ;; Multiply-sub instructions
824 (define_insn "*msubdf"
825   [(set (match_operand:DF 0 "nonimmediate_operand" "=v,lm")
826         (minus:DF (mult:DF (match_operand:DF 1 "general_operand" "%lmF,0")
827                           (match_operand:DF 2 "general_operand" "lmF,lmF"))
828                  (match_operand:DF 3 "general_operand" "lmF,lmF")))]
829   "TARGET_MULT_ADD"
830   "@
831    negl %3,%0\;dotl %1,%2
832    mull %2,%0\;subl %3,%0")
833
834 (define_insn "*msubsf"
835   [(set (match_operand:SF 0 "nonimmediate_operand" "=u,fm")
836         (minus:SF (mult:SF (match_operand:SF 1 "general_operand" "%fmF,0")
837                           (match_operand:SF 2 "general_operand" "fmF,fmF"))
838                  (match_operand:SF 3 "general_operand" "fmF,fmF")))]
839   "TARGET_MULT_ADD"
840   "@
841    negf %3,%0\;dotf %1,%2
842    mulf %2,%0\;subf %3,%0")
843
844 ;;- All kinds of add instructions.
845
846 (define_insn "adddf3"
847   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm")
848         (plus:DF (match_operand:DF 1 "general_operand" "%0")
849                  (match_operand:DF 2 "general_operand" "lmF")))]
850   "TARGET_32081"
851   "addl %2,%0")
852
853
854 (define_insn "addsf3"
855   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm")
856         (plus:SF (match_operand:SF 1 "general_operand" "%0")
857                  (match_operand:SF 2 "general_operand" "fmF")))]
858   "TARGET_32081"
859   "addf %2,%0")
860
861 (define_insn "*add_to_sp"
862   [(set (reg:SI 25)
863         (plus:SI (reg:SI 25)
864                  (match_operand:SI 0 "immediate_operand" "i")))]
865   "GET_CODE (operands[0]) == CONST_INT"
866   "*
867 {
868 #ifndef SEQUENT_ADJUST_STACK
869   if (TARGET_32532)
870     if (INTVAL (operands[0]) == 8)
871       return \"cmpd tos,tos\";
872   if (TARGET_32532 || TARGET_32332)
873     if (INTVAL (operands[0]) == 4)
874       return \"cmpqd %$0,tos\";
875 #endif
876   if (! TARGET_32532)
877     {
878       if (INTVAL (operands[0]) < 64 && INTVAL (operands[0]) > -64)
879         return \"adjspb %n0\";
880       else if (INTVAL (operands[0]) < 8192 && INTVAL (operands[0]) >= -8192)
881         return \"adjspw %n0\";
882     }
883   return \"adjspd %n0\";
884 }")
885
886 (define_insn "*frame_addr"
887   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
888         (plus:SI (reg:SI 24)
889                  (match_operand:SI 1 "immediate_operand" "i")))]
890   "GET_CODE (operands[1]) == CONST_INT"
891   "addr %c1(fp),%0")
892
893 (define_insn "*stack_addr"
894   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
895         (plus:SI (reg:SI 25)
896                  (match_operand:SI 1 "immediate_operand" "i")))]
897   "GET_CODE (operands[1]) == CONST_INT"
898   "addr %c1(sp),%0")
899
900 (define_insn "adddi3"
901   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro")
902         (plus:DI (match_operand:DI 1 "general_operand" "%0")
903                  (match_operand:DI 2 "general_operand" "ron")))]
904   ""
905   "*
906 {
907   rtx low[3], high[3], xops[4];
908   split_di (operands, 3, low, high);
909   xops[0] = low[0];
910   xops[1] = high[0];
911   xops[2] = low[2];
912   xops[3] = high[2];
913
914   if (GET_CODE (xops[2]) == CONST_INT)
915     {
916       int i = INTVAL (xops[2]);
917
918       if (i <= 7 && i >= -8) 
919         {
920           if (i == 0)
921             {
922               i = INTVAL (xops[3]);
923               if (i <= 7 && i >= -8)
924                 output_asm_insn (\"addqd %3,%1\", xops);
925               else
926                 output_asm_insn (\"addd %3,%1\", xops);
927             }
928           else
929             {
930               output_asm_insn (\"addqd %2,%0\", xops);
931               output_asm_insn (\"addcd %3,%1\", xops);
932             }
933           return \"\";
934         }
935     }
936   output_asm_insn (\"addd %2,%0\", xops);
937   output_asm_insn (\"addcd %3,%1\", xops);
938   return \"\";
939 }")
940
941 ;; See Note 1
942 (define_insn "addsi3"
943   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,=rm&<")
944         (plus:SI (match_operand:SI 1 "general_operand" "%0,r")
945                  (match_operand:SI 2 "general_operand" "g,i")))]
946   ""
947   "*
948 {
949   if (which_alternative == 1)
950     {
951       if (GET_CODE (operands[2]) == CONST_INT)
952         {
953           int i = INTVAL (operands[2]);
954           if (NS32K_DISPLACEMENT_P (i))
955             return \"addr %c2(%1),%0\";
956           else
957             return \"movd %1,%0\;addd %2,%0\";
958         }
959       else
960         {
961           if (flag_pic) 
962             return \"addr %a2[%1:b],%0\";
963           else
964             return \"addr %c2(%1),%0\";
965         }
966     }
967   else if (GET_CODE (operands[2]) == CONST_INT)
968     {
969       int i = INTVAL (operands[2]);
970
971       if (i <= 7 && i >= -8)
972         return \"addqd %2,%0\";
973       else if (! TARGET_32532 && GET_CODE (operands[0]) == REG
974                && NS32K_DISPLACEMENT_P (i))
975         return \"addr %c2(%0),%0\";
976     }
977   return \"addd %2,%0\";
978 }")
979
980 (define_insn "addhi3"
981   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
982         (plus:HI (match_operand:HI 1 "general_operand" "%0")
983                  (match_operand:HI 2 "general_operand" "g")))]
984   ""
985   "*
986 { if (GET_CODE (operands[2]) == CONST_INT)
987     {
988       int i = INTVAL (operands[2]);
989       if (i <= 7 && i >= -8)
990         return \"addqw %2,%0\";
991     }
992   return \"addw %2,%0\";
993 }")
994
995 (define_insn "*addhi_strict_low3"
996   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
997         (plus:HI (match_operand:HI 1 "general_operand" "0")
998                  (match_operand:HI 2 "general_operand" "g")))]
999   ""
1000   "*
1001 {
1002   if (GET_CODE (operands[1]) == CONST_INT
1003       && INTVAL (operands[1]) >-9 && INTVAL(operands[1]) < 8)
1004     return \"addqw %2,%0\";
1005   return \"addw %2,%0\";
1006 }")
1007
1008 (define_insn "addqi3"
1009   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1010         (plus:QI (match_operand:QI 1 "general_operand" "%0")
1011                  (match_operand:QI 2 "general_operand" "g")))]
1012   ""
1013   "*
1014 { if (GET_CODE (operands[2]) == CONST_INT)
1015     {
1016       int i = INTVAL (operands[2]);
1017       if (i <= 7 && i >= -8)
1018         return \"addqb %2,%0\";
1019     }
1020   return \"addb %2,%0\";
1021 }")
1022
1023 (define_insn "*addqi_strict_low3"
1024   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+r"))
1025         (plus:QI (match_operand:QI 1 "general_operand" "0")
1026                  (match_operand:QI 2 "general_operand" "g")))]
1027   ""
1028   "*
1029 {
1030   if (GET_CODE (operands[1]) == CONST_INT
1031       && INTVAL (operands[1]) >-9 && INTVAL(operands[1]) < 8)
1032     return \"addqb %2,%0\";
1033   return \"addb %2,%0\";
1034 }")
1035 \f
1036 ;;- All kinds of subtract instructions.
1037
1038 (define_insn "subdf3"
1039   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm")
1040         (minus:DF (match_operand:DF 1 "general_operand" "0")
1041                   (match_operand:DF 2 "general_operand" "lmF")))]
1042   "TARGET_32081"
1043   "subl %2,%0")
1044
1045 (define_insn "subsf3"
1046   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm")
1047         (minus:SF (match_operand:SF 1 "general_operand" "0")
1048                   (match_operand:SF 2 "general_operand" "fmF")))]
1049   "TARGET_32081"
1050   "subf %2,%0")
1051
1052 (define_insn "*sub_from_sp"
1053   [(set (reg:SI 25)
1054         (minus:SI (reg:SI 25)
1055                   (match_operand:SI 0 "immediate_operand" "i")))]
1056   "GET_CODE (operands[0]) == CONST_INT"
1057   "*
1058 {
1059   if (! TARGET_32532 && GET_CODE(operands[0]) == CONST_INT 
1060       && INTVAL(operands[0]) < 64 && INTVAL(operands[0]) > -64)
1061     return \"adjspb %0\";
1062   return \"adjspd %0\";
1063 }")
1064
1065 (define_insn "subdi3"
1066   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro")
1067         (minus:DI (match_operand:DI 1 "general_operand" "0")
1068                   (match_operand:DI 2 "general_operand" "ron")))]
1069   ""
1070   "*
1071 {
1072   rtx low[3], high[3], xops[4];
1073   split_di (operands, 3, low, high);
1074   xops[0] = low[0];
1075   xops[1] = high[0];
1076   xops[2] = low[2];
1077   xops[3] = high[2];
1078
1079   if (GET_CODE (xops[2]) == CONST_INT)
1080     {
1081       int i = INTVAL (xops[2]);
1082
1083       if (i <= 8 && i >= -7)
1084         {
1085           if (i == 0)
1086             {
1087               i = INTVAL (xops[3]);
1088               if (i <= 8 && i >= -7)
1089                 output_asm_insn (\"addqd %n3,%1\", xops);
1090               else
1091                 output_asm_insn (\"subd %3,%1\", xops);
1092             }
1093           else
1094             {
1095               output_asm_insn (\"addqd %n2,%0\", xops);
1096               output_asm_insn (\"subcd %3,%1\", xops);
1097             }
1098           return \"\";
1099         }
1100     }
1101   output_asm_insn (\"subd %2,%0\", xops);
1102   output_asm_insn (\"subcd %3,%1\", xops);
1103   return \"\";
1104 }")
1105
1106 (define_insn "subsi3"
1107   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1108         (minus:SI (match_operand:SI 1 "general_operand" "0")
1109                   (match_operand:SI 2 "general_operand" "g")))]
1110   ""
1111   "*
1112 { if (GET_CODE (operands[2]) == CONST_INT)
1113     {
1114       int i = INTVAL (operands[2]);
1115
1116       if (i <= 8 && i >= -7)
1117         return \"addqd %n2,%0\";
1118     }
1119   return \"subd %2,%0\";
1120 }")
1121
1122 (define_insn "subhi3"
1123   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1124         (minus:HI (match_operand:HI 1 "general_operand" "0")
1125                   (match_operand:HI 2 "general_operand" "g")))]
1126   ""
1127   "*
1128 { if (GET_CODE (operands[2]) == CONST_INT)
1129     {
1130       int i = INTVAL (operands[2]);
1131
1132       if (i <= 8 && i >= -7)
1133         return \"addqw %n2,%0\";
1134     }
1135   return \"subw %2,%0\";
1136 }")
1137
1138 (define_insn "*subhi_strict_low3"
1139   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r"))
1140         (minus:HI (match_operand:HI 1 "general_operand" "0")
1141                   (match_operand:HI 2 "general_operand" "g")))]
1142   ""
1143   "*
1144 {
1145   if (GET_CODE (operands[1]) == CONST_INT
1146       && INTVAL (operands[1]) >-8 && INTVAL(operands[1]) < 9)
1147     return \"addqw %n2,%0\";
1148   return \"subw %2,%0\";
1149 }")
1150
1151 (define_insn "subqi3"
1152   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1153         (minus:QI (match_operand:QI 1 "general_operand" "0")
1154                   (match_operand:QI 2 "general_operand" "g")))]
1155   ""
1156   "*
1157 { if (GET_CODE (operands[2]) == CONST_INT)
1158     {
1159       int i = INTVAL (operands[2]);
1160
1161       if (i <= 8 && i >= -7)
1162         return \"addqb %n2,%0\";
1163     }
1164   return \"subb %2,%0\";
1165 }")
1166
1167 (define_insn "*subqi_strict_low3"
1168   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+r"))
1169         (minus:QI (match_operand:QI 1 "general_operand" "0")
1170                   (match_operand:QI 2 "general_operand" "g")))]
1171   ""
1172   "*
1173 {
1174   if (GET_CODE (operands[1]) == CONST_INT
1175       && INTVAL (operands[1]) >-8 && INTVAL(operands[1]) < 9)
1176     return \"addqb %n2,%0\";
1177   return \"subb %2,%0\";
1178 }")
1179 \f
1180 ;;- Multiply instructions.
1181
1182 (define_insn "muldf3"
1183   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm")
1184         (mult:DF (match_operand:DF 1 "general_operand" "%0")
1185                  (match_operand:DF 2 "general_operand" "lmF")))]
1186   "TARGET_32081"
1187   "mull %2,%0")
1188
1189 (define_insn "mulsf3"
1190   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm")
1191         (mult:SF (match_operand:SF 1 "general_operand" "%0")
1192                  (match_operand:SF 2 "general_operand" "fmF")))]
1193   "TARGET_32081"
1194   "mulf %2,%0")
1195
1196 ;; See note 1
1197 (define_insn "mulsi3"
1198   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1199         (mult:SI (match_operand:SI 1 "general_operand" "%0")
1200                  (match_operand:SI 2 "general_operand" "g")))]
1201   ""
1202   "muld %2,%0")
1203
1204 (define_insn "mulhi3"
1205   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1206         (mult:HI (match_operand:HI 1 "general_operand" "%0")
1207                  (match_operand:HI 2 "general_operand" "g")))]
1208   ""
1209   "mulw %2,%0")
1210
1211 (define_insn "mulqi3"
1212   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1213         (mult:QI (match_operand:QI 1 "general_operand" "%0")
1214                  (match_operand:QI 2 "general_operand" "g")))]
1215   ""
1216   "mulb %2,%0")
1217
1218 (define_insn "umulsidi3"
1219   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
1220         (mult:DI (zero_extend:DI
1221                   (match_operand:SI 1 "nonimmediate_operand" "0"))
1222                  (zero_extend:DI
1223                   (match_operand:SI 2 "nonimmediate_operand" "rm"))))]
1224   ""
1225   "meid %2,%0")
1226 \f
1227 ;; divmod insns: We can only do the unsigned case.
1228 (define_expand "udivmodsi4"
1229   [(parallel
1230   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1231         (udiv:SI (match_operand:SI 1 "general_operand" "")
1232                      (match_operand:SI 2 "general_operand" "")))
1233    (set (match_operand:SI 3 "nonimmediate_operand" "")
1234         (umod:SI (match_dup 1) (match_dup 2)))])]
1235   ""
1236   "
1237 {
1238   rtx temp = gen_reg_rtx(DImode);
1239   rtx insn, first, last;
1240   first = emit_move_insn(gen_lowpart(SImode, temp), operands[1]);
1241   emit_move_insn(gen_highpart(SImode, temp), const0_rtx);
1242   emit_insn(gen_udivmoddisi4_internal(temp, temp, operands[2]));
1243   last = emit_move_insn(temp, temp);
1244   {
1245     rtx divdi, moddi, divsi, modsi;
1246     divsi = gen_rtx (UDIV, SImode, operands[1], operands[2]);
1247     modsi = gen_rtx (UMOD, SImode, operands[1], operands[2]);
1248     divdi = gen_rtx (ZERO_EXTEND, DImode, divsi);
1249     moddi = gen_rtx (ZERO_EXTEND, DImode, modsi);
1250     REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
1251                                  REG_NOTES (first));
1252     REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first,
1253                                 gen_rtx (EXPR_LIST, REG_EQUAL,
1254                        gen_rtx (IOR, DImode, moddi,
1255                                gen_rtx (ASHIFT, DImode, divdi, GEN_INT(32))),
1256                        REG_NOTES (last)));
1257   }
1258
1259   insn = emit_move_insn(operands[0], gen_highpart(SImode, temp));
1260   insn = emit_move_insn(operands[3], gen_lowpart(SImode, temp));
1261   DONE;
1262 }")
1263
1264 ;; If we try and describe what this does, we have to zero-expand an
1265 ;; operand, which prevents it being a constant (VOIDmode) (see udivmoddisi4
1266 ;; below. This udivmoddisi4_internal never matches anything and is only
1267 ;; ever used when explicitly emitted by a define_expand.
1268 (define_insn "udivmoddisi4_internal"
1269   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
1270         (unspec:DI [(match_operand:DI 1 "nonimmediate_operand" "0")
1271                     (match_operand:SI 2 "general_operand" "g")] 0))]
1272   ""
1273   "deid %2,%0")
1274
1275 ;; Retain this insn which *does* have a pattern indicating what it does,
1276 ;; just in case the compiler is smart enough to recognize a substitution.
1277 (define_insn "udivmoddisi4"
1278   [(set (subreg:SI (match_operand:DI 0 "nonimmediate_operand" "=rm") 4)
1279         (truncate:SI (udiv:DI (match_operand:DI 1 "nonimmediate_operand" "0")
1280                  (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm")))))
1281    (set (subreg:SI (match_operand:DI 3 "nonimmediate_operand" "=0") 0)
1282         (truncate:SI (umod:DI (match_dup 1) (zero_extend:DI (match_dup 2)))))]
1283   ""
1284   "deid %2,%0")
1285
1286 ;;;; Part word variants. These seem to never be used at the moment (gcc
1287 ;;;; 2.7.2.2). The code generation prefers to zero extend hi's and qi's
1288 ;;;; and use signed div and mod. Keep these insns incase that changes.
1289 ;;;; divmod should have an advantage when both div and mod are needed. However,
1290 ;;;; divmod uses two registers, so maybe the compiler knows best.
1291 ;;
1292 ;;(define_expand "udivmodhi4"
1293 ;;  [(parallel
1294 ;;  [(set (match_operand:HI 0 "nonimmediate_operand" "")
1295 ;;      (udiv:HI (match_operand:HI 1 "general_operand" "")
1296 ;;                   (match_operand:HI 2 "general_operand" "")))
1297 ;;   (set (match_operand:HI 3 "nonimmediate_operand" "")
1298 ;;      (umod:HI (match_dup 1) (match_dup 2)))])]
1299 ;;  ""
1300 ;;  "
1301 ;;{
1302 ;;  rtx temp = gen_reg_rtx(DImode);
1303 ;;  rtx insn, first, last;
1304 ;;  first = emit_move_insn(gen_lowpart(HImode, temp), operands[1]);
1305 ;;  emit_move_insn(gen_highpart (HImode, temp), const0_rtx);
1306 ;;  operands[2] = force_reg(HImode, operands[2]);
1307 ;;  emit_insn(gen_udivmoddihi4_internal(temp, temp, operands[2]));
1308 ;;  last = emit_move_insn(temp, temp);
1309 ;;  {
1310 ;;    rtx divdi, moddi, divhi, modhi;
1311 ;;    divhi = gen_rtx (UDIV, HImode, operands[1], operands[2]);
1312 ;;    modhi = gen_rtx (UMOD, HImode, operands[1], operands[2]);
1313 ;;    divdi = gen_rtx (ZERO_EXTEND, DImode, divhi);
1314 ;;    moddi = gen_rtx (ZERO_EXTEND, DImode, modhi);
1315 ;;    REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
1316 ;;                               REG_NOTES (first));
1317 ;;    REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first,
1318 ;;                                gen_rtx (EXPR_LIST, REG_EQUAL,
1319 ;;                       gen_rtx(IOR, DImode, moddi,
1320 ;;                               gen_rtx(ASHIFT, DImode, divdi, GEN_INT(32))),
1321 ;;                       REG_NOTES (last)));
1322 ;;  }
1323 ;;
1324 ;;  insn = emit_move_insn(operands[0], gen_highpart(HImode, temp));
1325 ;;  insn = emit_move_insn(operands[3], gen_lowpart(HImode, temp));
1326 ;;  DONE;
1327 ;;}")
1328 ;;
1329 ;;;; deiw wants two hi's in separate registers or else they can be adjacent
1330 ;;;; in memory. DI mode will ensure two registers are available, but if we
1331 ;;;; want to allow memory as an operand we would need SI mode. There is no
1332 ;;;; way to do this, so just restrict operand 0 and 1 to be in registers.
1333 ;;(define_insn "udivmoddihi4_internal"
1334 ;;  [(set (match_operand:DI 0 "register_operand" "=r")
1335 ;;        (unspec:DI [(match_operand:DI 1 "register_operand" "0")
1336 ;;                    (match_operand:HI 2 "general_operand" "g")] 0))]
1337 ;;  ""
1338 ;;  "deiw %2,%0")
1339 ;;
1340 ;;(define_insn "udivmoddihi4"
1341 ;;  [(set (subreg:HI (match_operand:DI 0 "register_operand" "=r") 2)
1342 ;;      (truncate:HI (udiv:DI (match_operand:DI 1 "register_operand" "0")
1343 ;;               (zero_extend:DI (match_operand:HI 2 "nonimmediate_operand" "rm")))))
1344 ;;   (set (subreg:HI (match_operand:DI 3 "register_operand" "=0") 0)
1345 ;;      (truncate:HI (umod:DI (match_dup 1) (zero_extend:DI (match_dup 2)))))]
1346 ;;  ""
1347 ;;  "deiw %2,%0")
1348 ;;
1349 ;;(define_expand "udivmodqi4"
1350 ;;  [(parallel
1351 ;;  [(set (match_operand:QI 0 "nonimmediate_operand" "")
1352 ;;      (udiv:QI (match_operand:QI 1 "general_operand" "")
1353 ;;                   (match_operand:QI 2 "general_operand" "")))
1354 ;;   (set (match_operand:QI 3 "nonimmediate_operand" "")
1355 ;;      (umod:QI (match_dup 1) (match_dup 2)))])]
1356 ;;  ""
1357 ;;  "
1358 ;;{
1359 ;;  rtx temp = gen_reg_rtx(DImode);
1360 ;;  rtx insn, first, last;
1361 ;;  first = emit_move_insn(gen_lowpart(QImode, temp), operands[1]);
1362 ;;  emit_move_insn(gen_highpart(QImode, temp), const0_rtx);
1363 ;;  operands[2] = force_reg(QImode, operands[2]);
1364 ;;  emit_insn(gen_udivmoddiqi4_internal(temp, temp, operands[2]));
1365 ;;  last = emit_move_insn(temp, temp);
1366 ;;  {
1367 ;;    rtx divdi, moddi, divqi, modqi;
1368 ;;    divqi = gen_rtx (UDIV, QImode, operands[1], operands[2]);
1369 ;;    modqi = gen_rtx (UMOD, QImode, operands[1], operands[2]);
1370 ;;    divdi = gen_rtx (ZERO_EXTEND, DImode, divqi);
1371 ;;    moddi = gen_rtx (ZERO_EXTEND, DImode, modqi);
1372 ;;    REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
1373 ;;                               REG_NOTES (first));
1374 ;;    REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first,
1375 ;;                                gen_rtx (EXPR_LIST, REG_EQUAL,
1376 ;;                       gen_rtx(IOR, DImode, moddi,
1377 ;;                               gen_rtx(ASHIFT, DImode, divdi, GEN_INT(32))),
1378 ;;                       REG_NOTES (last)));
1379 ;;  }
1380 ;;
1381 ;;  insn = emit_move_insn(operands[0], gen_highpart(QImode, temp));
1382 ;;  insn = emit_move_insn(operands[3], gen_lowpart(QImode, temp));
1383 ;;  DONE;
1384 ;;}")
1385 ;;
1386 ;;;; deib wants two qi's in separate registers or else they can be adjacent
1387 ;;;; in memory. DI mode will ensure two registers are available, but if we
1388 ;;;; want to allow memory as an operand we would need HI mode. There is no
1389 ;;;; way to do this, so just restrict operand 0 and 1 to be in registers.
1390 ;;(define_insn "udivmoddiqi4_internal"
1391 ;;  [(set (match_operand:DI 0 "register_operand" "=r")
1392 ;;        (unspec:DI [(match_operand:DI 1 "register_operand" "0")
1393 ;;                    (match_operand:QI 2 "general_operand" "g")] 0))]
1394 ;;  ""
1395 ;;  "deib %2,%0")
1396 ;;
1397 ;;(define_insn "udivmoddiqi4"
1398 ;;  [(set (subreg:QI (match_operand:DI 0 "register_operand" "=r") 1)
1399 ;;      (truncate:QI (udiv:DI (match_operand:DI 1 "register_operand" "0")
1400 ;;               (zero_extend:DI (match_operand:QI 2 "nonimmediate_operand" "rm")))))
1401 ;;   (set (subreg:QI (match_operand:DI 3 "register_operand" "=0") 0)
1402 ;;      (truncate:QI (umod:DI (match_dup 1) (zero_extend:DI (match_dup 2)))))]
1403 ;;  ""
1404 ;;  "deib %2,%0")
1405 \f
1406 ;;- Divide instructions.
1407
1408 (define_insn "divdf3"
1409   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm")
1410         (div:DF (match_operand:DF 1 "general_operand" "0")
1411                 (match_operand:DF 2 "general_operand" "lmF")))]
1412   "TARGET_32081"
1413   "divl %2,%0")
1414
1415 (define_insn "divsf3"
1416   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm")
1417         (div:SF (match_operand:SF 1 "general_operand" "0")
1418                 (match_operand:SF 2 "general_operand" "fmF")))]
1419   "TARGET_32081"
1420   "divf %2,%0")
1421
1422 ;; See note 1
1423 (define_insn "divsi3"
1424   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1425         (div:SI (match_operand:SI 1 "general_operand" "0")
1426                 (match_operand:SI 2 "general_operand" "g")))]
1427   ""
1428   "quod %2,%0")
1429
1430 (define_insn "divhi3"
1431   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1432         (div:HI (match_operand:HI 1 "general_operand" "0")
1433                 (match_operand:HI 2 "general_operand" "g")))]
1434   ""
1435   "quow %2,%0")
1436
1437 (define_insn "divqi3"
1438   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1439         (div:QI (match_operand:QI 1 "general_operand" "0")
1440                 (match_operand:QI 2 "general_operand" "g")))]
1441   ""
1442   "quob %2,%0")
1443 \f
1444 ;; Remainder instructions.
1445
1446 ;; See note 1
1447 (define_insn "modsi3"
1448   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1449         (mod:SI (match_operand:SI 1 "general_operand" "0")
1450                 (match_operand:SI 2 "general_operand" "g")))]
1451   ""
1452   "remd %2,%0")
1453
1454 (define_insn "modhi3"
1455   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1456         (mod:HI (match_operand:HI 1 "general_operand" "0")
1457                 (match_operand:HI 2 "general_operand" "g")))]
1458   ""
1459   "remw %2,%0")
1460
1461 (define_insn "modqi3"
1462   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1463         (mod:QI (match_operand:QI 1 "general_operand" "0")
1464                 (match_operand:QI 2 "general_operand" "g")))]
1465   ""
1466   "remb %2,%0")
1467
1468 \f
1469 ;;- Logical Instructions: AND
1470
1471 ;; See note 1
1472 (define_insn "andsi3"
1473   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1474         (and:SI (match_operand:SI 1 "general_operand" "%0")
1475                 (match_operand:SI 2 "general_operand" "g")))]
1476   ""
1477   "*
1478 {
1479   if (GET_CODE (operands[2]) == CONST_INT)
1480     {
1481       if ((INTVAL (operands[2]) | 0xff) == 0xffffffff)
1482         {
1483           if (INTVAL (operands[2]) == 0xffffff00)
1484             return \"movqb %$0,%0\";
1485           else
1486             {
1487               operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
1488               return \"andb %2,%0\";
1489             }
1490         }
1491       if ((INTVAL (operands[2]) | 0xffff) == 0xffffffff)
1492         {
1493           if (INTVAL (operands[2]) == 0xffff0000)
1494             return \"movqw %$0,%0\";
1495           else
1496             {
1497               operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
1498               return \"andw %2,%0\";
1499             }
1500         }
1501     }
1502   return \"andd %2,%0\";
1503 }")
1504
1505 (define_insn "andhi3"
1506   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1507         (and:HI (match_operand:HI 1 "general_operand" "%0")
1508                 (match_operand:HI 2 "general_operand" "g")))]
1509   ""
1510   "*
1511 {
1512   if (GET_CODE (operands[2]) == CONST_INT
1513       && (INTVAL (operands[2]) | 0xff) == 0xffffffff)
1514     {
1515       if (INTVAL (operands[2]) == 0xffffff00)
1516         return \"movqb %$0,%0\";
1517       else
1518         {
1519           operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
1520           return \"andb %2,%0\";
1521         }
1522     }
1523   return \"andw %2,%0\";
1524 }")
1525
1526 (define_insn "andqi3"
1527   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1528         (and:QI (match_operand:QI 1 "general_operand" "%0")
1529                 (match_operand:QI 2 "general_operand" "g")))]
1530   ""
1531   "andb %2,%0")
1532
1533 ;; See note 1
1534 (define_insn "*bicsi"
1535   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1536         (and:SI (not:SI (match_operand:SI 1 "general_operand" "g"))
1537                 (match_operand:SI 2 "general_operand" "0")))]
1538   ""
1539   "bicd %1,%0")
1540
1541 (define_insn "*bichi"
1542   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1543         (and:HI (not:HI (match_operand:HI 1 "general_operand" "g"))
1544                 (match_operand:HI 2 "general_operand" "0")))]
1545   ""
1546   "bicw %1,%0")
1547
1548 (define_insn "*bicqi"
1549   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1550         (and:QI (not:QI (match_operand:QI 1 "general_operand" "g"))
1551                 (match_operand:QI 2 "general_operand" "0")))]
1552   ""
1553   "bicb %1,%0")
1554 \f
1555 ;;- Bit set instructions.
1556
1557 ;; See note 1
1558 (define_insn "iorsi3"
1559   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1560         (ior:SI (match_operand:SI 1 "general_operand" "%0")
1561                 (match_operand:SI 2 "general_operand" "g")))]
1562   ""
1563   "*
1564 {
1565   if (GET_CODE (operands[2]) == CONST_INT) {
1566     if ((INTVAL (operands[2]) & 0xffffff00) == 0)
1567       return \"orb %2,%0\";
1568     if ((INTVAL (operands[2]) & 0xffff0000) == 0)
1569       return \"orw %2,%0\";
1570   }
1571   return \"ord %2,%0\";
1572 }")
1573
1574 (define_insn "iorhi3"
1575   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1576         (ior:HI (match_operand:HI 1 "general_operand" "%0")
1577                 (match_operand:HI 2 "general_operand" "g")))]
1578   ""
1579   "*
1580 {
1581   if (GET_CODE(operands[2]) == CONST_INT &&
1582       (INTVAL(operands[2]) & 0xffffff00) == 0)
1583     return \"orb %2,%0\";
1584   return \"orw %2,%0\";
1585 }")
1586
1587 (define_insn "iorqi3"
1588   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1589         (ior:QI (match_operand:QI 1 "general_operand" "%0")
1590                 (match_operand:QI 2 "general_operand" "g")))]
1591   ""
1592   "orb %2,%0")
1593
1594 ;;- xor instructions.
1595
1596 ;; See note 1
1597 (define_insn "xorsi3"
1598   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1599         (xor:SI (match_operand:SI 1 "general_operand" "%0")
1600                 (match_operand:SI 2 "general_operand" "g")))]
1601   ""
1602   "*
1603 {
1604   if (GET_CODE (operands[2]) == CONST_INT) {
1605     if ((INTVAL (operands[2]) & 0xffffff00) == 0)
1606       return \"xorb %2,%0\";
1607     if ((INTVAL (operands[2]) & 0xffff0000) == 0)
1608       return \"xorw %2,%0\";
1609   }
1610   return \"xord %2,%0\";
1611 }")
1612
1613 (define_insn "xorhi3"
1614   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1615         (xor:HI (match_operand:HI 1 "general_operand" "%0")
1616                 (match_operand:HI 2 "general_operand" "g")))]
1617   ""
1618   "*
1619 {
1620   if (GET_CODE(operands[2]) == CONST_INT &&
1621       (INTVAL(operands[2]) & 0xffffff00) == 0)
1622     return \"xorb %2,%0\";
1623   return \"xorw %2,%0\";
1624 }")
1625
1626 (define_insn "xorqi3"
1627   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1628         (xor:QI (match_operand:QI 1 "general_operand" "%0")
1629                 (match_operand:QI 2 "general_operand" "g")))]
1630   ""
1631   "xorb %2,%0")
1632 \f
1633 (define_insn "negdf2"
1634   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
1635         (neg:DF (match_operand:DF 1 "general_operand" "lmF")))]
1636   "TARGET_32081"
1637   "negl %1,%0")
1638
1639 (define_insn "negsf2"
1640   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
1641         (neg:SF (match_operand:SF 1 "general_operand" "fmF")))]
1642   "TARGET_32081"
1643   "negf %1,%0")
1644
1645 (define_insn "negdi2"
1646   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro")
1647         (neg:DI (match_operand:DI 1 "nonimmediate_operand" "ro")))]
1648   ""
1649   "*
1650 {
1651   rtx low[2], high[2], xops[4];
1652   split_di (operands, 2, low, high);
1653   xops[0] = low[0];
1654   xops[1] = high[0];
1655   xops[2] = low[1];
1656   xops[3] = high[1];
1657
1658   if (rtx_equal_p (operands[0], operands[1]))
1659     {
1660       output_asm_insn (\"negd %3,%1\", xops);
1661       output_asm_insn (\"negd %2,%0\", xops);
1662       output_asm_insn (\"subcd %$0,%1\", xops);
1663     }
1664   else
1665     {
1666       output_asm_insn (\"negd %2,%0\", xops);
1667       output_asm_insn (\"movqd %$0,%1\", xops);
1668       output_asm_insn (\"subcd %3,%1\", xops);
1669     }
1670   return \"\"; 
1671 }")
1672
1673 ;; See note 1
1674 (define_insn "negsi2"
1675   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
1676         (neg:SI (match_operand:SI 1 "general_operand" "g")))]
1677   ""
1678   "negd %1,%0")
1679
1680 (define_insn "neghi2"
1681   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
1682         (neg:HI (match_operand:HI 1 "general_operand" "g")))]
1683   ""
1684   "negw %1,%0")
1685
1686 (define_insn "negqi2"
1687   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
1688         (neg:QI (match_operand:QI 1 "general_operand" "g")))]
1689   ""
1690   "negb %1,%0")
1691 \f
1692 ;; See note 1
1693 (define_insn "one_cmplsi2"
1694   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
1695         (not:SI (match_operand:SI 1 "general_operand" "g")))]
1696   ""
1697   "comd %1,%0")
1698
1699 (define_insn "one_cmplhi2"
1700   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
1701         (not:HI (match_operand:HI 1 "general_operand" "g")))]
1702   ""
1703   "comw %1,%0")
1704
1705 (define_insn "one_cmplqi2"
1706   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
1707         (not:QI (match_operand:QI 1 "general_operand" "g")))]
1708   ""
1709   "comb %1,%0")
1710 \f
1711 ;; arithmetic left and right shift operations
1712 ;; on the 32532 we will always use lshd for arithmetic left shifts,
1713 ;; because it is three times faster.  Broken programs which
1714 ;; use negative shift counts are probably broken differently
1715 ;; than elsewhere.
1716
1717 ;; alternative 0 never matches on the 32532
1718 ;; See note 1
1719 (define_insn "ashlsi3"
1720   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,rm")
1721         (ashift:SI (match_operand:SI 1 "general_operand" "r,0")
1722                    (match_operand:SI 2 "general_operand" "I,g")))]
1723   ""
1724   "*
1725 { if (TARGET_32532)
1726     return \"lshd %2,%0\";
1727   else
1728     return output_shift_insn (operands);
1729 }")
1730
1731 (define_insn "ashlhi3"
1732   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1733         (ashift:HI (match_operand:HI 1 "general_operand" "0")
1734                    (match_operand:SI 2 "general_operand" "g")))]
1735   ""
1736   "*
1737 { if (GET_CODE (operands[2]) == CONST_INT)
1738     {
1739       if (INTVAL (operands[2]) == 1)
1740         return \"addw %0,%0\";
1741       else if (! TARGET_32532 && INTVAL (operands[2]) == 2)
1742         return \"addw %0,%0\;addw %0,%0\";
1743     }
1744   if (TARGET_32532)
1745     return \"lshw %2,%0\";
1746   else
1747     return \"ashw %2,%0\";
1748 }")
1749
1750 (define_insn "ashlqi3"
1751   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1752         (ashift:QI (match_operand:QI 1 "general_operand" "0")
1753                    (match_operand:SI 2 "general_operand" "g")))]
1754   ""
1755   "*
1756 { if (GET_CODE (operands[2]) == CONST_INT)
1757     {
1758       if (INTVAL (operands[2]) == 1)
1759         return \"addb %0,%0\";
1760       else if (! TARGET_32532 && INTVAL (operands[2]) == 2)
1761         return \"addb %0,%0\;addb %0,%0\";
1762     }
1763   if (TARGET_32532)
1764     return \"lshb %2,%0\";
1765   else
1766     return \"ashb %2,%0\";
1767 }")
1768
1769 ;; Arithmetic right shift on the 32k works by negating the shift count.
1770 (define_expand "ashrsi3"
1771   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1772         (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
1773                      (match_operand:SI 2 "general_operand" "g")))]
1774   ""
1775   "
1776 {
1777   if (GET_CODE (operands[2]) != CONST_INT)
1778     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1779 }")
1780
1781 (define_insn "*ashrisi3"
1782   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1783         (ashiftrt:SI (match_operand:SI 1 "general_operand" "0")
1784                      (match_operand:SI 2 "immediate_operand" "i")))]
1785   ""
1786   "ashd %n2,%0")
1787
1788 (define_insn "*ashrsi3"
1789   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1790         (ashiftrt:SI (match_operand:SI 1 "general_operand" "0")
1791                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1792   ""
1793   "ashd %2,%0")
1794
1795 (define_expand "ashrhi3"
1796   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1797         (ashiftrt:HI (match_operand:HI 1 "general_operand" "g")
1798                      (match_operand:SI 2 "general_operand" "g")))]
1799   ""
1800   "
1801 {
1802   if (GET_CODE (operands[2]) != CONST_INT)
1803     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1804 }")
1805
1806 (define_insn "*ashrihi3"
1807   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1808         (ashiftrt:HI (match_operand:HI 1 "general_operand" "0")
1809                      (match_operand:SI 2 "immediate_operand" "i")))]
1810   ""
1811   "ashw %n2,%0")
1812
1813 (define_insn "*ashrhi3"
1814   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1815         (ashiftrt:HI (match_operand:HI 1 "general_operand" "0")
1816                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1817   ""
1818   "ashw %2,%0")
1819
1820 (define_expand "ashrqi3"
1821   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1822         (ashiftrt:QI (match_operand:QI 1 "general_operand" "g")
1823                      (match_operand:SI 2 "general_operand" "g")))]
1824   ""
1825   "
1826 {
1827   if (GET_CODE (operands[2]) != CONST_INT)
1828     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1829 }")
1830
1831 (define_insn "*ashriqi3"
1832   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1833         (ashiftrt:QI (match_operand:QI 1 "general_operand" "0")
1834                      (match_operand:SI 2 "immediate_operand" "i")))]
1835   ""
1836   "ashb %n2,%0")
1837
1838 (define_insn "*ashrqi3"
1839   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1840         (ashiftrt:QI (match_operand:QI 1 "general_operand" "0")
1841                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1842   ""
1843   "ashb %2,%0")
1844
1845 ;; logical shift instructions
1846
1847 ;; Logical right shift on the 32k works by negating the shift count.
1848 (define_expand "lshrsi3"
1849   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1850         (lshiftrt:SI (match_operand:SI 1 "general_operand" "g")
1851                      (match_operand:SI 2 "general_operand" "g")))]
1852   ""
1853   "
1854 {
1855   if (GET_CODE (operands[2]) != CONST_INT)
1856     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1857 }")
1858
1859 (define_insn "*lshrisi3"
1860   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1861         (lshiftrt:SI (match_operand:SI 1 "general_operand" "0")
1862                      (match_operand:SI 2 "immediate_operand" "i")))]
1863   ""
1864   "lshd %n2,%0")
1865
1866 (define_insn "*lshrsi3"
1867   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1868         (lshiftrt:SI (match_operand:SI 1 "general_operand" "0")
1869                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1870   ""
1871   "lshd %2,%0")
1872
1873 (define_expand "lshrhi3"
1874   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1875         (lshiftrt:HI (match_operand:HI 1 "general_operand" "g")
1876                      (match_operand:SI 2 "general_operand" "g")))]
1877   ""
1878   "
1879 {
1880   if (GET_CODE (operands[2]) != CONST_INT)
1881     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1882 }")
1883
1884 (define_insn "*lshrihi3"
1885   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1886         (lshiftrt:HI (match_operand:HI 1 "general_operand" "0")
1887                      (match_operand:SI 2 "immediate_operand" "i")))]
1888   ""
1889   "lshw %n2,%0")
1890
1891 (define_insn "*lshrhi3"
1892   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1893         (lshiftrt:HI (match_operand:HI 1 "general_operand" "0")
1894                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1895   ""
1896   "lshw %2,%0")
1897
1898 (define_expand "lshrqi3"
1899   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1900         (lshiftrt:QI (match_operand:QI 1 "general_operand" "g")
1901                      (match_operand:SI 2 "general_operand" "g")))]
1902   ""
1903   "
1904 {
1905   if (GET_CODE (operands[2]) != CONST_INT)
1906     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1907 }")
1908
1909 (define_insn "*lshriqi3"
1910   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1911         (lshiftrt:QI (match_operand:QI 1 "general_operand" "0")
1912                      (match_operand:SI 2 "immediate_operand" "i")))]
1913   ""
1914   "lshb %n2,%0")
1915
1916 (define_insn "*lshrqi3"
1917   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1918         (lshiftrt:QI (match_operand:QI 1 "general_operand" "0")
1919                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1920   ""
1921   "lshb %2,%0")
1922
1923 ;; Rotate instructions
1924
1925 ;; See note 1
1926 (define_insn "rotlsi3"
1927   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1928         (rotate:SI (match_operand:SI 1 "general_operand" "0")
1929                    (match_operand:SI 2 "general_operand" "g")))]
1930   ""
1931   "rotd %2,%0")
1932
1933 (define_insn "rotlhi3"
1934   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1935         (rotate:HI (match_operand:HI 1 "general_operand" "0")
1936                    (match_operand:SI 2 "general_operand" "g")))]
1937   ""
1938   "rotw %2,%0")
1939
1940 (define_insn "rotlqi3"
1941   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
1942         (rotate:QI (match_operand:QI 1 "general_operand" "0")
1943                    (match_operand:SI 2 "general_operand" "g")))]
1944   ""
1945   "rotb %2,%0")
1946
1947 ;; Right rotate on the 32k works by negating the shift count.
1948 (define_expand "rotrsi3"
1949   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1950         (rotatert:SI (match_operand:SI 1 "general_operand" "g")
1951                      (match_operand:SI 2 "general_operand" "g")))]
1952   ""
1953   "
1954 {
1955   if (GET_CODE (operands[2]) != CONST_INT)
1956     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1957 }")
1958
1959 (define_insn "*rotrisi3"
1960   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1961         (rotatert:SI (match_operand:SI 1 "general_operand" "0")
1962                      (match_operand:SI 2 "immediate_operand" "i")))]
1963   ""
1964   "rotd %n2,%0")
1965
1966 (define_insn "*rotrsi3"
1967   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
1968         (rotatert:SI (match_operand:SI 1 "general_operand" "0")
1969                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1970   ""
1971   "rotd %2,%0")
1972
1973 (define_expand "rotrhi3"
1974   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1975         (rotatert:HI (match_operand:HI 1 "general_operand" "g")
1976                      (match_operand:SI 2 "general_operand" "g")))]
1977   ""
1978   "
1979 {
1980   if (GET_CODE (operands[2]) != CONST_INT)
1981     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
1982 }")
1983
1984 (define_insn "*rotrihi3"
1985   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1986         (rotatert:HI (match_operand:HI 1 "general_operand" "0")
1987                      (match_operand:SI 2 "immediate_operand" "i")))]
1988   ""
1989   "rotw %n2,%0")
1990
1991 (define_insn "*rotrhi3"
1992   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
1993         (rotatert:HI (match_operand:HI 1 "general_operand" "0")
1994                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
1995   ""
1996   "rotw %2,%0")
1997
1998 (define_expand "rotrqi3"
1999   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
2000         (rotatert:QI (match_operand:QI 1 "general_operand" "g")
2001                      (match_operand:SI 2 "general_operand" "g")))]
2002   ""
2003   "
2004 {
2005   if (GET_CODE (operands[2]) != CONST_INT)
2006     operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
2007 }")
2008
2009 (define_insn "*rotriqi3"
2010   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
2011         (rotatert:QI (match_operand:QI 1 "general_operand" "0")
2012                      (match_operand:SI 2 "immediate_operand" "i")))]
2013   ""
2014   "rotb %n2,%0")
2015
2016 (define_insn "*rotrqi3"
2017   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
2018         (rotatert:QI (match_operand:QI 1 "general_operand" "0")
2019                      (neg:SI (match_operand:SI 2 "register_operand" "r"))))]
2020   ""
2021   "rotb %2,%0")
2022 \f
2023 ;;- load or push effective address 
2024 ;; These come after the move, add, and multiply patterns
2025 ;; because we don't want pushl $1 turned into pushad 1.
2026
2027 (define_insn "*addrsi"
2028   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
2029         (match_operand:QI 1 "address_operand" "p"))]
2030   ""
2031   "*
2032 {
2033   if (REG_P (operands[0])
2034       && GET_CODE (operands[1]) == MULT
2035       && GET_CODE (XEXP (operands[1], 1)) == CONST_INT
2036       && (INTVAL (XEXP (operands[1], 1)) == 2
2037           || INTVAL (XEXP (operands[1], 1)) == 4))
2038     {
2039       rtx xoperands[3];
2040       xoperands[0] = operands[0];
2041       xoperands[1] = XEXP (operands[1], 0);
2042       xoperands[2] = GEN_INT (INTVAL (XEXP (operands[1], 1)) >> 1);
2043       return output_shift_insn (xoperands);
2044     }
2045   return \"addr %a1,%0\";
2046 }")
2047 \f
2048 ;;; Index insns.  These are about the same speed as multiply-add counterparts.
2049 ;;; but slower than using power-of-2 shifts if we can use them
2050 ;
2051 ;;; See note 1
2052 ;(define_insn ""
2053 ;  [(set (match_operand:SI 0 "register_operand" "=r")
2054 ;       (plus:SI (match_operand:SI 1 "general_operand" "g")
2055 ;                (mult:SI (match_operand:SI 2 "register_operand" "0")
2056 ;                         (plus:SI (match_operand:SI 3 "general_operand" "g") (const_int 1)))))]
2057 ;  "GET_CODE (operands[3]) != CONST_INT || INTVAL (operands[3]) > 8"
2058 ;  "indexd %0,%3,%1")
2059 ;
2060 ;(define_insn ""
2061 ;  [(set (match_operand:SI 0 "register_operand" "=r")
2062 ;       (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "0")
2063 ;                         (plus:SI (match_operand:SI 2 "general_operand" "g") (const_int 1)))
2064 ;                (match_operand:SI 3 "general_operand" "g")))]
2065 ;  "GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) > 8"
2066 ;  "indexd %0,%2,%3")
2067 \f
2068 ;; Set, Clear, and Invert bit
2069
2070 ;; See note 1
2071 (define_insn "*sbitsi"
2072   [(set (zero_extract:SI (match_operand:SI 0 "nonimmediate_operand" "+rm")
2073                          (const_int 1)
2074                          (match_operand:SI 1 "general_operand" "g"))
2075         (const_int 1))]
2076   ""
2077   "sbitd %1,%0")
2078
2079 ;; See note 1
2080 (define_insn "*cbitsi"
2081   [(set (zero_extract:SI (match_operand:SI 0 "nonimmediate_operand" "+rm")
2082                          (const_int 1)
2083                          (match_operand:SI 1 "general_operand" "g"))
2084         (const_int 0))]
2085   ""
2086   "cbitd %1,%0")
2087
2088 ;; See note 1
2089 (define_insn "*ibitsi"
2090   [(set (match_operand:SI 0 "nonimmediate_operand" "+rm")
2091         (xor:SI (ashift:SI (const_int 1)
2092                            (match_operand:SI 1 "general_operand" "g"))
2093                 (match_dup 0)))]
2094   ""
2095   "ibitd %1,%0")
2096
2097 ;; See note 1
2098 (define_insn "*ibitqi"
2099   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm")
2100         (xor:QI (subreg:QI
2101                  (ashift:SI (const_int 1)
2102                             (match_operand:QI 1 "general_operand" "g")) 0)
2103                 (match_dup 0)))]
2104   ""
2105   "ibitb %1,%0")
2106
2107 ;; Recognize jbs and jbc instructions.
2108
2109 (define_insn "*tbit"
2110   [(set (cc0)
2111         (zero_extract (match_operand:SI 0 "nonimmediate_operand" "rm")
2112                       (const_int 1)
2113                       (match_operand:SI 1 "general_operand" "g")))]
2114   ""
2115   "*
2116 { cc_status.flags = CC_Z_IN_F;
2117   return \"tbitd %1,%0\";
2118 }")
2119
2120 ;; extract(base, width, offset)
2121 ;; Signed bitfield extraction is not supported in hardware on the
2122 ;; NS 32032.  It is therefore better to let GCC figure out a
2123 ;; good strategy for generating the proper instruction sequence
2124 ;; and represent it as rtl.
2125
2126 ;; Optimize the case of extracting a byte or word from a register.
2127 ;; Otherwise we must load a register with the offset of the
2128 ;; chunk we want, and perform an extract insn (each of which
2129 ;; is very expensive).  Since we use the stack to do our bit-twiddling
2130 ;; we cannot use it for a destination.  Perhaps things are fast
2131 ;; enough on the 32532 that such hacks are not needed.
2132
2133 (define_insn "*extract_bytes"
2134   [(set (match_operand:SI 0 "nonimmediate_operand" "=ro")
2135         (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
2136                          (match_operand:SI 2 "const_int_operand" "i")
2137                          (match_operand:SI 3 "const_int_operand" "i")))]
2138   "(INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
2139    && (INTVAL (operands[3]) == 8 || INTVAL (operands[3]) == 16 || INTVAL (operands[3]) == 24)"
2140   "*
2141 {
2142   output_asm_insn (\"movd %1,tos\", operands);
2143   if (INTVAL (operands[2]) == 16)
2144     {
2145       if (INTVAL (operands[3]) == 8)
2146         output_asm_insn (\"movzwd 1(sp),%0\", operands);
2147       else
2148         output_asm_insn (\"movzwd 2(sp),%0\", operands);
2149     }
2150   else
2151     {
2152       if (INTVAL (operands[3]) == 8)
2153         output_asm_insn (\"movzbd 1(sp),%0\", operands);
2154       else if (INTVAL (operands[3]) == 16)
2155         output_asm_insn (\"movzbd 2(sp),%0\", operands);
2156       else
2157         output_asm_insn (\"movzbd 3(sp),%0\", operands);
2158     }
2159   if (TARGET_32532 || TARGET_32332)
2160     return \"cmpqd %$0,tos\";
2161   else
2162     return \"adjspb %$-4\";
2163 }")
2164
2165 ;; The exts/ext instructions have the problem that they always access
2166 ;; 32 bits even if the bitfield is smaller. For example the instruction
2167 ;;      extsd 7(r1),r0,2,5
2168 ;; would read not only at address 7(r1) but also at 8(r1) to 10(r1).
2169 ;; If these addresses are in a different (unmapped) page a memory fault
2170 ;; is the result.
2171 ;;
2172 ;; Timing considerations:
2173 ;;      movd    0(r1),r0        3 bytes
2174 ;;      lshd    -26,r0          4
2175 ;;      andd    0x1f,r0         5
2176 ;; takes about 13 cycles on the 532 while
2177 ;;      extsd   7(r1),r0,2,5    5 bytes
2178 ;; takes about 21 cycles.
2179 ;;
2180 ;; The inss/ins instructions suffer from the same problem.
2181 ;;
2182 ;; A machine specific option (-mbitfield/-mnobitfield) is used
2183 ;; to allow/disallow the use of these instructions.
2184
2185 (define_insn "*bitfield_ext"
2186   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
2187         (zero_extract:SI (match_operand:SI 1 "register_operand" "g")
2188                          (match_operand:SI 2 "const_int_operand" "i")
2189                          (match_operand:SI 3 "nonmemory_operand" "rK")))]
2190   "TARGET_BITFIELD"
2191   "*
2192 { if (GET_CODE (operands[3]) == CONST_INT)
2193     return \"extsd %1,%0,%3,%2\";
2194   else return \"extd %3,%1,%0,%2\";
2195 }")
2196
2197 (define_insn "extzv"
2198   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
2199         (zero_extract:SI (match_operand:QI 1 "general_operand" "g")
2200                          (match_operand:SI 2 "const_int_operand" "i")
2201                          (match_operand:SI 3 "nonmemory_operand" "rK")))]
2202   "TARGET_BITFIELD"
2203   "*
2204 { if (GET_CODE (operands[3]) == CONST_INT)
2205     return \"extsd %1,%0,%3,%2\";
2206   else return \"extd %3,%1,%0,%2\";
2207 }")
2208
2209 (define_insn "*bitfield_set"
2210   [(set (zero_extract:SI (match_operand:SI 0 "memory_operand" "+o,+r")
2211                          (match_operand:SI 1 "const_int_operand" "i,i")
2212                          (match_operand:SI 2 "nonmemory_operand" "rn,rK"))
2213         (match_operand:SI 3 "nonimmediate_operand" "rm,rm"))]
2214   "TARGET_BITFIELD"
2215   "*
2216 { if (GET_CODE (operands[2]) == CONST_INT)
2217     {
2218       if (which_alternative == 0 && INTVAL (operands[2]) >= 8)
2219         {
2220           operands[0] = adjust_address (operands[0], QImode,
2221                                         INTVAL (operands[2]) / 8);
2222           operands[2] = GEN_INT (INTVAL (operands[2]) % 8);
2223         }
2224       if (INTVAL (operands[1]) <= 8)
2225         return \"inssb %3,%0,%2,%1\";
2226       else if (INTVAL (operands[1]) <= 16)
2227         return \"inssw %3,%0,%2,%1\";
2228       else
2229         return \"inssd %3,%0,%2,%1\";
2230     }
2231   return \"insd %2,%3,%0,%1\";
2232 }")
2233
2234
2235 (define_insn "insv"
2236   [(set (zero_extract:SI (match_operand:QI 0 "nonimmediate_operand" "+rm")
2237                          (match_operand:SI 1 "const_int_operand" "i")
2238                          (match_operand:SI 2 "nonmemory_operand" "rK"))
2239         (match_operand:SI 3 "nonimmediate_operand" "rm"))]
2240   "TARGET_BITFIELD"
2241   "*
2242 { if (GET_CODE (operands[2]) == CONST_INT)
2243   {
2244     if (INTVAL (operands[1]) <= 8)
2245       return \"inssb %3,%0,%2,%1\";
2246     else if (INTVAL (operands[1]) <= 16)
2247       return \"inssw %3,%0,%2,%1\";
2248     else
2249       return \"inssd %3,%0,%2,%1\";
2250   }
2251   return \"insd %2,%3,%0,%1\";
2252 }")
2253
2254 \f
2255 (define_insn "jump"
2256   [(set (pc)
2257         (label_ref (match_operand 0 "" "")))]
2258   ""
2259   "br %l0")
2260
2261 (define_insn "beq"
2262   [(set (pc)
2263         (if_then_else (eq (cc0)
2264                           (const_int 0))
2265                       (label_ref (match_operand 0 "" ""))
2266                       (pc)))]
2267   ""
2268   "*
2269 { if (cc_prev_status.flags & CC_Z_IN_F)
2270     return \"bfc %l0\";
2271   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2272     return \"bfs %l0\";
2273   else return \"beq %l0\";
2274 }")
2275
2276 (define_insn "bne"
2277   [(set (pc)
2278         (if_then_else (ne (cc0)
2279                           (const_int 0))
2280                       (label_ref (match_operand 0 "" ""))
2281                       (pc)))]
2282   ""
2283   "*
2284 { if (cc_prev_status.flags & CC_Z_IN_F)
2285     return \"bfs %l0\";
2286   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2287     return \"bfc %l0\";
2288   else return \"bne %l0\";
2289 }")
2290
2291 (define_insn "bgt"
2292   [(set (pc)
2293         (if_then_else (gt (cc0)
2294                           (const_int 0))
2295                       (label_ref (match_operand 0 "" ""))
2296                       (pc)))]
2297   ""
2298   "bgt %l0")
2299
2300 (define_insn "bgtu"
2301   [(set (pc)
2302         (if_then_else (gtu (cc0)
2303                            (const_int 0))
2304                       (label_ref (match_operand 0 "" ""))
2305                       (pc)))]
2306   ""
2307   "bhi %l0")
2308
2309 (define_insn "blt"
2310   [(set (pc)
2311         (if_then_else (lt (cc0)
2312                           (const_int 0))
2313                       (label_ref (match_operand 0 "" ""))
2314                       (pc)))]
2315   ""
2316   "blt %l0")
2317
2318 (define_insn "bltu"
2319   [(set (pc)
2320         (if_then_else (ltu (cc0)
2321                            (const_int 0))
2322                       (label_ref (match_operand 0 "" ""))
2323                       (pc)))]
2324   ""
2325   "blo %l0")
2326
2327 (define_insn "bge"
2328   [(set (pc)
2329         (if_then_else (ge (cc0)
2330                           (const_int 0))
2331                       (label_ref (match_operand 0 "" ""))
2332                       (pc)))]
2333   ""
2334   "bge %l0")
2335
2336 (define_insn "bgeu"
2337   [(set (pc)
2338         (if_then_else (geu (cc0)
2339                            (const_int 0))
2340                       (label_ref (match_operand 0 "" ""))
2341                       (pc)))]
2342   ""
2343   "bhs %l0")
2344
2345 (define_insn "ble"
2346   [(set (pc)
2347         (if_then_else (le (cc0)
2348                           (const_int 0))
2349                       (label_ref (match_operand 0 "" ""))
2350                       (pc)))]
2351   ""
2352   "ble %l0")
2353
2354 (define_insn "bleu"
2355   [(set (pc)
2356         (if_then_else (leu (cc0)
2357                            (const_int 0))
2358                       (label_ref (match_operand 0 "" ""))
2359                       (pc)))]
2360   ""
2361   "bls %l0")
2362 \f
2363 ;; "Reversed" jump instructions. Are these ever generated?
2364
2365 (define_insn "*bne"
2366   [(set (pc)
2367         (if_then_else (eq (cc0)
2368                           (const_int 0))
2369                       (pc)
2370                       (label_ref (match_operand 0 "" ""))))]
2371   ""
2372   "*
2373 { if (cc_prev_status.flags & CC_Z_IN_F)
2374     return \"bfs %l0\";
2375   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2376     return \"bfc %l0\";
2377   else return \"bne %l0\";
2378 }")
2379
2380 (define_insn "*beq"
2381   [(set (pc)
2382         (if_then_else (ne (cc0)
2383                           (const_int 0))
2384                       (pc)
2385                       (label_ref (match_operand 0 "" ""))))]
2386   ""
2387   "*
2388 { if (cc_prev_status.flags & CC_Z_IN_F)
2389     return \"bfc %l0\";
2390   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2391     return \"bfs %l0\";
2392   else return \"beq %l0\";
2393 }")
2394
2395 (define_insn "*ble"
2396   [(set (pc)
2397         (if_then_else (gt (cc0)
2398                           (const_int 0))
2399                       (pc)
2400                       (label_ref (match_operand 0 "" ""))))]
2401   ""
2402   "ble %l0")
2403
2404 (define_insn "*bleu"
2405   [(set (pc)
2406         (if_then_else (gtu (cc0)
2407                            (const_int 0))
2408                       (pc)
2409                       (label_ref (match_operand 0 "" ""))))]
2410   ""
2411   "bls %l0")
2412
2413 (define_insn "*bge"
2414   [(set (pc)
2415         (if_then_else (lt (cc0)
2416                           (const_int 0))
2417                       (pc)
2418                       (label_ref (match_operand 0 "" ""))))]
2419   ""
2420   "bge %l0")
2421
2422 (define_insn "*bgeu"
2423   [(set (pc)
2424         (if_then_else (ltu (cc0)
2425                            (const_int 0))
2426                       (pc)
2427                       (label_ref (match_operand 0 "" ""))))]
2428   ""
2429   "bhs %l0")
2430
2431 (define_insn "*blt"
2432   [(set (pc)
2433         (if_then_else (ge (cc0)
2434                           (const_int 0))
2435                       (pc)
2436                       (label_ref (match_operand 0 "" ""))))]
2437   ""
2438   "blt %l0")
2439
2440 (define_insn "*bltu"
2441   [(set (pc)
2442         (if_then_else (geu (cc0)
2443                            (const_int 0))
2444                       (pc)
2445                       (label_ref (match_operand 0 "" ""))))]
2446   ""
2447   "blo %l0")
2448
2449 (define_insn "*bgt"
2450   [(set (pc)
2451         (if_then_else (le (cc0)
2452                           (const_int 0))
2453                       (pc)
2454                       (label_ref (match_operand 0 "" ""))))]
2455   ""
2456   "bgt %l0")
2457
2458 (define_insn "*bgtu"
2459   [(set (pc)
2460         (if_then_else (leu (cc0)
2461                            (const_int 0))
2462                       (pc)
2463                       (label_ref (match_operand 0 "" ""))))]
2464   ""
2465   "bhi %l0")
2466 \f
2467 ;; Subtract-and-jump and Add-and-jump insns.
2468 ;; These can actually be used for adding numbers in the range -8 to 7
2469
2470 (define_insn "*sub_br"
2471   [(set (pc)
2472         (if_then_else
2473          (ne (match_operand:SI 0 "nonimmediate_operand" "+rm")
2474              (match_operand:SI 1 "const_int_operand" "i"))
2475          (label_ref (match_operand 2 "" ""))
2476          (pc)))
2477   (set (match_dup 0)
2478        (minus:SI (match_dup 0)
2479                  (match_dup 1)))]
2480   "INTVAL (operands[1]) > -8 && INTVAL (operands[1]) <= 8"
2481   "acbd %n1,%0,%l2")
2482
2483 (define_insn "*add_br"
2484   [(set (pc)
2485         (if_then_else
2486          (ne (match_operand:SI 0 "nonimmediate_operand" "+rm")
2487              (match_operand:SI 1 "const_int_operand" "i"))
2488          (label_ref (match_operand 2 "" ""))
2489          (pc)))
2490   (set (match_dup 0)
2491        (plus:SI (match_dup 0)
2492                 (match_operand:SI 3 "const_int_operand" "i")))]
2493   "INTVAL (operands[1]) == - INTVAL (operands[3])
2494    && INTVAL (operands[3]) >= -8 && INTVAL (operands[3]) < 8"
2495   "acbd %3,%0,%l2")
2496 \f
2497 (define_insn "call"
2498   [(call (match_operand:QI 0 "memory_operand" "m")
2499          (match_operand 1 "" ""))]
2500   ;; Operand 1 is not used
2501   ""
2502   "*
2503 {
2504 #ifndef JSR_ALWAYS
2505   if (GET_CODE (operands[0]) == MEM)
2506     {
2507       rtx temp = XEXP (operands[0], 0);
2508       if (CONSTANT_ADDRESS_P (temp))
2509         {
2510 #ifdef ENCORE_ASM
2511           return \"bsr %?%0\";
2512 #else
2513 #ifdef CALL_MEMREF_IMPLICIT
2514           operands[0] = temp;
2515           return \"bsr %0\";
2516 #else
2517 #ifdef GNX_V3
2518           return \"bsr %0\";
2519 #else
2520           return \"bsr %?%a0\";
2521 #endif
2522 #endif
2523 #endif
2524         }
2525       if (GET_CODE (XEXP (operands[0], 0)) == REG)
2526 #if defined (GNX_V3) || defined (CALL_MEMREF_IMPLICIT)
2527         return \"jsr %0\";
2528 #else
2529         return \"jsr %a0\";
2530 #endif
2531     }
2532 #endif /* not JSR_ALWAYS */
2533   return \"jsr %0\";
2534 }")
2535
2536 (define_insn "call_value"
2537   [(set (match_operand 0 "" "=rf")
2538         (call (match_operand:QI 1 "memory_operand" "m")
2539               (match_operand 2 "" "")))]
2540    ;; Operand 2 is not used
2541   ""
2542   "*
2543 {
2544 #ifndef JSR_ALWAYS
2545   if (GET_CODE (operands[1]) == MEM)
2546     {
2547       rtx temp = XEXP (operands[1], 0);
2548       if (CONSTANT_ADDRESS_P (temp))
2549         {
2550 #ifdef ENCORE_ASM
2551           return \"bsr %?%1\";
2552 #else
2553 #ifdef CALL_MEMREF_IMPLICIT
2554           operands[1] = temp;
2555           return \"bsr %1\";
2556 #else
2557 #ifdef GNX_V3
2558           return \"bsr %1\";
2559 #else
2560           return \"bsr %?%a1\";
2561 #endif
2562 #endif
2563 #endif
2564         }
2565       if (GET_CODE (XEXP (operands[1], 0)) == REG)
2566 #if defined (GNX_V3) || defined (CALL_MEMREF_IMPLICIT)
2567         return \"jsr %1\";
2568 #else
2569         return \"jsr %a1\";
2570 #endif
2571     }
2572 #endif /* not JSR_ALWAYS */
2573   return \"jsr %1\";
2574 }")
2575
2576 ;; Call subroutine returning any type.
2577
2578 (define_expand "untyped_call"
2579   [(parallel [(call (match_operand 0 "" "")
2580                     (const_int 0))
2581               (match_operand 1 "" "")
2582               (match_operand 2 "" "")])]
2583   ""
2584   "
2585 {
2586   int i;
2587
2588   emit_call_insn (GEN_CALL (operands[0], const0_rtx, NULL, const0_rtx));
2589
2590   for (i = 0; i < XVECLEN (operands[2], 0); i++)
2591     {
2592       rtx set = XVECEXP (operands[2], 0, i);
2593       emit_move_insn (SET_DEST (set), SET_SRC (set));
2594     }
2595
2596   /* The optimizer does not know that the call sets the function value
2597      registers we stored in the result block.  We avoid problems by
2598      claiming that all hard registers are used and clobbered at this
2599      point.  */
2600   emit_insn (gen_blockage ());
2601
2602   DONE;
2603 }")
2604
2605 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
2606 ;; all of memory.  This blocks insns from being moved across this point.
2607
2608 (define_insn "blockage"
2609   [(unspec_volatile [(const_int 0)] 0)]
2610   ""
2611   "")
2612
2613 (define_insn "return"
2614   [(return)]
2615   "0"
2616   "ret 0")
2617
2618 (define_insn "abssf2"
2619   [(set (match_operand:SF 0 "nonimmediate_operand" "=fm<")
2620         (abs:SF (match_operand:SF 1 "general_operand" "fmF")))]
2621   "TARGET_32081"
2622   "absf %1,%0")
2623
2624 (define_insn "absdf2"
2625   [(set (match_operand:DF 0 "nonimmediate_operand" "=lm<")
2626         (abs:DF (match_operand:DF 1 "general_operand" "lmF")))]
2627   "TARGET_32081"
2628   "absl %1,%0")
2629
2630 ;; See note 1
2631 (define_insn "abssi2"
2632   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm<")
2633         (abs:SI (match_operand:SI 1 "general_operand" "g")))]
2634   ""
2635   "absd %1,%0")
2636
2637 (define_insn "abshi2"
2638   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm<")
2639         (abs:HI (match_operand:HI 1 "general_operand" "g")))]
2640   ""
2641   "absw %1,%0")
2642
2643 (define_insn "absqi2"
2644   [(set (match_operand:QI 0 "nonimmediate_operand" "=rm<")
2645         (abs:QI (match_operand:QI 1 "general_operand" "g")))]
2646   ""
2647   "absb %1,%0")
2648
2649 (define_insn "nop"
2650   [(const_int 0)]
2651   ""
2652   "nop")
2653
2654 (define_insn "indirect_jump"
2655   [(set (pc) (match_operand:SI 0 "register_operand" "r"))]
2656   ""
2657   "jump %0")
2658 \f
2659 (define_insn "tablejump"
2660   [(set (pc)
2661         (plus:SI (pc) (match_operand:SI 0 "general_operand" "g")))
2662    (use (label_ref (match_operand 1 "" "")))]
2663   ""
2664   "*
2665 {
2666   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, \"LI\",
2667                              CODE_LABEL_NUMBER (operands[1]));
2668   return \"cased %0\";
2669 }")
2670
2671 ;; Scondi instructions
2672 (define_insn "seq"
2673   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2674         (eq:SI (cc0) (const_int 0)))]
2675   ""
2676   "*
2677 { if (cc_prev_status.flags & CC_Z_IN_F)
2678     return \"sfcd %0\";
2679   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2680     return \"sfsd %0\";
2681   else return \"seqd %0\";
2682 }")
2683
2684 (define_insn "*seqhi"
2685   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2686         (eq:HI (cc0) (const_int 0)))]
2687   ""
2688   "*
2689 { if (cc_prev_status.flags & CC_Z_IN_F)
2690     return \"sfcw %0\";
2691   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2692     return \"sfsw %0\";
2693   else return \"seqw %0\";
2694 }")
2695
2696 (define_insn "*seqqi"
2697   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2698         (eq:QI (cc0) (const_int 0)))]
2699   ""
2700   "*
2701 { if (cc_prev_status.flags & CC_Z_IN_F)
2702     return \"sfcb %0\";
2703   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2704     return \"sfsb %0\";
2705   else return \"seqb %0\";
2706 }")
2707
2708 (define_insn "sne"
2709   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2710         (ne:SI (cc0) (const_int 0)))]
2711   ""
2712   "*
2713 { if (cc_prev_status.flags & CC_Z_IN_F)
2714     return \"sfsd %0\";
2715   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2716     return \"sfcd %0\";
2717   else return \"sned %0\";
2718 }")
2719
2720 (define_insn "*snehi"
2721   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2722         (ne:HI (cc0) (const_int 0)))]
2723   ""
2724   "*
2725 { if (cc_prev_status.flags & CC_Z_IN_F)
2726     return \"sfsw %0\";
2727   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2728     return \"sfcw %0\";
2729   else return \"snew %0\";
2730 }")
2731
2732 (define_insn "*sneqi"
2733   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2734         (ne:QI (cc0) (const_int 0)))]
2735   ""
2736   "*
2737 { if (cc_prev_status.flags & CC_Z_IN_F)
2738     return \"sfsb %0\";
2739   else if (cc_prev_status.flags & CC_Z_IN_NOT_F)
2740     return \"sfcb %0\";
2741   else return \"sneb %0\";
2742 }")
2743
2744 (define_insn "sgt"
2745   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2746         (gt:SI (cc0) (const_int 0)))]
2747   ""
2748   "sgtd %0")
2749
2750 (define_insn "*sgthi"
2751   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2752         (gt:HI (cc0) (const_int 0)))]
2753   ""
2754   "sgtw %0")
2755
2756 (define_insn "*sgtqi"
2757   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2758         (gt:QI (cc0) (const_int 0)))]
2759   ""
2760   "sgtb %0")
2761
2762 (define_insn "sgtu"
2763   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2764         (gtu:SI (cc0) (const_int 0)))]
2765   ""
2766   "shid %0")
2767
2768 (define_insn "*sgtuhi"
2769   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2770         (gtu:HI (cc0) (const_int 0)))]
2771   ""
2772   "shiw %0")
2773
2774 (define_insn "*sgtuqi"
2775   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2776         (gtu:QI (cc0) (const_int 0)))]
2777   ""
2778   "shib %0")
2779
2780 (define_insn "slt"
2781   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2782         (lt:SI (cc0) (const_int 0)))]
2783   ""
2784   "sltd %0")
2785
2786 (define_insn "*slthi"
2787   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2788         (lt:HI (cc0) (const_int 0)))]
2789   ""
2790   "sltw %0")
2791
2792 (define_insn "*sltqi"
2793   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2794         (lt:QI (cc0) (const_int 0)))]
2795   ""
2796   "sltb %0")
2797
2798 (define_insn "sltu"
2799   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2800         (ltu:SI (cc0) (const_int 0)))]
2801   ""
2802   "slod %0")
2803
2804 (define_insn "*sltuhi"
2805   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2806         (ltu:HI (cc0) (const_int 0)))]
2807   ""
2808   "slow %0")
2809
2810 (define_insn "*sltuqi"
2811   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2812         (ltu:QI (cc0) (const_int 0)))]
2813   ""
2814   "slob %0")
2815
2816 (define_insn "sge"
2817   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2818         (ge:SI (cc0) (const_int 0)))]
2819   ""
2820   "sged %0")
2821
2822 (define_insn "*sgehi"
2823   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2824         (ge:HI (cc0) (const_int 0)))]
2825   ""
2826   "sgew %0")
2827
2828 (define_insn "*sgeqi"
2829   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2830         (ge:QI (cc0) (const_int 0)))]
2831   ""
2832   "sgeb %0")
2833
2834 (define_insn "sgeu"
2835   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2836         (geu:SI (cc0) (const_int 0)))]
2837   ""
2838   "shsd %0")  
2839
2840 (define_insn "*sgeuhi"
2841   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2842         (geu:HI (cc0) (const_int 0)))]
2843   ""
2844   "shsw %0")  
2845
2846 (define_insn "*sgeuqi"
2847   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2848         (geu:QI (cc0) (const_int 0)))]
2849   ""
2850   "shsb %0")  
2851
2852 (define_insn "sle"
2853   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2854         (le:SI (cc0) (const_int 0)))]
2855   ""
2856   "sled %0")
2857
2858 (define_insn "*slehi"
2859   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2860         (le:HI (cc0) (const_int 0)))]
2861   ""
2862   "slew %0")
2863
2864 (define_insn "*sleqi"
2865   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2866         (le:QI (cc0) (const_int 0)))]
2867   ""
2868   "sleb %0")
2869
2870 (define_insn "sleu"
2871   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<")
2872         (leu:SI (cc0) (const_int 0)))]
2873   ""
2874   "slsd %0")
2875
2876 (define_insn "*sleuhi"
2877   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<")
2878         (leu:HI (cc0) (const_int 0)))]
2879   ""
2880   "slsw %0")
2881
2882 (define_insn "*sleuqi"
2883   [(set (match_operand:QI 0 "nonimmediate_operand" "=r<")
2884         (leu:QI (cc0) (const_int 0)))]
2885   ""
2886   "slsb %0")
2887 \f
2888 ;; ffs instructions
2889
2890 (define_insn "*ffs"
2891   [(set (match_operand:SI 0 "nonimmediate_operand" "=ro")
2892         (minus:SI 
2893                 (plus:SI (ffs:SI (zero_extract:SI 
2894                                 (match_operand:SI 1 "general_operand" "g") 
2895                                 (minus:SI (const_int 32) (match_dup 0))
2896                                 (match_dup 0)))
2897                         (match_dup 0)) 
2898                 (const_int 1)))]
2899   ""
2900   "ffsd %1,%0; bfc 1f; addqd %$-1,%0; 1:")
2901
2902 (define_expand "ffssi2"
2903   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm") (const_int 0))
2904    (set (match_dup 0)
2905         (minus:SI 
2906                 (plus:SI (ffs:SI (zero_extract:SI 
2907                                 (match_operand:SI 1 "general_operand" "g") 
2908                                 (minus:SI (const_int 32) (match_dup 0))
2909                                 (match_dup 0)))
2910                         (match_dup 0)) 
2911                 (const_int 1)))
2912    (set (match_dup 0)
2913         (plus:SI (match_dup 0)
2914                  (const_int 1)))]
2915   ""
2916   "operands[1] = make_safe_from(operands[1], operands[0]);")
2917 \f
2918 ;; Speed up stack adjust followed by a HI fixedpoint push.
2919
2920 (define_peephole
2921   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int -2)))
2922    (set (match_operand:HI 0 "push_operand" "=m")
2923         (match_operand:HI 1 "general_operand" "g"))]
2924   "! reg_mentioned_p (stack_pointer_rtx, operands[1])"
2925   "*
2926 {
2927   if (GET_CODE (operands[1]) == CONST_INT)
2928         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,tos\"),
2929                          operands);
2930   else
2931         output_asm_insn (\"movzwd %1,tos\", operands);
2932   return \"\";
2933 }")
2934
2935 ;; Speed up stack adjust followed by a zero_extend:HI(QI) fixedpoint push.
2936
2937 (define_peephole
2938   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int -2)))
2939    (set (match_operand:HI 0 "push_operand" "=m")
2940         (zero_extend:HI (match_operand:QI 1 "general_operand" "g")))]
2941   "! reg_mentioned_p (stack_pointer_rtx, operands[1])"
2942   "*
2943 {
2944   if (GET_CODE (operands[1]) == CONST_INT)
2945         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,tos\"),
2946                          operands);
2947   else
2948         output_asm_insn (\"movzbd %1,tos\", operands);
2949   return \"\";
2950 }")
2951
2952 ;; Speed up stack adjust followed by a sign_extend:HI(QI) fixedpoint push.
2953
2954 (define_peephole
2955   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int -2)))
2956    (set (match_operand:HI 0 "push_operand" "=m")
2957         (sign_extend:HI (match_operand:QI 1 "general_operand" "g")))]
2958   "! reg_mentioned_p (stack_pointer_rtx, operands[1])"
2959   "*
2960 {
2961   if (GET_CODE (operands[1]) == CONST_INT)
2962         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,tos\"),
2963                          operands);
2964   else
2965         output_asm_insn (\"movxbd %1,tos\", operands);
2966   return \"\";
2967 }")
2968
2969 ;; Speed up stack adjust followed by a QI fixedpoint push.
2970
2971 (define_peephole
2972   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int -3)))
2973    (set (match_operand:QI 0 "push_operand" "=m")
2974         (match_operand:QI 1 "general_operand" "g"))]
2975   "! reg_mentioned_p (stack_pointer_rtx, operands[1])"
2976   "*
2977 {
2978   if (GET_CODE (operands[1]) == CONST_INT)
2979         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,tos\"),
2980                          operands);
2981   else
2982         output_asm_insn (\"movzbd %1,tos\", operands);
2983   return \"\";
2984 }")
2985
2986 ;; Speed up stack adjust followed by a SI fixedpoint push.
2987
2988 (define_peephole
2989   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int 4)))
2990    (set (match_operand:SI 0 "push_operand" "=m")
2991         (match_operand:SI 1 "general_operand" "g"))]
2992   "! reg_mentioned_p (stack_pointer_rtx, operands[1])"
2993   "*
2994 {
2995   if (GET_CODE (operands[1]) == CONST_INT)
2996         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,0(sp)\"),
2997                          operands);
2998   else if (GET_CODE (operands[1]) != REG
2999            && GET_CODE (operands[1]) != MEM
3000            && address_operand (operands[1], SImode))
3001         output_asm_insn (\"addr %a1,0(sp)\", operands);
3002   else
3003         output_asm_insn (\"movd %1,0(sp)\", operands);
3004   return \"\";
3005 }")
3006
3007 ;; Speed up stack adjust followed by two fullword fixedpoint pushes.
3008
3009 (define_peephole
3010   [(set (reg:SI 25) (plus:SI (reg:SI 25) (const_int 8)))
3011    (set (match_operand:SI 0 "push_operand" "=m")
3012         (match_operand:SI 1 "general_operand" "g"))
3013    (set (match_operand:SI 2 "push_operand" "=m")
3014         (match_operand:SI 3 "general_operand" "g"))]
3015   "! reg_mentioned_p (stack_pointer_rtx, operands[1])
3016    && ! reg_mentioned_p (stack_pointer_rtx, operands[3])"
3017   "*
3018 {
3019   if (GET_CODE (operands[1]) == CONST_INT)
3020         output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%1,4(sp)\"),
3021                          operands);
3022   else if (GET_CODE (operands[1]) != REG
3023            && GET_CODE (operands[1]) != MEM
3024            && address_operand (operands[1], SImode))
3025         output_asm_insn (\"addr %a1,4(sp)\", operands);
3026   else
3027         output_asm_insn (\"movd %1,4(sp)\", operands);
3028
3029   if (GET_CODE (operands[3]) == CONST_INT)
3030         output_asm_insn (output_move_dconst (INTVAL (operands[3]), \"%3,0(sp)\"),
3031                          operands);
3032   else if (GET_CODE (operands[3]) != REG
3033            && GET_CODE (operands[3]) != MEM
3034            && address_operand (operands[3], SImode))
3035         output_asm_insn (\"addr %a3,0(sp)\", operands);
3036   else
3037         output_asm_insn (\"movd %3,0(sp)\", operands);
3038   return \"\";
3039 }")