OSDN Git Service

* config/m68k/m68k-none.h: Introduce new ColdFire archs.
[pf3gnuchains/gcc-fork.git] / gcc / config / m68k / m68k.md
1 ;;- Machine description for GNU compiler, Motorola 68000 Version
2 ;;  Copyright (C) 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003
3 ;;  Free Software Foundation, Inc.
4
5 ;; This file is part of GNU CC.
6
7 ;; GNU CC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 2, or (at your option)
10 ;; any later version.
11
12 ;; GNU CC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 ;; GNU General Public License for more details.
16
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GNU CC; see the file COPYING.  If not, write to
19 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
20 ;; Boston, MA 02111-1307, USA.
21
22 ;;- Information about MCF5200 port.
23
24 ;;- The MCF5200 "ColdFire" architecture is a reduced version of the
25 ;;- 68k ISA.  Differences include reduced support for byte and word
26 ;;- operands and the removal of BCD, bitfield, rotate, and integer
27 ;;- divide instructions.  The TARGET_COLDFIRE flag turns the use of the
28 ;;- removed opcodes and addressing modes off.
29 ;;- 
30
31
32 ;;- instruction definitions
33
34 ;;- @@The original PO technology requires these to be ordered by speed,
35 ;;- @@    so that assigner will pick the fastest.
36
37 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
38
39 ;;- When naming insn's (operand 0 of define_insn) be careful about using
40 ;;- names from other targets machine descriptions.
41
42 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
43 ;;- updates for most instructions.
44
45 ;;- Operand classes for the register allocator:
46 ;;- 'a' one of the address registers can be used.
47 ;;- 'd' one of the data registers can be used.
48 ;;- 'f' one of the m68881 registers can be used
49 ;;- 'r' either a data or an address register can be used.
50
51 ;;- Immediate Floating point operator constraints
52 ;;- 'G' a floating point constant that is *NOT* one of the standard
53 ;;   68881 constant values (to force calling output_move_const_double
54 ;;   to get it from rom if it is a 68881 constant).
55 ;;
56 ;;   See the functions standard_XXX_constant_p in output-m68k.c for more
57 ;; info.
58
59 ;;- Immediate integer operand constraints:
60 ;;- 'I'  1 .. 8
61 ;;- 'J'  -32768 .. 32767
62 ;;- 'K'  all integers EXCEPT -128 .. 127
63 ;;- 'L'  -8 .. -1
64 ;;- 'M'  all integers EXCEPT -256 .. 255
65 ;;- 'N'  24 .. 31
66 ;;- 'O'  16
67 ;;- 'P'  8 .. 15
68
69 ;;- Assembler specs:
70 ;;- "%."    size separator ("." or "")                  move%.l d0,d1
71 ;;- "%#"    immediate separator ("#" or "")             move%.l %#0,d0
72 ;;- "%-"    push operand "sp@-"                         move%.l d0,%-
73 ;;- "%+"    pop operand "sp@+"                          move%.l d0,%+
74 ;;- "%@"    top of stack "sp@"                          move%.l d0,%@
75 ;;- "%!"    fpcr register
76 ;;- "%$"    single-precision fp specifier ("s" or "")   f%$add.x fp0,fp1
77 ;;- "%&"    double-precision fp specifier ("d" or "")   f%&add.x fp0,fp1
78
79 ;;- Information about 68040 port.
80
81 ;;- The 68040 executes all 68030 and 68881/2 instructions, but some must
82 ;;- be emulated in software by the OS.  It is faster to avoid these
83 ;;- instructions and issue a library call rather than trapping into
84 ;;- the kernel.  The affected instructions are fintrz and fscale.  The
85 ;;- TARGET_68040 flag turns the use of the opcodes off.
86
87 ;;- The '040 also implements a set of new floating-point instructions
88 ;;- which specify the rounding precision in the opcode.  This finally
89 ;;- permit the 68k series to be truly IEEE compliant, and solves all
90 ;;- issues of excess precision accumulating in the extended registers.
91 ;;- By default, GCC does not use these instructions, since such code will
92 ;;- not run on an '030.  To use these instructions, use the -m68040-only
93 ;;- switch.  By changing TARGET_DEFAULT to include TARGET_68040_ONLY,
94 ;;- you can make these instructions the default.
95
96 ;;- These new instructions aren't directly in the md.  They are brought
97 ;;- into play by defining "%$" and "%&" to expand to "s" and "d" rather
98 ;;- than "".
99
100 ;;- Information about 68060 port.
101
102 ;;- The 68060 executes all 68030 and 68881/2 instructions, but some must
103 ;;- be emulated in software by the OS.  It is faster to avoid these
104 ;;- instructions and issue a library call rather than trapping into
105 ;;- the kernel.  The affected instructions are: divs.l <ea>,Dr:Dq;
106 ;;- divu.l <ea>,Dr:Dq; muls.l <ea>,Dr:Dq; mulu.l <ea>,Dr:Dq; and
107 ;;- fscale.  The TARGET_68060 flag turns the use of the opcodes off.
108
109 ;;- Some of these insn's are composites of several m68000 op codes.
110 ;;- The assembler (or final @@??) insures that the appropriate one is
111 ;;- selected.
112
113 ;; UNSPEC usage:
114
115 (define_constants
116   [(UNSPEC_SIN  1)
117    (UNSPEC_COS  2)
118   ])
119
120 ;; UNSPEC_VOLATILE usage:
121
122 (define_constants
123   [(UNSPECV_BLOCKAGE    0)
124   ])
125 \f
126 (define_insn ""
127   [(set (match_operand:DF 0 "push_operand" "=m")
128         (match_operand:DF 1 "general_operand" "ro<>fyE"))]
129   ""
130   "*
131 {
132   if (FP_REG_P (operands[1]))
133     return \"fmove%.d %f1,%0\";
134   return output_move_double (operands);
135 }")
136
137 (define_insn "pushdi"
138   [(set (match_operand:DI 0 "push_operand" "=m")
139         (match_operand:DI 1 "general_operand" "ro<>Fyi"))]
140   ""
141   "*
142 {
143   return output_move_double (operands);
144 }")
145 \f
146 ;; We don't want to allow a constant operand for test insns because
147 ;; (set (cc0) (const_int foo)) has no mode information.  Such insns will
148 ;; be folded while optimizing anyway.
149
150 (define_expand "tstdi"
151   [(parallel [(set (cc0)
152                    (match_operand:DI 0 "nonimmediate_operand" ""))
153               (clobber (match_scratch:SI 1 ""))
154               (clobber (match_scratch:DI 2 ""))])]
155   ""
156   "m68k_last_compare_had_fp_operands = 0;")
157
158 (define_insn ""
159   [(set (cc0)
160         (match_operand:DI 0 "nonimmediate_operand" "am,d"))
161    (clobber (match_scratch:SI 1 "=X,d"))
162    (clobber (match_scratch:DI 2 "=d,X"))]
163   ""
164   "*
165 {
166   if (which_alternative == 0)
167     {
168       rtx xoperands[2];
169
170       xoperands[0] = operands[2];
171       xoperands[1] = operands[0];
172       output_move_double (xoperands);
173       cc_status.flags |= CC_REVERSED;
174       return \"neg%.l %R2\;negx%.l %2\";
175     }
176   if (find_reg_note (insn, REG_DEAD, operands[0]))
177     {
178       cc_status.flags |= CC_REVERSED;
179       return \"neg%.l %R0\;negx%.l %0\";
180     }
181   else
182     /*
183     ** 'sub' clears %1, and also clears the X cc bit
184     ** 'tst' sets the Z cc bit according to the low part of the DImode operand
185     ** 'subx %1' (i.e. subx #0) acts as a (non-existent) tstx on the high part
186     */
187     return \"sub%.l %1,%1\;tst%.l %R0\;subx%.l %1,%0\";
188 }")
189
190 (define_expand "tstsi"
191   [(set (cc0)
192         (match_operand:SI 0 "nonimmediate_operand" ""))]
193   ""
194   "m68k_last_compare_had_fp_operands = 0;")
195
196 (define_insn ""
197   [(set (cc0)
198         (match_operand:SI 0 "nonimmediate_operand" "rm"))]
199   ""
200   "*
201 {
202   if (TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P (operands[0]))
203     return \"tst%.l %0\";
204   /* If you think that the 68020 does not support tstl a0,
205      reread page B-167 of the 68020 manual more carefully.  */
206   /* On an address reg, cmpw may replace cmpl.  */
207 #ifdef SGS_CMP_ORDER
208   return \"cmp%.w %0,%#0\";
209 #else
210   return \"cmp%.w %#0,%0\";
211 #endif
212 }")
213
214 ;; This can't use an address register, because comparisons
215 ;; with address registers as second operand always test the whole word.
216 (define_expand "tsthi"
217   [(set (cc0)
218         (match_operand:HI 0 "nonimmediate_operand" ""))]
219   ""
220   "m68k_last_compare_had_fp_operands = 0;")
221
222 (define_insn ""
223   [(set (cc0)
224         (match_operand:HI 0 "nonimmediate_operand" "dm"))]
225   ""
226   "tst%.w %0")
227
228 (define_expand "tstqi"
229   [(set (cc0)
230         (match_operand:QI 0 "nonimmediate_operand" ""))]
231   ""
232   "m68k_last_compare_had_fp_operands = 0;")
233
234 (define_insn ""
235   [(set (cc0)
236         (match_operand:QI 0 "nonimmediate_operand" "dm"))]
237   ""
238   "tst%.b %0")
239
240 (define_expand "tstsf"
241   [(set (cc0)
242         (match_operand:SF 0 "general_operand" ""))]
243   "TARGET_68881"
244   "
245 {
246   m68k_last_compare_had_fp_operands = 1;
247 }")
248
249 (define_insn ""
250   [(set (cc0)
251         (match_operand:SF 0 "general_operand" "fdm"))]
252   "TARGET_68881"
253   "*
254 {
255   cc_status.flags = CC_IN_68881;
256   if (FP_REG_P (operands[0]))
257     return \"ftst%.x %0\";
258   return \"ftst%.s %0\";
259 }")
260
261 (define_expand "tstdf"
262   [(set (cc0)
263         (match_operand:DF 0 "general_operand" ""))]
264   "TARGET_68881"
265   "
266 {
267   m68k_last_compare_had_fp_operands = 1;
268 }")
269
270 (define_insn ""
271   [(set (cc0)
272         (match_operand:DF 0 "general_operand" "fm"))]
273   "TARGET_68881"
274   "*
275 {
276   cc_status.flags = CC_IN_68881;
277   if (FP_REG_P (operands[0]))
278     return \"ftst%.x %0\";
279   return \"ftst%.d %0\";
280 }")
281 \f
282 ;; compare instructions.
283
284 (define_expand "cmpdi"
285   [(parallel
286     [(set (cc0)
287           (compare (match_operand:DI 0 "nonimmediate_operand" "")
288                    (match_operand:DI 1 "general_operand" "")))
289      (clobber (match_dup 2))])]
290   ""
291   "m68k_last_compare_had_fp_operands = 0; operands[2] = gen_reg_rtx (DImode);")
292
293 (define_insn ""
294   [(set (cc0)
295         (compare (match_operand:DI 1 "nonimmediate_operand" "0,d")
296                  (match_operand:DI 2 "general_operand" "d,0")))
297    (clobber (match_operand:DI 0 "register_operand" "=d,d"))]
298   ""
299   "*
300 {
301   if (rtx_equal_p (operands[0], operands[1]))
302     return \"sub%.l %R2,%R0\;subx%.l %2,%0\";
303   else
304     {
305       cc_status.flags |= CC_REVERSED;
306       return \"sub%.l %R1,%R0\;subx%.l %1,%0\";
307     }
308 }")
309
310 ;; This is the second "hook" for PIC code (in addition to movsi). See
311 ;; comment of movsi for a description of PIC handling.
312 (define_expand "cmpsi"
313   [(set (cc0)
314         (compare (match_operand:SI 0 "nonimmediate_operand" "")
315                  (match_operand:SI 1 "general_operand" "")))]
316   ""
317   "
318 {
319   m68k_last_compare_had_fp_operands = 0;
320   if (flag_pic && !TARGET_PCREL && symbolic_operand (operands[1], SImode))
321     {
322       /* The source is an address which requires PIC relocation.
323          Call legitimize_pic_address with the source, mode, and a relocation
324          register (a new pseudo, or the final destination if reload_in_progress
325          is set).   Then fall through normally */
326       rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
327       operands[1] = legitimize_pic_address (operands[1], SImode, temp);
328     }
329 }")
330
331 ;; A composite of the cmp, cmpa, cmpi & cmpm m68000 op codes.
332 (define_insn ""
333   [(set (cc0)
334         (compare (match_operand:SI 0 "nonimmediate_operand" "rKT,rKs,mSr,mSa,>")
335                  (match_operand:SI 1 "general_src_operand" "mSr,mSa,KTr,Ksr,>")))]
336   "!TARGET_COLDFIRE"
337   "*
338 {
339   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
340 #ifdef SGS_CMP_ORDER
341     return \"cmpm%.l %0,%1\";
342 #else
343     return \"cmpm%.l %1,%0\";
344 #endif
345   if (REG_P (operands[1])
346       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
347     { cc_status.flags |= CC_REVERSED;
348 #ifdef SGS_CMP_ORDER
349       return \"cmp%.l %d1,%d0\";
350 #else
351       return \"cmp%.l %d0,%d1\";
352 #endif
353     }
354   if (ADDRESS_REG_P (operands[0])
355       && GET_CODE (operands[1]) == CONST_INT
356       && INTVAL (operands[1]) < 0x8000
357       && INTVAL (operands[1]) >= -0x8000)
358     {
359 #ifdef SGS_CMP_ORDER
360       return \"cmp%.w %0,%1\";
361 #else
362       return \"cmp%.w %1,%0\";
363 #endif
364     }
365 #ifdef SGS_CMP_ORDER
366   return \"cmp%.l %d0,%d1\";
367 #else
368   return \"cmp%.l %d1,%d0\";
369 #endif
370 }")
371
372 (define_insn ""
373   [(set (cc0)
374         (compare (match_operand:SI 0 "nonimmediate_operand" "mrKs,r")
375                  (match_operand:SI 1 "general_operand" "r,mrKs")))]
376   "TARGET_COLDFIRE"
377   "*
378 {
379   if (REG_P (operands[1])
380       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
381     { cc_status.flags |= CC_REVERSED;
382 #ifdef SGS_CMP_ORDER
383       return \"cmp%.l %d1,%d0\";
384 #else
385       return \"cmp%.l %d0,%d1\";
386 #endif
387     }
388 #ifdef SGS_CMP_ORDER
389   return \"cmp%.l %d0,%d1\";
390 #else
391   return \"cmp%.l %d1,%d0\";
392 #endif
393 }")
394
395 (define_expand "cmphi"
396   [(set (cc0)
397         (compare (match_operand:HI 0 "nonimmediate_src_operand" "")
398                  (match_operand:HI 1 "general_src_operand" "")))]
399   "!TARGET_COLDFIRE"
400   "m68k_last_compare_had_fp_operands = 0;")
401
402 (define_insn ""
403   [(set (cc0)
404         (compare (match_operand:HI 0 "nonimmediate_src_operand" "rnmS,d,n,mS,>")
405                  (match_operand:HI 1 "general_src_operand" "d,rnmS,mS,n,>")))]
406   "!TARGET_COLDFIRE"
407   "*
408 {
409   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
410 #ifdef SGS_CMP_ORDER
411     return \"cmpm%.w %0,%1\";
412 #else
413     return \"cmpm%.w %1,%0\";
414 #endif
415   if ((REG_P (operands[1]) && !ADDRESS_REG_P (operands[1]))
416       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
417     { cc_status.flags |= CC_REVERSED;
418 #ifdef SGS_CMP_ORDER
419       return \"cmp%.w %d1,%d0\";
420 #else
421       return \"cmp%.w %d0,%d1\";
422 #endif
423     }
424 #ifdef SGS_CMP_ORDER
425   return \"cmp%.w %d0,%d1\";
426 #else
427   return \"cmp%.w %d1,%d0\";
428 #endif
429 }")
430
431 (define_expand "cmpqi"
432   [(set (cc0)
433         (compare (match_operand:QI 0 "nonimmediate_src_operand" "")
434                  (match_operand:QI 1 "general_src_operand" "")))]
435   "!TARGET_COLDFIRE"
436   "m68k_last_compare_had_fp_operands = 0;")
437
438 (define_insn ""
439   [(set (cc0)
440         (compare (match_operand:QI 0 "nonimmediate_src_operand" "dn,dmS,>")
441                  (match_operand:QI 1 "general_src_operand" "dmS,nd,>")))]
442   "!TARGET_COLDFIRE"
443   "*
444 {
445   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
446 #ifdef SGS_CMP_ORDER
447     return \"cmpm%.b %0,%1\";
448 #else
449     return \"cmpm%.b %1,%0\";
450 #endif
451   if (REG_P (operands[1])
452       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
453     { cc_status.flags |= CC_REVERSED;
454 #ifdef SGS_CMP_ORDER
455       return \"cmp%.b %d1,%d0\";
456 #else
457       return \"cmp%.b %d0,%d1\";
458 #endif
459     }
460 #ifdef SGS_CMP_ORDER
461   return \"cmp%.b %d0,%d1\";
462 #else
463   return \"cmp%.b %d1,%d0\";
464 #endif
465 }")
466
467 (define_expand "cmpdf"
468   [(set (cc0)
469         (compare (match_operand:DF 0 "general_operand" "")
470                  (match_operand:DF 1 "general_operand" "")))]
471   "TARGET_68881"
472   "
473 {
474   m68k_last_compare_had_fp_operands = 1;
475 }")
476
477 (define_insn ""
478   [(set (cc0)
479         (compare (match_operand:DF 0 "general_operand" "f,mG")
480                  (match_operand:DF 1 "general_operand" "fmG,f")))]
481   "TARGET_68881"
482   "*
483 {
484   cc_status.flags = CC_IN_68881;
485 #ifdef SGS_CMP_ORDER
486   if (REG_P (operands[0]))
487     {
488       if (REG_P (operands[1]))
489         return \"fcmp%.x %0,%1\";
490       else
491         return \"fcmp%.d %0,%f1\";
492     }
493   cc_status.flags |= CC_REVERSED;
494   return \"fcmp%.d %1,%f0\";
495 #else
496   if (REG_P (operands[0]))
497     {
498       if (REG_P (operands[1]))
499         return \"fcmp%.x %1,%0\";
500       else
501         return \"fcmp%.d %f1,%0\";
502     }
503   cc_status.flags |= CC_REVERSED;
504   return \"fcmp%.d %f0,%1\";
505 #endif
506 }")
507
508 (define_expand "cmpsf"
509  [(set (cc0)
510        (compare (match_operand:SF 0 "general_operand" "")
511                 (match_operand:SF 1 "general_operand" "")))]
512  "TARGET_68881"
513  "
514 {
515   m68k_last_compare_had_fp_operands = 1;
516 }")
517
518 (define_insn ""
519   [(set (cc0)
520         (compare (match_operand:SF 0 "general_operand" "f,mdG")
521                  (match_operand:SF 1 "general_operand" "fmdG,f")))]
522   "TARGET_68881"
523   "*
524 {
525   cc_status.flags = CC_IN_68881;
526 #ifdef SGS_CMP_ORDER
527   if (FP_REG_P (operands[0]))
528     {
529       if (FP_REG_P (operands[1]))
530         return \"fcmp%.x %0,%1\";
531       else
532         return \"fcmp%.s %0,%f1\";
533     }
534   cc_status.flags |= CC_REVERSED;
535   return \"fcmp%.s %1,%f0\";
536 #else
537   if (FP_REG_P (operands[0]))
538     {
539       if (FP_REG_P (operands[1]))
540         return \"fcmp%.x %1,%0\";
541       else
542         return \"fcmp%.s %f1,%0\";
543     }
544   cc_status.flags |= CC_REVERSED;
545   return \"fcmp%.s %f0,%1\";
546 #endif
547 }")
548 \f
549 ;; Recognizers for btst instructions.
550
551 ;; Coldfire/5200 only allows "<Q>" type addresses when the bit position is
552 ;; specified as a constant, so we must disable all patterns that may extract
553 ;; from a MEM at a constant bit position if we can't use this as a constraint.
554
555 (define_insn ""
556   [(set (cc0) (zero_extract (match_operand:QI 0 "memory_src_operand" "oS")
557                             (const_int 1)
558                             (minus:SI (const_int 7)
559                                       (match_operand:SI 1 "general_operand" "di"))))]
560   "!TARGET_COLDFIRE"
561   "* { return output_btst (operands, operands[1], operands[0], insn, 7); }")
562
563 ;; This is the same as the above pattern except for the constraints.  The 'i'
564 ;; has been deleted.
565
566 (define_insn ""
567   [(set (cc0) (zero_extract (match_operand:QI 0 "memory_operand" "o")
568                             (const_int 1)
569                             (minus:SI (const_int 7)
570                                       (match_operand:SI 1 "general_operand" "d"))))]
571   "TARGET_COLDFIRE"
572   "* { return output_btst (operands, operands[1], operands[0], insn, 7); }")
573
574 (define_insn ""
575   [(set (cc0) (zero_extract (match_operand:SI 0 "register_operand" "d")
576                             (const_int 1)
577                             (minus:SI (const_int 31)
578                                       (match_operand:SI 1 "general_operand" "di"))))]
579   ""
580   "* { return output_btst (operands, operands[1], operands[0], insn, 31); }")
581
582 ;; The following two patterns are like the previous two
583 ;; except that they use the fact that bit-number operands
584 ;; are automatically masked to 3 or 5 bits.
585
586 (define_insn ""
587   [(set (cc0) (zero_extract (match_operand:QI 0 "memory_operand" "o")
588                             (const_int 1)
589                             (minus:SI (const_int 7)
590                                       (and:SI
591                                        (match_operand:SI 1 "register_operand" "d")
592                                        (const_int 7)))))]
593   ""
594   "* { return output_btst (operands, operands[1], operands[0], insn, 7); }")
595
596 (define_insn ""
597   [(set (cc0) (zero_extract (match_operand:SI 0 "register_operand" "d")
598                             (const_int 1)
599                             (minus:SI (const_int 31)
600                                       (and:SI
601                                        (match_operand:SI 1 "register_operand" "d")
602                                        (const_int 31)))))]
603   ""
604   "* { return output_btst (operands, operands[1], operands[0], insn, 31); }")
605
606 ;; Nonoffsettable mem refs are ok in this one pattern
607 ;; since we don't try to adjust them.
608 (define_insn ""
609   [(set (cc0) (zero_extract (match_operand:QI 0 "memory_operand" "m")
610                             (const_int 1)
611                             (match_operand:SI 1 "const_int_operand" "n")))]
612   "(unsigned) INTVAL (operands[1]) < 8 && !TARGET_COLDFIRE"
613   "*
614 {
615   operands[1] = GEN_INT (7 - INTVAL (operands[1]));
616   return output_btst (operands, operands[1], operands[0], insn, 7);
617 }")
618
619 (define_insn ""
620   [(set (cc0) (zero_extract (match_operand:SI 0 "register_operand" "do")
621                             (const_int 1)
622                             (match_operand:SI 1 "const_int_operand" "n")))]
623   "!TARGET_COLDFIRE"
624   "*
625 {
626   if (GET_CODE (operands[0]) == MEM)
627     {
628       operands[0] = adjust_address (operands[0], QImode,
629                                     INTVAL (operands[1]) / 8);
630       operands[1] = GEN_INT (7 - INTVAL (operands[1]) % 8);
631       return output_btst (operands, operands[1], operands[0], insn, 7);
632     }
633   operands[1] = GEN_INT (31 - INTVAL (operands[1]));
634   return output_btst (operands, operands[1], operands[0], insn, 31);
635 }")
636
637 ;; This is the same as the above pattern except for the constraints.
638 ;; The 'o' has been replaced with 'Q'.
639
640 (define_insn ""
641   [(set (cc0) (zero_extract (match_operand:SI 0 "register_operand" "dQ")
642                             (const_int 1)
643                             (match_operand:SI 1 "const_int_operand" "n")))]
644   "TARGET_COLDFIRE"
645   "*
646 {
647   if (GET_CODE (operands[0]) == MEM)
648     {
649       operands[0] = adjust_address (operands[0], QImode,
650                                     INTVAL (operands[1]) / 8);
651       operands[1] = GEN_INT (7 - INTVAL (operands[1]) % 8);
652       return output_btst (operands, operands[1], operands[0], insn, 7);
653     }
654   operands[1] = GEN_INT (31 - INTVAL (operands[1]));
655   return output_btst (operands, operands[1], operands[0], insn, 31);
656 }")
657
658 \f
659 ;; move instructions
660
661 ;; A special case in which it is not desirable
662 ;; to reload the constant into a data register.
663 (define_insn "pushexthisi_const"
664   [(set (match_operand:SI 0 "push_operand" "=m")
665         (match_operand:SI 1 "const_int_operand" "J"))]
666   "INTVAL (operands[1]) >= -0x8000 && INTVAL (operands[1]) < 0x8000"
667   "*
668 {
669   if (operands[1] == const0_rtx)
670     return \"clr%.l %0\";
671   return \"pea %a1\";
672 }")
673
674 ;This is never used.
675 ;(define_insn "swapsi"
676 ;  [(set (match_operand:SI 0 "nonimmediate_operand" "+r")
677 ;       (match_operand:SI 1 "general_operand" "+r"))
678 ;   (set (match_dup 1) (match_dup 0))]
679 ;  ""
680 ;  "exg %1,%0")
681
682 ;; Special case of fullword move when source is zero.
683 ;; The reason this is special is to avoid loading a zero
684 ;; into a data reg with moveq in order to store it elsewhere.
685
686 (define_insn "movsi_const0"
687   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
688         (const_int 0))]
689   ;; clr insns on 68000 read before writing.
690   ;; This isn't so on the 68010, but we have no TARGET_68010.
691   "((TARGET_68020 || TARGET_COLDFIRE)
692     || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))"
693   "*
694 {
695   if (ADDRESS_REG_P (operands[0]))
696     {
697       /* On the '040, 'subl an,an' takes 2 clocks while lea takes only 1 */
698       if (!TARGET_68040 && !TARGET_68060)
699         return \"sub%.l %0,%0\";
700       else
701         {
702 #ifdef MOTOROLA
703 #ifdef SGS
704           /* Many SGS assemblers croak on size specifiers for constants.  */
705           return \"lea 0,%0\";
706 #else
707           return \"lea 0.w,%0\";
708 #endif
709 #else
710           return \"lea 0:w,%0\";
711 #endif
712         }
713     }
714   /* moveq is faster on the 68000.  */
715   if (DATA_REG_P (operands[0]) && (!TARGET_68020 && !TARGET_COLDFIRE))
716     return \"moveq %#0,%0\";
717   return \"clr%.l %0\";
718 }")
719
720 ;; General case of fullword move.
721 ;;
722 ;; This is the main "hook" for PIC code.  When generating
723 ;; PIC, movsi is responsible for determining when the source address
724 ;; needs PIC relocation and appropriately calling legitimize_pic_address
725 ;; to perform the actual relocation.
726 ;;
727 ;; In both the PIC and non-PIC cases the patterns generated will
728 ;; matched by the next define_insn.
729 (define_expand "movsi"
730   [(set (match_operand:SI 0 "nonimmediate_operand" "")
731         (match_operand:SI 1 "general_operand" ""))]
732   ""
733   "
734 {
735   if (flag_pic && !TARGET_PCREL && symbolic_operand (operands[1], SImode))
736     {
737       /* The source is an address which requires PIC relocation.
738          Call legitimize_pic_address with the source, mode, and a relocation
739          register (a new pseudo, or the final destination if reload_in_progress
740          is set).   Then fall through normally */
741       rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
742       operands[1] = legitimize_pic_address (operands[1], SImode, temp);
743     }
744   else if (flag_pic && TARGET_PCREL && ! reload_in_progress)
745     {
746       /* Don't allow writes to memory except via a register;
747          the m68k doesn't consider PC-relative addresses to be writable.  */
748       if (symbolic_operand (operands[0], SImode))
749         operands[0] = force_reg (SImode, XEXP (operands[0], 0));
750       else if (GET_CODE (operands[0]) == MEM
751                && symbolic_operand (XEXP (operands[0], 0), SImode))
752         operands[0] = gen_rtx (MEM, SImode,
753                                force_reg (SImode, XEXP (operands[0], 0)));
754     }
755 }")
756
757 ;; General case of fullword move.  The register constraints
758 ;; force integer constants in range for a moveq to be reloaded
759 ;; if they are headed for memory.
760 (define_insn ""
761   ;; Notes: make sure no alternative allows g vs g.
762   ;; We don't allow f-regs since fixed point cannot go in them.
763   [(set (match_operand:SI 0 "nonimmediate_operand" "=g,d,a<")
764         (match_operand:SI 1 "general_src_operand" "daymSKT,n,i"))]
765
766   "!TARGET_COLDFIRE"
767   "*
768 {
769   return output_move_simode (operands);
770 }")
771
772 (define_insn ""
773   [(set (match_operand:SI 0 "nonimmediate_operand" "=r<Q>,g")
774         (match_operand:SI 1 "general_operand" "g,r<Q>"))]
775   "TARGET_COLDFIRE"
776   "* return output_move_simode (operands);")
777
778 ;; Special case of fullword move, where we need to get a non-GOT PIC
779 ;; reference into an address register.
780 (define_insn ""
781   [(set (match_operand:SI 0 "nonimmediate_operand" "=a<")
782         (match_operand:SI 1 "pcrel_address" ""))]
783   "TARGET_PCREL"
784   "*
785 {
786   if (push_operand (operands[0], SImode))
787     return \"pea %a1\";
788   return \"lea %a1,%0\";
789 }")
790
791 (define_expand "movhi"
792   [(set (match_operand:HI 0 "nonimmediate_operand" "")
793         (match_operand:HI 1 "general_operand" ""))]
794   ""
795   "")
796
797 (define_insn ""
798   [(set (match_operand:HI 0 "nonimmediate_operand" "=g")
799         (match_operand:HI 1 "general_src_operand" "gS"))]
800   "!TARGET_COLDFIRE"
801   "* return output_move_himode (operands);")
802
803  (define_insn ""
804   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<Q>,g")
805         (match_operand:HI 1 "general_operand" "g,r<Q>"))]
806   "TARGET_COLDFIRE"
807   "* return output_move_himode (operands);")
808
809 (define_expand "movstricthi"
810   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
811         (match_operand:HI 1 "general_src_operand" ""))]
812   ""
813   "")
814
815 (define_insn ""
816   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
817         (match_operand:HI 1 "general_src_operand" "rmSn"))]
818   "!TARGET_COLDFIRE"
819   "* return output_move_stricthi (operands);")
820
821 (define_insn ""
822   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+d,m"))
823         (match_operand:HI 1 "general_src_operand" "rmn,r"))]
824   "TARGET_COLDFIRE"
825   "* return output_move_stricthi (operands);")
826
827 (define_expand "movqi"
828   [(set (match_operand:QI 0 "nonimmediate_operand" "")
829         (match_operand:QI 1 "general_src_operand" ""))]
830   ""
831   "")
832
833 (define_insn ""
834   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,*a,m")
835         (match_operand:QI 1 "general_src_operand" "dmSi*a,di*a,dmSi"))]
836   "!TARGET_COLDFIRE"
837   "* return output_move_qimode (operands);")
838
839 (define_insn ""
840   [(set (match_operand:QI 0 "nonimmediate_operand" "=d<Q>,dm,d*a")
841         (match_operand:QI 1 "general_src_operand" "dmi,d<Q>,di*a"))]
842   "TARGET_COLDFIRE"
843   "* return output_move_qimode (operands);")
844
845 (define_expand "movstrictqi"
846   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
847         (match_operand:QI 1 "general_src_operand" ""))]
848   ""
849   "")
850
851 (define_insn ""
852   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
853         (match_operand:QI 1 "general_src_operand" "dmSn"))]
854   "!TARGET_COLDFIRE"
855   "* return output_move_strictqi (operands);")
856
857 (define_insn ""
858   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+d,m"))
859         (match_operand:QI 1 "general_src_operand" "dmn,d"))]
860   "TARGET_COLDFIRE"
861   "* return output_move_strictqi (operands);")
862
863 (define_expand "pushqi1"
864   [(set (reg:SI 15) (plus:SI (reg:SI 15) (const_int -2)))
865    (set (mem:QI (plus:SI (reg:SI 15) (const_int 1)))
866         (match_operand:QI 0 "general_operand" ""))]
867   "!TARGET_COLDFIRE"
868   "")
869
870 (define_expand "movsf"
871   [(set (match_operand:SF 0 "nonimmediate_operand" "")
872         (match_operand:SF 1 "general_operand" ""))]
873   ""
874   "")
875
876 (define_insn ""
877   [(set (match_operand:SF 0 "nonimmediate_operand" "=rmf")
878         (match_operand:SF 1 "general_operand" "rmfF"))]
879   "!TARGET_COLDFIRE"
880   "*
881 {
882   if (FP_REG_P (operands[0]))
883     {
884       if (FP_REG_P (operands[1]))
885         return \"f%$move%.x %1,%0\";
886       else if (ADDRESS_REG_P (operands[1]))
887         return \"move%.l %1,%-\;f%$move%.s %+,%0\";
888       else if (GET_CODE (operands[1]) == CONST_DOUBLE)
889         return output_move_const_single (operands);
890       return \"f%$move%.s %f1,%0\";
891     }
892   if (FP_REG_P (operands[1]))
893     {
894       if (ADDRESS_REG_P (operands[0]))
895         return \"fmove%.s %1,%-\;move%.l %+,%0\";
896       return \"fmove%.s %f1,%0\";
897     }
898   if (operands[1] == CONST0_RTX (SFmode)
899       /* clr insns on 68000 read before writing.
900          This isn't so on the 68010, but we have no TARGET_68010.  */
901       && ((TARGET_68020 || TARGET_COLDFIRE)
902           || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))))
903     {
904       if (ADDRESS_REG_P (operands[0]))
905         {
906           /* On the '040, 'subl an,an' takes 2 clocks while lea takes only 1 */
907           if (!TARGET_68040 && !TARGET_68060)
908             return \"sub%.l %0,%0\";
909           else
910             {
911 #ifdef MOTOROLA
912 #ifdef SGS
913               /* Many SGS assemblers croak on size specifiers for constants.  */
914               return \"lea 0,%0\";
915 #else
916               return \"lea 0.w,%0\";
917 #endif
918 #else
919               return \"lea 0:w,%0\";
920 #endif
921             }
922         }
923       /* moveq is faster on the 68000.  */
924       if (DATA_REG_P (operands[0]) && !(TARGET_68020 || TARGET_COLDFIRE))
925         {
926           return \"moveq %#0,%0\";
927         }
928       return \"clr%.l %0\";
929     }
930   return \"move%.l %1,%0\";
931 }")
932
933 (define_insn ""
934   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,g")
935         (match_operand:SF 1 "general_operand" "g,r"))]
936   "TARGET_COLDFIRE"
937   "* return \"move%.l %1,%0\";")
938
939 (define_expand "movdf"
940   [(set (match_operand:DF 0 "nonimmediate_operand" "")
941         (match_operand:DF 1 "general_operand" ""))]
942   ""
943   "")
944
945 (define_insn ""
946   [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,rf,rf,&rof<>")
947         (match_operand:DF 1 "general_operand" "*rf,m,0,*rofE<>"))]
948 ;  [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,&rf,&rof<>")
949 ;       (match_operand:DF 1 "general_operand" "rf,m,rofF<>"))]
950   "!TARGET_COLDFIRE"
951   "*
952 {
953   if (FP_REG_P (operands[0]))
954     {
955       if (FP_REG_P (operands[1]))
956         return \"f%&move%.x %1,%0\";
957       if (REG_P (operands[1]))
958         {
959           rtx xoperands[2];
960           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
961           output_asm_insn (\"move%.l %1,%-\", xoperands);
962           output_asm_insn (\"move%.l %1,%-\", operands);
963           return \"f%&move%.d %+,%0\";
964         }
965       if (GET_CODE (operands[1]) == CONST_DOUBLE)
966         return output_move_const_double (operands);
967       return \"f%&move%.d %f1,%0\";
968     }
969   else if (FP_REG_P (operands[1]))
970     {
971       if (REG_P (operands[0]))
972         {
973           output_asm_insn (\"fmove%.d %f1,%-\;move%.l %+,%0\", operands);
974           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
975           return \"move%.l %+,%0\";
976         }
977       else
978         return \"fmove%.d %f1,%0\";
979     }
980   return output_move_double (operands);
981 }")
982
983 (define_insn ""
984   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,g")
985         (match_operand:DF 1 "general_operand" "g,r"))]
986   "TARGET_COLDFIRE"
987   "* return output_move_double (operands);")
988
989 ;; ??? The XFmode patterns are schizophrenic about whether constants are
990 ;; allowed.  Most but not all have predicates and constraint that disallow
991 ;; constants.  Most but not all have output templates that handle constants.
992 ;; See also LEGITIMATE_CONSTANT_P.
993
994 (define_expand "movxf"
995   [(set (match_operand:XF 0 "nonimmediate_operand" "")
996         (match_operand:XF 1 "general_operand" ""))]
997   ""
998   "
999 {
1000   /* We can't rewrite operands during reload.  */
1001   if (! reload_in_progress)
1002     {
1003       if (CONSTANT_P (operands[1]))
1004         {
1005           operands[1] = force_const_mem (XFmode, operands[1]);
1006           if (! memory_address_p (XFmode, XEXP (operands[1], 0)))
1007             operands[1] = adjust_address (operands[1], XFmode, 0);
1008         }
1009       if (flag_pic && TARGET_PCREL)
1010         {
1011           /* Don't allow writes to memory except via a register; the
1012              m68k doesn't consider PC-relative addresses to be writable.  */
1013           if (GET_CODE (operands[0]) == MEM
1014               && symbolic_operand (XEXP (operands[0], 0), SImode))
1015             operands[0] = gen_rtx (MEM, XFmode,
1016                                    force_reg (SImode, XEXP (operands[0], 0)));
1017         }
1018     }
1019 }")
1020
1021 (define_insn ""
1022   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,!r,!f,!r")
1023         (match_operand:XF 1 "nonimmediate_operand" "m,f,f,f,r,!r"))]
1024   "TARGET_68881"
1025   "*
1026 {
1027   if (FP_REG_P (operands[0]))
1028     {
1029       if (FP_REG_P (operands[1]))
1030         return \"fmove%.x %1,%0\";
1031       if (REG_P (operands[1]))
1032         {
1033           rtx xoperands[2];
1034           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1035           output_asm_insn (\"move%.l %1,%-\", xoperands);
1036           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1037           output_asm_insn (\"move%.l %1,%-\", xoperands);
1038           output_asm_insn (\"move%.l %1,%-\", operands);
1039           return \"fmove%.x %+,%0\";
1040         }
1041       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1042         return \"fmove%.x %1,%0\";
1043       return \"fmove%.x %f1,%0\";
1044     }
1045   if (FP_REG_P (operands[1]))
1046     {
1047       if (REG_P (operands[0]))
1048         {
1049           output_asm_insn (\"fmove%.x %f1,%-\;move%.l %+,%0\", operands);
1050           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1051           output_asm_insn (\"move%.l %+,%0\", operands);
1052           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1053           return \"move%.l %+,%0\";
1054         }
1055       /* Must be memory destination.  */
1056       return \"fmove%.x %f1,%0\";
1057     }
1058   return output_move_double (operands);
1059 }
1060 ")
1061
1062 (define_insn ""
1063   [(set (match_operand:XF 0 "nonimmediate_operand" "=rm,rf,&rof<>")
1064         (match_operand:XF 1 "nonimmediate_operand" "rf,m,rof<>"))]
1065   "! TARGET_68881 && ! TARGET_COLDFIRE"
1066   "*
1067 {
1068   if (FP_REG_P (operands[0]))
1069     {
1070       if (FP_REG_P (operands[1]))
1071         return \"fmove%.x %1,%0\";
1072       if (REG_P (operands[1]))
1073         {
1074           rtx xoperands[2];
1075           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1076           output_asm_insn (\"move%.l %1,%-\", xoperands);
1077           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1078           output_asm_insn (\"move%.l %1,%-\", xoperands);
1079           output_asm_insn (\"move%.l %1,%-\", operands);
1080           return \"fmove%.x %+,%0\";
1081         }
1082       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1083         return \"fmove%.x %1,%0\";
1084       return \"fmove%.x %f1,%0\";
1085     }
1086   if (FP_REG_P (operands[1]))
1087     {
1088       if (REG_P (operands[0]))
1089         {
1090           output_asm_insn (\"fmove%.x %f1,%-\;move%.l %+,%0\", operands);
1091           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1092           output_asm_insn (\"move%.l %+,%0\", operands);
1093           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1094           return \"move%.l %+,%0\";
1095         }
1096       else
1097         return \"fmove%.x %f1,%0\";
1098     }
1099   return output_move_double (operands);
1100 }
1101 ")
1102
1103 (define_insn ""
1104   [(set (match_operand:XF 0 "nonimmediate_operand" "=r,g")
1105         (match_operand:XF 1 "nonimmediate_operand" "g,r"))]
1106   "! TARGET_68881 && TARGET_COLDFIRE"
1107   "* return output_move_double (operands);")
1108
1109 (define_expand "movdi"
1110   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1111   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1112         (match_operand:DI 1 "general_operand" ""))]
1113   ""
1114   "")
1115
1116 ;; movdi can apply to fp regs in some cases
1117 (define_insn ""
1118   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1119   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,r,&ro<>")
1120         (match_operand:DI 1 "general_operand" "rF,m,roi<>F"))]
1121 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&r,&ro<>,!&rm,!&f")
1122 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF"))]
1123 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&rf,&ro<>,!&rm,!&f")
1124 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF,rfF"))]
1125   "!TARGET_COLDFIRE"
1126   "*
1127 {
1128   if (FP_REG_P (operands[0]))
1129     {
1130       if (FP_REG_P (operands[1]))
1131         return \"fmove%.x %1,%0\";
1132       if (REG_P (operands[1]))
1133         {
1134           rtx xoperands[2];
1135           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1136           output_asm_insn (\"move%.l %1,%-\", xoperands);
1137           output_asm_insn (\"move%.l %1,%-\", operands);
1138           return \"fmove%.d %+,%0\";
1139         }
1140       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1141         return output_move_const_double (operands);
1142       return \"fmove%.d %f1,%0\";
1143     }
1144   else if (FP_REG_P (operands[1]))
1145     {
1146       if (REG_P (operands[0]))
1147         {
1148           output_asm_insn (\"fmove%.d %f1,%-\;move%.l %+,%0\", operands);
1149           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1150           return \"move%.l %+,%0\";
1151         }
1152       else
1153         return \"fmove%.d %f1,%0\";
1154     }
1155   return output_move_double (operands);
1156 }")
1157
1158 (define_insn ""
1159   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,g")
1160         (match_operand:DI 1 "general_operand" "g,r"))]
1161   "TARGET_COLDFIRE"
1162   "* return output_move_double (operands);")
1163
1164 ;; Thus goes after the move instructions
1165 ;; because the move instructions are better (require no spilling)
1166 ;; when they can apply.  It goes before the add/sub insns
1167 ;; so we will prefer it to them.
1168
1169 (define_insn "pushasi"
1170   [(set (match_operand:SI 0 "push_operand" "=m")
1171         (match_operand:SI 1 "address_operand" "p"))]
1172   ""
1173   "pea %a1")
1174 \f
1175 ;; truncation instructions
1176 (define_insn "truncsiqi2"
1177   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1178         (truncate:QI
1179          (match_operand:SI 1 "general_src_operand" "doJS,i")))]
1180   ""
1181   "*
1182 {
1183   if (GET_CODE (operands[0]) == REG)
1184     {
1185       /* Must clear condition codes, since the move.l bases them on
1186          the entire 32 bits, not just the desired 8 bits.  */
1187       CC_STATUS_INIT;
1188       return \"move%.l %1,%0\";
1189     }
1190   if (GET_CODE (operands[1]) == MEM)
1191     operands[1] = adjust_address (operands[1], QImode, 3);
1192   return \"move%.b %1,%0\";
1193 }")
1194
1195 (define_insn "trunchiqi2"
1196   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1197         (truncate:QI
1198          (match_operand:HI 1 "general_src_operand" "doJS,i")))]
1199   ""
1200   "*
1201 {
1202   if (GET_CODE (operands[0]) == REG
1203       && (GET_CODE (operands[1]) == MEM
1204           || GET_CODE (operands[1]) == CONST_INT))
1205     {
1206       /* Must clear condition codes, since the move.w bases them on
1207          the entire 16 bits, not just the desired 8 bits.  */
1208       CC_STATUS_INIT;
1209       return \"move%.w %1,%0\";
1210     }
1211   if (GET_CODE (operands[0]) == REG)
1212     {
1213       /* Must clear condition codes, since the move.l bases them on
1214          the entire 32 bits, not just the desired 8 bits.  */
1215       CC_STATUS_INIT;
1216       return \"move%.l %1,%0\";
1217     }
1218   if (GET_CODE (operands[1]) == MEM)
1219     operands[1] = adjust_address (operands[1], QImode, 1);
1220   return \"move%.b %1,%0\";
1221 }")
1222
1223 (define_insn "truncsihi2"
1224   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm,d")
1225         (truncate:HI
1226          (match_operand:SI 1 "general_src_operand" "roJS,i")))]
1227   ""
1228   "*
1229 {
1230   if (GET_CODE (operands[0]) == REG)
1231     {
1232       /* Must clear condition codes, since the move.l bases them on
1233          the entire 32 bits, not just the desired 8 bits.  */
1234       CC_STATUS_INIT;
1235       return \"move%.l %1,%0\";
1236     }
1237   if (GET_CODE (operands[1]) == MEM)
1238     operands[1] = adjust_address (operands[1], QImode, 2);
1239   return \"move%.w %1,%0\";
1240 }")
1241 \f
1242 ;; zero extension instructions
1243
1244 (define_insn "zero_extendqidi2"
1245   [(set (match_operand:DI 0 "nonimmediate_operand" "=&d")
1246         (zero_extend:DI (match_operand:QI 1 "general_operand" "dm")))]
1247   ""
1248   "*
1249 {
1250   CC_STATUS_INIT;
1251   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1252   return \"moveq %#0,%0\;moveq %#0,%2\;move%.b %1,%2\";
1253 }")
1254
1255 (define_insn "zero_extendhidi2"
1256   [(set (match_operand:DI 0 "nonimmediate_operand" "=&d")
1257         (zero_extend:DI (match_operand:HI 1 "general_operand" "rm")))]
1258   ""
1259   "*
1260 {
1261   CC_STATUS_INIT;
1262   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1263   return \"moveq %#0,%0\;moveq %#0,%2\;move%.w %1,%2\";
1264 }")
1265
1266 ;; this is the canonical form for (lshiftrt:DI x 32)
1267 (define_expand "zero_extendsidi2"
1268   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1269     (zero_extend:DI (match_operand:SI 1 "general_operand" "")))]
1270   ""
1271   "")
1272
1273 (define_insn "*zero_extendsidi2_cf"
1274   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,m")
1275     (zero_extend:DI (match_operand:SI 1 "general_operand" "rm,r")))]
1276   "TARGET_COLDFIRE"
1277   "*
1278 {
1279   CC_STATUS_INIT;
1280   if (GET_CODE (operands[0]) == REG)
1281     operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1282   else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1283     return \"move%.l %1,%0\;clr%.l %0\";
1284   else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1285     return \"clr%.l %0\;move%.l %1,%0\";
1286   else
1287     operands[2] = adjust_address (operands[0], SImode, 4);
1288   if (GET_CODE (operands[1]) != REG || GET_CODE (operands[2]) != REG
1289       || REGNO (operands[1]) != REGNO (operands[2]))
1290     output_asm_insn (\"move%.l %1,%2\", operands);
1291   if (ADDRESS_REG_P (operands[0]))
1292     return \"sub%.l %0,%0\";
1293   else
1294     return \"clr%.l %0\";
1295 }")
1296
1297 (define_insn "*zero_extendsidi2"
1298   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm")
1299     (zero_extend:DI (match_operand:SI 1 "general_operand" "rm")))]
1300   "!TARGET_COLDFIRE"
1301   "*
1302 {
1303   CC_STATUS_INIT;
1304   if (GET_CODE (operands[0]) == REG)
1305     operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1306   else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1307     return \"move%.l %1,%0\;clr%.l %0\";
1308   else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1309     return \"clr%.l %0\;move%.l %1,%0\";
1310   else
1311     operands[2] = adjust_address (operands[0], SImode, 4);
1312   if (GET_CODE (operands[1]) != REG || GET_CODE (operands[2]) != REG
1313       || REGNO (operands[1]) != REGNO (operands[2]))
1314     output_asm_insn (\"move%.l %1,%2\", operands);
1315   if (ADDRESS_REG_P (operands[0]))
1316     return \"sub%.l %0,%0\";
1317   else
1318     return \"clr%.l %0\";
1319 }")
1320
1321 (define_expand "zero_extendhisi2"
1322   [(set (match_operand:SI 0 "register_operand" "")
1323         (const_int 0))
1324    (set (strict_low_part (match_dup 2))
1325         (match_operand:HI 1 "general_operand" ""))]
1326   ""
1327   "
1328 {
1329   operands[1] = make_safe_from (operands[1], operands[0]);
1330   operands[2] = gen_lowpart_SUBREG (HImode, operands[0]);
1331 }")
1332
1333 (define_expand "zero_extendqihi2"
1334   [(set (match_operand:HI 0 "register_operand" "")
1335         (const_int 0))
1336    (set (strict_low_part (match_dup 2))
1337         (match_operand:QI 1 "general_operand" ""))]
1338   ""
1339   "
1340 {
1341   operands[1] = make_safe_from (operands[1], operands[0]);
1342   operands[2] = gen_lowpart_SUBREG (QImode, operands[0]);
1343 }")
1344
1345 (define_expand "zero_extendqisi2"
1346   [(set (match_operand:SI 0 "register_operand" "")
1347         (const_int 0))
1348    (set (strict_low_part (match_dup 2))
1349         (match_operand:QI 1 "general_operand" ""))]
1350   ""
1351   "
1352 {
1353   operands[1] = make_safe_from (operands[1], operands[0]);
1354   operands[2] = gen_lowpart_SUBREG (QImode, operands[0]);
1355 }")
1356 \f
1357 ;; Patterns to recognize zero-extend insns produced by the combiner.
1358 ;; We don't allow both operands in memory, because of aliasing problems.
1359 ;; Explicitly disallow two memory operands via the condition since reloading
1360 ;; of this case will result in worse code than the uncombined patterns.
1361
1362 (define_insn ""
1363   [(set (match_operand:SI 0 "nonimmediate_operand" "=do<>,d<")
1364         (zero_extend:SI (match_operand:HI 1 "nonimmediate_src_operand" "r,mS")))]
1365   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
1366   "*
1367 {
1368   if (DATA_REG_P (operands[0]))
1369     {
1370       if (GET_CODE (operands[1]) == REG
1371           && REGNO (operands[0]) == REGNO (operands[1]))
1372         return \"and%.l %#0xFFFF,%0\";
1373       if (reg_mentioned_p (operands[0], operands[1]))
1374         return \"move%.w %1,%0\;and%.l %#0xFFFF,%0\";
1375       return \"clr%.l %0\;move%.w %1,%0\";
1376     }
1377   else if (GET_CODE (operands[0]) == MEM
1378            && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1379     return \"move%.w %1,%0\;clr%.w %0\";
1380   else if (GET_CODE (operands[0]) == MEM
1381            && GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1382     return \"clr%.w %0\;move%.w %1,%0\";
1383   else
1384     {
1385       output_asm_insn (\"clr%.w %0\", operands);
1386       operands[0] = adjust_address (operands[0], HImode, 2);
1387       return \"move%.w %1,%0\";
1388     }
1389 }")
1390
1391 (define_insn ""
1392   [(set (match_operand:HI 0 "nonimmediate_operand" "=do<>,d")
1393         (zero_extend:HI (match_operand:QI 1 "nonimmediate_src_operand" "d,mS")))]
1394   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
1395   "*
1396 {
1397   if (DATA_REG_P (operands[0]))
1398     {
1399       if (GET_CODE (operands[1]) == REG
1400           && REGNO (operands[0]) == REGNO (operands[1]))
1401         return (!TARGET_COLDFIRE ? \"and%.w %#0xFF,%0\" : \"and%.l %#0xFF,%0\");
1402       if (reg_mentioned_p (operands[0], operands[1]))
1403         return (!TARGET_COLDFIRE ? \"move%.b %1,%0\;and%.w %#0xFF,%0\" 
1404                              : \"move%.b %1,%0\;and%.l %#0xFF,%0\");
1405       return \"clr%.w %0\;move%.b %1,%0\";
1406     }
1407   else if (GET_CODE (operands[0]) == MEM
1408            && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1409     {
1410       if (REGNO (XEXP (XEXP (operands[0], 0), 0))
1411           == STACK_POINTER_REGNUM)
1412         {
1413           output_asm_insn (\"clr%.w %-\", operands);
1414           operands[0] = gen_rtx_MEM (GET_MODE (operands[0]),
1415                                      plus_constant (stack_pointer_rtx, 1));
1416           return \"move%.b %1,%0\";
1417         }
1418       else
1419         return \"move%.b %1,%0\;clr%.b %0\";
1420     }
1421   else if (GET_CODE (operands[0]) == MEM
1422            && GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1423     return \"clr%.b %0\;move%.b %1,%0\";
1424   else
1425     {
1426       output_asm_insn (\"clr%.b %0\", operands);
1427       operands[0] = adjust_address (operands[0], QImode, 1);
1428       return \"move%.b %1,%0\";
1429     }
1430 }")
1431
1432 (define_insn ""
1433   [(set (match_operand:SI 0 "nonimmediate_operand" "=do<>,d")
1434         (zero_extend:SI (match_operand:QI 1 "nonimmediate_src_operand" "d,mS")))]
1435   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
1436   "*
1437 {
1438   if (DATA_REG_P (operands[0]))
1439     {
1440       if (GET_CODE (operands[1]) == REG
1441           && REGNO (operands[0]) == REGNO (operands[1]))
1442         return \"and%.l %#0xFF,%0\";
1443       if (reg_mentioned_p (operands[0], operands[1]))
1444         return \"move%.b %1,%0\;and%.l %#0xFF,%0\";
1445       return \"clr%.l %0\;move%.b %1,%0\";
1446     }
1447   else if (GET_CODE (operands[0]) == MEM
1448            && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1449     {
1450       operands[0] = XEXP (XEXP (operands[0], 0), 0);
1451 #ifdef MOTOROLA
1452 #ifdef SGS
1453       return \"clr%.l -(%0)\;move%.b %1,3(%0)\";
1454 #else
1455       return \"clr%.l -(%0)\;move%.b %1,(3,%0)\";
1456 #endif
1457 #else
1458       return \"clrl %0@-\;moveb %1,%0@(3)\";
1459 #endif
1460     }
1461   else if (GET_CODE (operands[0]) == MEM
1462            && GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1463     {
1464       operands[0] = XEXP (XEXP (operands[0], 0), 0);
1465 #ifdef MOTOROLA
1466 #ifdef SGS
1467       return \"clr%.l (%0)+\;move%.b %1,-1(%0)\";
1468 #else
1469       return \"clr%.l (%0)+\;move%.b %1,(-1,%0)\";
1470 #endif
1471 #else
1472       return \"clrl %0@+\;moveb %1,%0@(-1)\";
1473 #endif
1474     }
1475   else
1476     {
1477       output_asm_insn (\"clr%.l %0\", operands);
1478       operands[0] = adjust_address (operands[0], QImode, 3);
1479       return \"move%.b %1,%0\";
1480     }
1481 }")
1482 \f
1483 ;; sign extension instructions
1484
1485 (define_insn "extendqidi2"
1486   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1487         (sign_extend:DI (match_operand:QI 1 "general_src_operand" "rmS")))]
1488   ""
1489   "*
1490 {
1491   CC_STATUS_INIT;
1492   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1493   if (TARGET_68020 || TARGET_COLDFIRE)
1494     return \"move%.b %1,%2\;extb%.l %2\;smi %0\;extb%.l %0\";
1495   else
1496     return \"move%.b %1,%2\;ext%.w %0\;ext%.l %2\;move%.l %2,%0\;smi %0\";
1497 }")
1498
1499 (define_insn "extendhidi2"
1500   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1501         (sign_extend:DI
1502          (match_operand:HI 1 "general_src_operand" "rmS")))]
1503   ""
1504   "*
1505 {
1506   CC_STATUS_INIT;
1507   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1508   if (TARGET_68020 || TARGET_COLDFIRE)
1509     return \"move%.w %1,%2\;ext%.l %2\;smi %0\;extb%.l %0\";
1510   else
1511     return \"move%.w %1,%2\;ext%.l %2\;smi %0\;ext%.w %0\;ext%.l %0\";
1512 }")
1513
1514 (define_insn "extendsidi2"
1515   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1516         (sign_extend:DI
1517          (match_operand:SI 1 "general_operand" "rm")))]
1518   ""
1519   "*
1520 {
1521   CC_STATUS_INIT;
1522   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1523   if (TARGET_68020 || TARGET_COLDFIRE)
1524     return \"move%.l %1,%2\;smi %0\;extb%.l %0\";
1525   else
1526     return \"move%.l %1,%2\;smi %0\;ext%.w %0\;ext%.l %0\";
1527 }")
1528
1529 ;; Special case when one can avoid register clobbering, copy and test
1530 ;; Maybe there is a way to make that the general case, by forcing the
1531 ;; result of the SI tree to be in the lower register of the DI target
1532
1533 (define_insn "extendplussidi"
1534   [(set (match_operand:DI 0 "register_operand" "=d")
1535     (sign_extend:DI (plus:SI (match_operand:SI 1 "general_operand" "%rmn")
1536             (match_operand:SI 2 "general_operand" "rmn"))))]
1537   ""
1538   "*
1539 {
1540   CC_STATUS_INIT;
1541   operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1542   if (GET_CODE (operands[1]) == CONST_INT
1543   && (unsigned) INTVAL (operands[1]) > 8)
1544     {
1545       rtx tmp = operands[1];
1546
1547       operands[1] = operands[2];
1548       operands[2] = tmp;
1549     }
1550   if (GET_CODE (operands[1]) == REG
1551       && REGNO (operands[1]) == REGNO (operands[3]))
1552     output_asm_insn (\"add%.l %2,%3\", operands);
1553   else
1554     output_asm_insn (\"move%.l %2,%3\;add%.l %1,%3\", operands);
1555   if (TARGET_68020 || TARGET_COLDFIRE)
1556     return \"smi %0\;extb%.l %0\";
1557   else
1558     return \"smi %0\;ext%.w %0\;ext%.l %0\";
1559 }")
1560
1561 (define_insn "extendhisi2"
1562   [(set (match_operand:SI 0 "nonimmediate_operand" "=*d,a")
1563         (sign_extend:SI
1564          (match_operand:HI 1 "nonimmediate_src_operand" "0,rmS")))]
1565   ""
1566   "*
1567 {
1568   if (ADDRESS_REG_P (operands[0]))
1569     return \"move%.w %1,%0\";
1570   return \"ext%.l %0\";
1571 }")
1572
1573 (define_insn "extendqihi2"
1574   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
1575         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "0")))]
1576   ""
1577   "ext%.w %0")
1578
1579 (define_insn "extendqisi2"
1580   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
1581         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "0")))]
1582   "TARGET_68020 || TARGET_COLDFIRE"
1583   "extb%.l %0")
1584 \f
1585 ;; Conversions between float and double.
1586
1587 (define_expand "extendsfdf2"
1588   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1589         (float_extend:DF
1590          (match_operand:SF 1 "general_operand" "")))]
1591   "TARGET_68881"
1592   "")
1593
1594 (define_insn ""
1595   [(set (match_operand:DF 0 "nonimmediate_operand" "=*fdm,f")
1596         (float_extend:DF
1597           (match_operand:SF 1 "general_operand" "f,dmF")))]
1598   "TARGET_68881"
1599   "*
1600 {
1601   if (FP_REG_P (operands[0]) && FP_REG_P (operands[1]))
1602     {
1603       if (REGNO (operands[0]) == REGNO (operands[1]))
1604         {
1605           /* Extending float to double in an fp-reg is a no-op.
1606              NOTICE_UPDATE_CC has already assumed that the
1607              cc will be set.  So cancel what it did.  */
1608           cc_status = cc_prev_status;
1609           return \"\";
1610         }
1611       return \"f%&move%.x %1,%0\";
1612     }
1613   if (FP_REG_P (operands[0]))
1614     return \"f%&move%.s %f1,%0\";
1615   if (DATA_REG_P (operands[0]) && FP_REG_P (operands[1]))
1616     {
1617       output_asm_insn (\"fmove%.d %f1,%-\;move%.l %+,%0\", operands);
1618       operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1619       return \"move%.l %+,%0\";
1620     }
1621   return \"fmove%.d %f1,%0\";
1622 }")
1623
1624 ;; This cannot output into an f-reg because there is no way to be
1625 ;; sure of truncating in that case.
1626 (define_expand "truncdfsf2"
1627   [(set (match_operand:SF 0 "nonimmediate_operand" "")
1628         (float_truncate:SF
1629           (match_operand:DF 1 "general_operand" "")))]
1630   "TARGET_68881"
1631   "")
1632
1633 ;; On the '040 we can truncate in a register accurately and easily.
1634 (define_insn ""
1635   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1636         (float_truncate:SF
1637           (match_operand:DF 1 "general_operand" "fmG")))]
1638   "TARGET_68040_ONLY"
1639   "*
1640 {
1641   if (FP_REG_P (operands[1]))
1642     return \"f%$move%.x %1,%0\";
1643   return \"f%$move%.d %f1,%0\";
1644 }")
1645
1646 (define_insn ""
1647   [(set (match_operand:SF 0 "nonimmediate_operand" "=dm")
1648         (float_truncate:SF
1649           (match_operand:DF 1 "general_operand" "f")))]
1650   "TARGET_68881"
1651   "fmove%.s %f1,%0")
1652 \f
1653 ;; Conversion between fixed point and floating point.
1654 ;; Note that among the fix-to-float insns
1655 ;; the ones that start with SImode come first.
1656 ;; That is so that an operand that is a CONST_INT
1657 ;; (and therefore lacks a specific machine mode).
1658 ;; will be recognized as SImode (which is always valid)
1659 ;; rather than as QImode or HImode.
1660
1661 (define_expand "floatsisf2"
1662   [(set (match_operand:SF 0 "nonimmediate_operand" "")
1663         (float:SF (match_operand:SI 1 "general_operand" "")))]
1664   "TARGET_68881"
1665   "")
1666
1667 (define_insn ""
1668   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1669         (float:SF (match_operand:SI 1 "general_operand" "dmi")))]
1670   "TARGET_68881"
1671   "f%$move%.l %1,%0")
1672
1673 (define_expand "floatsidf2"
1674   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1675         (float:DF (match_operand:SI 1 "general_operand" "")))]
1676   "TARGET_68881"
1677   "")
1678
1679 (define_insn ""
1680   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
1681         (float:DF (match_operand:SI 1 "general_operand" "dmi")))]
1682   "TARGET_68881"
1683   "f%&move%.l %1,%0")
1684
1685 (define_insn "floathisf2"
1686   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1687         (float:SF (match_operand:HI 1 "general_operand" "dmn")))]
1688   "TARGET_68881"
1689   "f%$move%.w %1,%0")
1690
1691 (define_insn "floathidf2"
1692   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
1693         (float:DF (match_operand:HI 1 "general_operand" "dmn")))]
1694   "TARGET_68881"
1695   "fmove%.w %1,%0")
1696
1697 (define_insn "floatqisf2"
1698   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1699         (float:SF (match_operand:QI 1 "general_operand" "dmn")))]
1700   "TARGET_68881"
1701   "fmove%.b %1,%0")
1702
1703 (define_insn "floatqidf2"
1704   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
1705         (float:DF (match_operand:QI 1 "general_operand" "dmn")))]
1706   "TARGET_68881"
1707   "f%&move%.b %1,%0")
1708
1709 ;; New routines to convert floating-point values to integers
1710 ;; to be used on the '040.  These should be faster than trapping
1711 ;; into the kernel to emulate fintrz.  They should also be faster
1712 ;; than calling the subroutines fixsfsi or fixdfsi.
1713
1714 (define_insn "fix_truncdfsi2"
1715   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
1716         (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
1717    (clobber (match_scratch:SI 2 "=d"))
1718    (clobber (match_scratch:SI 3 "=d"))]
1719   "TARGET_68881 && TARGET_68040"
1720   "*
1721 {
1722   CC_STATUS_INIT;
1723   return \"fmovem%.l %!,%2\;moveq %#16,%3\;or%.l %2,%3\;and%.w %#-33,%3\;fmovem%.l %3,%!\;fmove%.l %1,%0\;fmovem%.l %2,%!\";
1724 }")
1725
1726 (define_insn "fix_truncdfhi2"
1727   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
1728         (fix:HI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
1729    (clobber (match_scratch:SI 2 "=d"))
1730    (clobber (match_scratch:SI 3 "=d"))]
1731   "TARGET_68881 && TARGET_68040"
1732   "*
1733 {
1734   CC_STATUS_INIT;
1735   return \"fmovem%.l %!,%2\;moveq %#16,%3\;or%.l %2,%3\;and%.w %#-33,%3\;fmovem%.l %3,%!\;fmove%.w %1,%0\;fmovem%.l %2,%!\";
1736 }")
1737
1738 (define_insn "fix_truncdfqi2"
1739   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
1740         (fix:QI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
1741    (clobber (match_scratch:SI 2 "=d"))
1742    (clobber (match_scratch:SI 3 "=d"))]
1743   "TARGET_68881 && TARGET_68040"
1744   "*
1745 {
1746   CC_STATUS_INIT;
1747   return \"fmovem%.l %!,%2\;moveq %#16,%3\;or%.l %2,%3\;and%.w %#-33,%3\;fmovem%.l %3,%!\;fmove%.b %1,%0\;fmovem%.l %2,%!\";
1748 }")
1749
1750 ;; Convert a float to a float whose value is an integer.
1751 ;; This is the first stage of converting it to an integer type.
1752
1753 (define_insn "ftruncdf2"
1754   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
1755         (fix:DF (match_operand:DF 1 "general_operand" "fFm")))]
1756   "TARGET_68881 && !TARGET_68040"
1757   "*
1758 {
1759   if (FP_REG_P (operands[1]))
1760     return \"fintrz%.x %f1,%0\";
1761   return \"fintrz%.d %f1,%0\";
1762 }")
1763
1764 (define_insn "ftruncsf2"
1765   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1766         (fix:SF (match_operand:SF 1 "general_operand" "dfFm")))]
1767   "TARGET_68881 && !TARGET_68040"
1768   "*
1769 {
1770   if (FP_REG_P (operands[1]))
1771     return \"fintrz%.x %f1,%0\";
1772   return \"fintrz%.s %f1,%0\";
1773 }")
1774
1775 ;; Convert a float whose value is an integer
1776 ;; to an actual integer.  Second stage of converting float to integer type.
1777 (define_insn "fixsfqi2"
1778   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
1779         (fix:QI (match_operand:SF 1 "general_operand" "f")))]
1780   "TARGET_68881"
1781   "fmove%.b %1,%0")
1782
1783 (define_insn "fixsfhi2"
1784   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
1785         (fix:HI (match_operand:SF 1 "general_operand" "f")))]
1786   "TARGET_68881"
1787   "fmove%.w %1,%0")
1788
1789 (define_insn "fixsfsi2"
1790   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
1791         (fix:SI (match_operand:SF 1 "general_operand" "f")))]
1792   "TARGET_68881"
1793   "fmove%.l %1,%0")
1794
1795 (define_insn "fixdfqi2"
1796   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
1797         (fix:QI (match_operand:DF 1 "general_operand" "f")))]
1798   "TARGET_68881"
1799   "fmove%.b %1,%0")
1800
1801 (define_insn "fixdfhi2"
1802   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
1803         (fix:HI (match_operand:DF 1 "general_operand" "f")))]
1804   "TARGET_68881"
1805   "fmove%.w %1,%0")
1806
1807 (define_insn "fixdfsi2"
1808   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
1809         (fix:SI (match_operand:DF 1 "general_operand" "f")))]
1810   "TARGET_68881"
1811   "fmove%.l %1,%0")
1812 \f
1813 ;; add instructions
1814
1815 (define_insn "adddi_lshrdi_63"
1816   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1817     (plus:DI (lshiftrt:DI (match_operand:DI 1 "general_operand" "rm")
1818             (const_int 63))
1819         (match_dup 1)))
1820    (clobber (match_scratch:SI 2 "=d"))]
1821   ""
1822   "*
1823 {
1824   operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1825   if (REG_P (operands[1]) && REGNO (operands[1]) == REGNO (operands[0]))
1826     return
1827     \"move%.l %1,%2\;add%.l %2,%2\;subx%.l %2,%2\;sub%.l %2,%3\;subx%.l %2,%0\";
1828   if (GET_CODE (operands[1]) == REG)
1829     operands[4] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1830   else if (GET_CODE (XEXP (operands[1], 0)) == POST_INC
1831         || GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)
1832     operands[4] = operands[1];
1833   else
1834     operands[4] = adjust_address (operands[1], SImode, 4);
1835   if (GET_CODE (operands[1]) == MEM
1836    && GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)
1837     output_asm_insn (\"move%.l %4,%3\", operands);
1838   output_asm_insn (\"move%.l %1,%0\;smi %2\", operands);
1839   if (TARGET_68020 || TARGET_COLDFIRE)
1840     output_asm_insn (\"extb%.l %2\", operands);
1841   else
1842     output_asm_insn (\"ext%.w %2\;ext%.l %2\", operands);
1843   if (GET_CODE (operands[1]) != MEM
1844    || GET_CODE (XEXP (operands[1], 0)) != PRE_DEC)
1845     output_asm_insn (\"move%.l %4,%3\", operands);
1846   return \"sub%.l %2,%3\;subx%.l %2,%0\";
1847 }")
1848
1849 (define_insn "adddi_sexthishl32"
1850   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,a,*d,*d")
1851     (plus:DI (ashift:DI (sign_extend:DI
1852           (match_operand:HI 1 "general_operand" "rm,rm,rm,rm"))
1853             (const_int 32))
1854         (match_operand:DI 2 "general_operand" "0,0,0,0")))
1855    (clobber (match_scratch:SI 3 "=&d,X,a,?d"))]
1856   "!TARGET_COLDFIRE"
1857   "*
1858 {
1859   CC_STATUS_INIT;
1860   if (ADDRESS_REG_P (operands[0]))
1861     return \"add%.w %1,%0\";
1862   else if (ADDRESS_REG_P (operands[3]))
1863     return \"move%.w %1,%3\;add%.l %3,%0\";
1864   else
1865     return \"move%.w %1,%3\;ext%.l %3\;add%.l %3,%0\";
1866 } ")
1867
1868 (define_insn "adddi_dilshr32"
1869   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,o")
1870 ;;    (plus:DI (match_operand:DI 2 "general_operand" "%0")
1871 ;;      (lshiftrt:DI (match_operand:DI 1 "general_operand" "ro")
1872 ;;            (const_int 32))))]
1873     (plus:DI (lshiftrt:DI (match_operand:DI 1 "general_operand" "ro,d")
1874             (const_int 32))
1875         (match_operand:DI 2 "general_operand" "0,0")))]
1876   ""
1877   "*
1878 {
1879   CC_STATUS_INIT;
1880   if (GET_CODE (operands[0]) == REG)
1881     operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1882   else
1883     operands[2] = adjust_address (operands[0], SImode, 4);
1884   return \"add%.l %1,%2\;negx%.l %0\;neg%.l %0\";
1885 } ")
1886
1887 (define_insn "adddi_dishl32"
1888   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,o")
1889 ;;    (plus:DI (match_operand:DI 2 "general_operand" "%0")
1890 ;;      (ashift:DI (match_operand:DI 1 "general_operand" "ro")
1891 ;;            (const_int 32))))]
1892     (plus:DI (ashift:DI (match_operand:DI 1 "general_operand" "ro,d")
1893             (const_int 32))
1894         (match_operand:DI 2 "general_operand" "0,0")))]
1895   ""
1896   "*
1897 {
1898   CC_STATUS_INIT;
1899   if (GET_CODE (operands[1]) == REG)
1900     operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1901   else
1902     operands[1] = adjust_address (operands[1], SImode, 4);
1903   return \"add%.l %1,%0\";
1904 } ")
1905
1906 (define_insn "adddi3"
1907   [(set (match_operand:DI 0 "nonimmediate_operand" "=<,o<>,d,d,d")
1908         (plus:DI (match_operand:DI 1 "general_operand" "%0,0,0,0,0")
1909                  (match_operand:DI 2 "general_operand" "<,d,no>,d,a")))
1910    (clobber (match_scratch:SI 3 "=X,&d,&d,X,&d"))]
1911   ""
1912   "*
1913 {
1914   if (DATA_REG_P (operands[0]))
1915     {
1916       if (DATA_REG_P (operands[2]))
1917         return \"add%.l %R2,%R0\;addx%.l %2,%0\";
1918       else if (GET_CODE (operands[2]) == MEM
1919           && GET_CODE (XEXP (operands[2], 0)) == POST_INC)
1920         return \"move%.l %2,%3\;add%.l %2,%R0\;addx%.l %3,%0\";
1921       else
1922         {
1923           rtx high, low;
1924           rtx xoperands[2];
1925
1926           if (GET_CODE (operands[2]) == REG)
1927             {
1928               low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
1929               high = operands[2];
1930             }
1931           else if (CONSTANT_P (operands[2]))
1932             split_double (operands[2], &high, &low);
1933           else
1934             {
1935               low = adjust_address (operands[2], SImode, 4);
1936               high = operands[2];
1937             }
1938
1939           operands[1] = low, operands[2] = high;
1940           xoperands[0] = operands[3];
1941           if (GET_CODE (operands[1]) == CONST_INT
1942               && INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
1943             xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
1944           else
1945             xoperands[1] = operands[2];
1946
1947           output_asm_insn (output_move_simode (xoperands), xoperands);
1948           if (GET_CODE (operands[1]) == CONST_INT)
1949             {
1950               if (INTVAL (operands[1]) > 0 && INTVAL (operands[1]) <= 8)
1951                 return \"addq%.l %1,%R0\;addx%.l %3,%0\";
1952               else if (INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
1953                 {
1954                   operands[1] = GEN_INT (-INTVAL (operands[1]));
1955                   return \"subq%.l %1,%R0\;subx%.l %3,%0\";
1956                 }
1957             }
1958           return \"add%.l %1,%R0\;addx%.l %3,%0\";
1959         }
1960     }
1961   else if (GET_CODE (operands[0]) == MEM)
1962     {
1963       if (GET_CODE (operands[2]) == MEM
1964           && GET_CODE (XEXP (operands[2], 0)) == PRE_DEC)
1965         return \"add%.l %2,%0\;addx%.l %2,%0\";
1966       CC_STATUS_INIT;
1967       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
1968         {
1969           operands[1] = gen_rtx_MEM (SImode,
1970                                      plus_constant (XEXP(operands[0], 0), -8));
1971           return \"move%.l %0,%3\;add%.l %R2,%0\;addx%.l %2,%3\;move%.l %3,%1\";
1972         }
1973       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
1974         {
1975           operands[1] = XEXP(operands[0], 0);
1976           return \"add%.l %R2,%0\;move%.l %0,%3\;addx%.l %2,%3\;move%.l %3,%1\";
1977         }
1978       else
1979         {
1980           operands[1] = adjust_address (operands[0], SImode, 4);
1981           return \"add%.l %R2,%1\;move%.l %0,%3\;addx%.l %2,%3\;move%.l %3,%0\";
1982         }
1983     }
1984   else
1985     abort ();
1986 } ")
1987
1988 (define_insn "addsi_lshrsi_31"
1989   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
1990     (plus:SI (lshiftrt:SI (match_operand:SI 1 "general_operand" "rm")
1991             (const_int 31))
1992         (match_dup 1)))]
1993   ""
1994   "*
1995 {
1996   operands[2] = operands[0];
1997   operands[3] = gen_label_rtx();
1998   if (GET_CODE (operands[0]) == MEM)
1999     {
2000       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2001         operands[0] = gen_rtx_MEM (SImode, XEXP (XEXP (operands[0], 0), 0));
2002       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2003         operands[2] = gen_rtx_MEM (SImode, XEXP (XEXP (operands[0], 0), 0));
2004     }
2005   output_asm_insn (\"move%.l %1,%0\", operands);
2006 #ifdef MOTOROLA
2007   output_asm_insn (\"jbpl %l3\", operands);
2008 #else
2009   output_asm_insn (\"jpl %l3\", operands);
2010 #endif
2011   output_asm_insn (\"addq%.l %#1,%2\", operands);
2012   (*targetm.asm_out.internal_label) (asm_out_file, \"L\",
2013                                 CODE_LABEL_NUMBER (operands[3]));
2014   return \"\";
2015 }")
2016
2017 (define_expand "addsi3"
2018   [(set (match_operand:SI 0 "nonimmediate_operand" "")
2019         (plus:SI (match_operand:SI 1 "general_operand" "")
2020                  (match_operand:SI 2 "general_src_operand" "")))]
2021   ""
2022   "")
2023
2024 ;; Note that the middle two alternatives are near-duplicates
2025 ;; in order to handle insns generated by reload.
2026 ;; This is needed since they are not themselves reloaded,
2027 ;; so commutativity won't apply to them.
2028 (define_insn "*addsi3_internal"
2029   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,?a,?a,d,a")
2030         (plus:SI (match_operand:SI 1 "general_operand" "%0,a,rJK,0,0")
2031                  (match_operand:SI 2 "general_src_operand" "dIKLT,rJK,a,mSrIKLT,mSrIKLs")))]
2032
2033
2034   "! TARGET_COLDFIRE"
2035   "* return output_addsi3 (operands);")
2036
2037 (define_insn "*addsi3_5200"
2038   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,?a,?a,r")
2039         (plus:SI (match_operand:SI 1 "general_operand" "%0,a,rJK,0")
2040                  (match_operand:SI 2 "general_src_operand" "d,rJK,a,mrIKLs")))]
2041   "TARGET_COLDFIRE"
2042   "* return output_addsi3 (operands);")
2043
2044 (define_insn ""
2045   [(set (match_operand:SI 0 "nonimmediate_operand" "=a")
2046         (plus:SI (match_operand:SI 1 "general_operand" "0")
2047                  (sign_extend:SI
2048                   (match_operand:HI 2 "nonimmediate_src_operand" "rmS"))))]
2049   "!TARGET_COLDFIRE"
2050   "add%.w %2,%0")
2051
2052 (define_insn "addhi3"
2053   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,r")
2054         (plus:HI (match_operand:HI 1 "general_operand" "%0,0")
2055                  (match_operand:HI 2 "general_src_operand" "dn,rmSn")))]
2056   "!TARGET_COLDFIRE"
2057   "*
2058 {
2059   if (GET_CODE (operands[2]) == CONST_INT)
2060     {
2061       /* If the constant would be a negative number when interpreted as
2062          HImode, make it negative.  This is usually, but not always, done
2063          elsewhere in the compiler.  First check for constants out of range,
2064          which could confuse us.  */
2065
2066       if (INTVAL (operands[2]) >= 32768)
2067         operands[2] = GEN_INT (INTVAL (operands[2]) - 65536);
2068
2069       if (INTVAL (operands[2]) > 0
2070           && INTVAL (operands[2]) <= 8)
2071         return \"addq%.w %2,%0\";
2072       if (INTVAL (operands[2]) < 0
2073           && INTVAL (operands[2]) >= -8)
2074         {
2075           operands[2] = GEN_INT (- INTVAL (operands[2]));
2076           return \"subq%.w %2,%0\";
2077         }
2078       /* On the CPU32 it is faster to use two addqw instructions to
2079          add a small integer (8 < N <= 16) to a register.  
2080          Likewise for subqw.  */
2081       if (TARGET_CPU32 && REG_P (operands[0]))
2082         {
2083           if (INTVAL (operands[2]) > 8
2084               && INTVAL (operands[2]) <= 16)
2085             {
2086               operands[2] = GEN_INT (INTVAL (operands[2]) - 8);
2087               return \"addq%.w %#8,%0\;addq%.w %2,%0\";
2088             }
2089           if (INTVAL (operands[2]) < -8
2090               && INTVAL (operands[2]) >= -16)
2091             {
2092               operands[2] = GEN_INT (- INTVAL (operands[2]) - 8);
2093               return \"subq%.w %#8,%0\;subq%.w %2,%0\";
2094             }
2095         }
2096       if (ADDRESS_REG_P (operands[0]) && !TARGET_68040)
2097 #ifdef MOTOROLA  
2098             return \"lea (%c2,%0),%0\";
2099 #else
2100             return \"lea %0@(%c2),%0\";
2101 #endif
2102     }
2103   return \"add%.w %2,%0\";
2104 }")
2105
2106 ;; These insns must use MATCH_DUP instead of the more expected
2107 ;; use of a matching constraint because the "output" here is also
2108 ;; an input, so you can't use the matching constraint.  That also means
2109 ;; that you can't use the "%", so you need patterns with the matched
2110 ;; operand in both positions.
2111
2112 (define_insn ""
2113   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2114         (plus:HI (match_dup 0)
2115                  (match_operand:HI 1 "general_src_operand" "dn,rmSn")))]
2116   "!TARGET_COLDFIRE"
2117   "*
2118 {
2119   if (GET_CODE (operands[1]) == CONST_INT)
2120     {
2121       /* If the constant would be a negative number when interpreted as
2122          HImode, make it negative.  This is usually, but not always, done
2123          elsewhere in the compiler.  First check for constants out of range,
2124          which could confuse us.  */
2125
2126       if (INTVAL (operands[1]) >= 32768)
2127         operands[1] = GEN_INT (INTVAL (operands[1]) - 65536);
2128
2129       if (INTVAL (operands[1]) > 0
2130           && INTVAL (operands[1]) <= 8)
2131         return \"addq%.w %1,%0\";
2132       if (INTVAL (operands[1]) < 0
2133           && INTVAL (operands[1]) >= -8)
2134         {
2135           operands[1] = GEN_INT (- INTVAL (operands[1]));
2136           return \"subq%.w %1,%0\";
2137         }
2138       /* On the CPU32 it is faster to use two addqw instructions to
2139          add a small integer (8 < N <= 16) to a register. 
2140          Likewise for subqw.  */
2141       if (TARGET_CPU32 && REG_P (operands[0]))
2142         {
2143           if (INTVAL (operands[1]) > 8
2144               && INTVAL (operands[1]) <= 16)
2145             {
2146               operands[1] = GEN_INT (INTVAL (operands[1]) - 8);
2147               return \"addq%.w %#8,%0\;addq%.w %1,%0\";
2148             }
2149           if (INTVAL (operands[1]) < -8
2150               && INTVAL (operands[1]) >= -16)
2151             {
2152               operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
2153               return \"subq%.w %#8,%0\;subq%.w %1,%0\";
2154             }
2155         }
2156       if (ADDRESS_REG_P (operands[0]) && !TARGET_68040)
2157 #ifdef MOTOROLA  
2158             return \"lea (%c1,%0),%0\";
2159 #else
2160             return \"lea %0@(%c1),%0\";
2161 #endif
2162     }
2163   return \"add%.w %1,%0\";
2164 }")
2165
2166 (define_insn ""
2167   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2168         (plus:HI (match_operand:HI 1 "general_src_operand" "dn,rmSn")
2169                  (match_dup 0)))]
2170   "!TARGET_COLDFIRE"
2171   "*
2172 {
2173   if (GET_CODE (operands[1]) == CONST_INT)
2174     {
2175       /* If the constant would be a negative number when interpreted as
2176          HImode, make it negative.  This is usually, but not always, done
2177          elsewhere in the compiler.  First check for constants out of range,
2178          which could confuse us.  */
2179
2180       if (INTVAL (operands[1]) >= 32768)
2181         operands[1] = GEN_INT (INTVAL (operands[1]) - 65536);
2182
2183       if (INTVAL (operands[1]) > 0
2184           && INTVAL (operands[1]) <= 8)
2185         return \"addq%.w %1,%0\";
2186       if (INTVAL (operands[1]) < 0
2187           && INTVAL (operands[1]) >= -8)
2188         {
2189           operands[1] = GEN_INT (- INTVAL (operands[1]));
2190           return \"subq%.w %1,%0\";
2191         }
2192       /* On the CPU32 it is faster to use two addqw instructions to
2193          add a small integer (8 < N <= 16) to a register.
2194          Likewise for subqw.  */
2195       if (TARGET_CPU32 && REG_P (operands[0])) 
2196         {
2197           if (INTVAL (operands[1]) > 8
2198               && INTVAL (operands[1]) <= 16)
2199             {
2200               operands[1] = GEN_INT (INTVAL (operands[1]) - 8);
2201               return \"addq%.w %#8,%0\;addq%.w %1,%0\";
2202             }
2203           if (INTVAL (operands[1]) < -8
2204               && INTVAL (operands[1]) >= -16)
2205             {
2206               operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
2207               return \"subq%.w %#8,%0\;subq%.w %1,%0\";
2208             }
2209         }
2210       if (ADDRESS_REG_P (operands[0]) && !TARGET_68040)
2211 #ifdef MOTOROLA  
2212             return \"lea (%c1,%0),%0\";
2213 #else
2214             return \"lea %0@(%c1),%0\";
2215 #endif
2216     }
2217   return \"add%.w %1,%0\";
2218 }")
2219
2220 (define_insn "addqi3"
2221   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
2222         (plus:QI (match_operand:QI 1 "general_operand" "%0,0")
2223                  (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
2224   "!TARGET_COLDFIRE"
2225   "*
2226 {
2227   if (GET_CODE (operands[2]) == CONST_INT)
2228     {
2229       if (INTVAL (operands[2]) >= 128)
2230         operands[2] = GEN_INT (INTVAL (operands[2]) - 256);
2231
2232       if (INTVAL (operands[2]) > 0
2233           && INTVAL (operands[2]) <= 8)
2234         return \"addq%.b %2,%0\";
2235       if (INTVAL (operands[2]) < 0 && INTVAL (operands[2]) >= -8)
2236        {
2237          operands[2] = GEN_INT (- INTVAL (operands[2]));
2238          return \"subq%.b %2,%0\";
2239        }
2240     }
2241   return \"add%.b %2,%0\";
2242 }")
2243
2244 (define_insn ""
2245   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2246         (plus:QI (match_dup 0)
2247                  (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
2248   "!TARGET_COLDFIRE"
2249   "*
2250 {
2251   if (GET_CODE (operands[1]) == CONST_INT)
2252     {
2253       if (INTVAL (operands[1]) >= 128)
2254         operands[1] = GEN_INT (INTVAL (operands[1]) - 256);
2255
2256       if (INTVAL (operands[1]) > 0
2257           && INTVAL (operands[1]) <= 8)
2258         return \"addq%.b %1,%0\";
2259       if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
2260        {
2261          operands[1] = GEN_INT (- INTVAL (operands[1]));
2262          return \"subq%.b %1,%0\";
2263        }
2264     }
2265   return \"add%.b %1,%0\";
2266 }")
2267
2268 (define_insn ""
2269   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2270         (plus:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
2271                  (match_dup 0)))]
2272   "!TARGET_COLDFIRE"
2273   "*
2274 {
2275   if (GET_CODE (operands[1]) == CONST_INT)
2276     {
2277       if (INTVAL (operands[1]) >= 128)
2278         operands[1] = GEN_INT (INTVAL (operands[1]) - 256);
2279
2280       if (INTVAL (operands[1]) > 0
2281           && INTVAL (operands[1]) <= 8)
2282         return \"addq%.b %1,%0\";
2283       if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
2284        {
2285          operands[1] = GEN_INT (- INTVAL (operands[1]));
2286          return \"subq%.b %1,%0\";
2287        }
2288     }
2289   return \"add%.b %1,%0\";
2290 }")
2291
2292 (define_expand "adddf3"
2293   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2294         (plus:DF (match_operand:DF 1 "general_operand" "")
2295                  (match_operand:DF 2 "general_operand" "")))]
2296   "TARGET_68881"
2297   "")
2298
2299 (define_insn ""
2300   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2301         (plus:DF (float:DF (match_operand:SI 2 "general_operand" "dmi"))
2302                  (match_operand:DF 1 "general_operand" "0")))]
2303   "TARGET_68881"
2304   "f%&add%.l %2,%0")
2305
2306 (define_insn ""
2307   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2308         (plus:DF (float:DF (match_operand:HI 2 "general_operand" "dmn"))
2309                  (match_operand:DF 1 "general_operand" "0")))]
2310   "TARGET_68881"
2311   "f%&add%.w %2,%0")
2312
2313 (define_insn ""
2314   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2315         (plus:DF (float:DF (match_operand:QI 2 "general_operand" "dmn"))
2316                  (match_operand:DF 1 "general_operand" "0")))]
2317   "TARGET_68881"
2318   "f%&add%.b %2,%0")
2319
2320 (define_insn ""
2321   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2322         (plus:DF (match_operand:DF 1 "general_operand" "%0")
2323                  (match_operand:DF 2 "general_operand" "fmG")))]
2324   "TARGET_68881"
2325   "*
2326 {
2327   if (REG_P (operands[2]))
2328     return \"f%&add%.x %2,%0\";
2329   return \"f%&add%.d %f2,%0\";
2330 }")
2331
2332 (define_expand "addsf3"
2333   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2334         (plus:SF (match_operand:SF 1 "general_operand" "")
2335                  (match_operand:SF 2 "general_operand" "")))]
2336   "TARGET_68881"
2337   "")
2338
2339 (define_insn ""
2340   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2341         (plus:SF (float:SF (match_operand:SI 2 "general_operand" "dmi"))
2342                  (match_operand:SF 1 "general_operand" "0")))]
2343   "TARGET_68881"
2344   "f%$add%.l %2,%0")
2345
2346 (define_insn ""
2347   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2348         (plus:SF (float:SF (match_operand:HI 2 "general_operand" "dmn"))
2349                  (match_operand:SF 1 "general_operand" "0")))]
2350   "TARGET_68881"
2351   "f%$add%.w %2,%0")
2352
2353 (define_insn ""
2354   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2355         (plus:SF (float:SF (match_operand:QI 2 "general_operand" "dmn"))
2356                  (match_operand:SF 1 "general_operand" "0")))]
2357   "TARGET_68881"
2358   "f%$add%.b %2,%0")
2359
2360 (define_insn ""
2361   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2362         (plus:SF (match_operand:SF 1 "general_operand" "%0")
2363                  (match_operand:SF 2 "general_operand" "fdmF")))]
2364   "TARGET_68881"
2365   "*
2366 {
2367   if (REG_P (operands[2]) && ! DATA_REG_P (operands[2]))
2368     return \"f%$add%.x %2,%0\";
2369   return \"f%$add%.s %f2,%0\";
2370 }")
2371 \f
2372 ;; subtract instructions
2373
2374 (define_insn "subdi_sexthishl32"
2375   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,a,*d,*d")
2376     (minus:DI (match_operand:DI 1 "general_operand" "0,0,0,0")
2377         (ashift:DI (sign_extend:DI (match_operand:HI 2 "general_operand" "rm,rm,rm,rm"))
2378             (const_int 32))))
2379    (clobber (match_scratch:SI 3 "=&d,X,a,?d"))]
2380   "!TARGET_COLDFIRE"
2381   "*
2382 {
2383   CC_STATUS_INIT;
2384   if (ADDRESS_REG_P (operands[0]))
2385     return \"sub%.w %2,%0\";
2386   else if (ADDRESS_REG_P (operands[3]))
2387     return \"move%.w %2,%3\;sub%.l %3,%0\";
2388   else
2389     return \"move%.w %2,%3\;ext%.l %3\;sub%.l %3,%0\";
2390 } ")
2391
2392 (define_insn "subdi_dishl32"
2393   [(set (match_operand:DI 0 "nonimmediate_operand" "+ro")
2394     (minus:DI (match_dup 0)
2395         (ashift:DI (match_operand:DI 1 "general_operand" "ro")
2396             (const_int 32))))]
2397   ""
2398   "*
2399 {
2400   CC_STATUS_INIT;
2401   if (GET_CODE (operands[1]) == REG)
2402     operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2403   else
2404     operands[1] = adjust_address (operands[1], SImode, 4);
2405   return \"sub%.l %1,%0\";
2406 } ")
2407
2408 (define_insn "subdi3"
2409   [(set (match_operand:DI 0 "nonimmediate_operand" "=<,o<>,d,d,d")
2410         (minus:DI (match_operand:DI 1 "general_operand" "0,0,0,0,0")
2411                  (match_operand:DI 2 "general_operand" "<,d,no>,d,a")))
2412    (clobber (match_scratch:SI 3 "=X,&d,&d,X,&d"))]
2413   ""
2414   "*
2415 {
2416   if (DATA_REG_P (operands[0]))
2417     {
2418       if (DATA_REG_P (operands[2]))
2419         return \"sub%.l %R2,%R0\;subx%.l %2,%0\";
2420       else if (GET_CODE (operands[2]) == MEM
2421           && GET_CODE (XEXP (operands[2], 0)) == POST_INC)
2422         {
2423           return \"move%.l %2,%3\;sub%.l %2,%R0\;subx%.l %3,%0\";
2424         }
2425       else
2426         {
2427           rtx high, low;
2428           rtx xoperands[2];
2429
2430           if (GET_CODE (operands[2]) == REG)
2431             {
2432               low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
2433               high = operands[2];
2434             }
2435           else if (CONSTANT_P (operands[2]))
2436             split_double (operands[2], &high, &low);
2437           else
2438             {
2439               low = adjust_address (operands[2], SImode, 4);
2440               high = operands[2];
2441             }
2442
2443           operands[1] = low, operands[2] = high;
2444           xoperands[0] = operands[3];
2445           if (GET_CODE (operands[1]) == CONST_INT
2446               && INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2447             xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
2448           else
2449             xoperands[1] = operands[2];
2450
2451           output_asm_insn (output_move_simode (xoperands), xoperands);
2452           if (GET_CODE (operands[1]) == CONST_INT)
2453             {
2454               if (INTVAL (operands[1]) > 0 && INTVAL (operands[1]) <= 8)
2455                 return \"subq%.l %1,%R0\;subx%.l %3,%0\";
2456               else if (INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2457                 {
2458                   operands[1] = GEN_INT (-INTVAL (operands[1]));
2459                   return \"addq%.l %1,%R0\;addx%.l %3,%0\";
2460                 }
2461             }
2462           return \"sub%.l %1,%R0\;subx%.l %3,%0\";
2463         }
2464     }
2465   else if (GET_CODE (operands[0]) == MEM)
2466     {
2467       if (GET_CODE (operands[2]) == MEM
2468           && GET_CODE (XEXP (operands[2], 0)) == PRE_DEC)
2469         return \"sub%.l %2,%0\;subx%.l %2,%0\";
2470       CC_STATUS_INIT;
2471       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2472         {
2473           operands[1]
2474             = gen_rtx_MEM (SImode, plus_constant (XEXP (operands[0], 0), -8));
2475           return \"move%.l %0,%3\;sub%.l %R2,%0\;subx%.l %2,%3\;move%.l %3,%1\";
2476         }
2477       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2478         {
2479           operands[1] = XEXP(operands[0], 0);
2480           return \"sub%.l %R2,%0\;move%.l %0,%3\;subx%.l %2,%3\;move%.l %3,%1\";
2481         }
2482       else
2483         {
2484           operands[1] = adjust_address (operands[0], SImode, 4);
2485           return \"sub%.l %R2,%1\;move%.l %0,%3\;subx%.l %2,%3\;move%.l %3,%0\";
2486         }
2487     }
2488   else
2489     abort ();
2490 } ")
2491
2492 (define_insn "subsi3"
2493   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d,a")
2494         (minus:SI (match_operand:SI 1 "general_operand" "0,0,0")
2495                   (match_operand:SI 2 "general_src_operand" "dT,mSrT,mSrs")))]
2496   ""
2497   "sub%.l %2,%0")
2498
2499 (define_insn ""
2500   [(set (match_operand:SI 0 "nonimmediate_operand" "=a")
2501         (minus:SI (match_operand:SI 1 "general_operand" "0")
2502                   (sign_extend:SI
2503                    (match_operand:HI 2 "nonimmediate_src_operand" "rmS"))))]
2504   "!TARGET_COLDFIRE"
2505   "sub%.w %2,%0")
2506
2507 (define_insn "subhi3"
2508   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,r")
2509         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
2510                   (match_operand:HI 2 "general_src_operand" "dn,rmSn")))]
2511   "!TARGET_COLDFIRE"
2512   "sub%.w %2,%0")
2513
2514 (define_insn ""
2515   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2516         (minus:HI (match_dup 0)
2517                   (match_operand:HI 1 "general_src_operand" "dn,rmSn")))]
2518   "!TARGET_COLDFIRE"
2519   "sub%.w %1,%0")
2520
2521 (define_insn "subqi3"
2522   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
2523         (minus:QI (match_operand:QI 1 "general_operand" "0,0")
2524                   (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
2525   "!TARGET_COLDFIRE"
2526   "sub%.b %2,%0")
2527
2528 (define_insn ""
2529   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2530         (minus:QI (match_dup 0)
2531                   (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
2532   "!TARGET_COLDFIRE"
2533   "sub%.b %1,%0")
2534
2535 (define_expand "subdf3"
2536   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2537         (minus:DF (match_operand:DF 1 "general_operand" "")
2538                   (match_operand:DF 2 "general_operand" "")))]
2539   "TARGET_68881"
2540   "")
2541
2542 (define_insn ""
2543   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2544         (minus:DF (match_operand:DF 1 "general_operand" "0")
2545                   (float:DF (match_operand:SI 2 "general_operand" "dmi"))))]
2546   "TARGET_68881"
2547   "f%&sub%.l %2,%0")
2548
2549 (define_insn ""
2550   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2551         (minus:DF (match_operand:DF 1 "general_operand" "0")
2552                   (float:DF (match_operand:HI 2 "general_operand" "dmn"))))]
2553   "TARGET_68881"
2554   "f%&sub%.w %2,%0")
2555
2556 (define_insn ""
2557   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2558         (minus:DF (match_operand:DF 1 "general_operand" "0")
2559                   (float:DF (match_operand:QI 2 "general_operand" "dmn"))))]
2560   "TARGET_68881"
2561   "f%&sub%.b %2,%0")
2562
2563 (define_insn ""
2564   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2565         (minus:DF (match_operand:DF 1 "general_operand" "0")
2566                   (match_operand:DF 2 "general_operand" "fmG")))]
2567   "TARGET_68881"
2568   "*
2569 {
2570   if (REG_P (operands[2]))
2571     return \"f%&sub%.x %2,%0\";
2572   return \"f%&sub%.d %f2,%0\";
2573 }")
2574
2575 (define_expand "subsf3"
2576   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2577         (minus:SF (match_operand:SF 1 "general_operand" "")
2578                   (match_operand:SF 2 "general_operand" "")))]
2579   "TARGET_68881"
2580   "")
2581
2582 (define_insn ""
2583   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2584         (minus:SF (match_operand:SF 1 "general_operand" "0")
2585                   (float:SF (match_operand:SI 2 "general_operand" "dmi"))))]
2586   "TARGET_68881"
2587   "f%$sub%.l %2,%0")
2588
2589 (define_insn ""
2590   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2591         (minus:SF (match_operand:SF 1 "general_operand" "0")
2592                   (float:SF (match_operand:HI 2 "general_operand" "dmn"))))]
2593   "TARGET_68881"
2594   "f%$sub%.w %2,%0")
2595
2596 (define_insn ""
2597   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2598         (minus:SF (match_operand:SF 1 "general_operand" "0")
2599                   (float:SF (match_operand:QI 2 "general_operand" "dmn"))))]
2600   "TARGET_68881"
2601   "f%$sub%.b %2,%0")
2602
2603 (define_insn ""
2604   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2605         (minus:SF (match_operand:SF 1 "general_operand" "0")
2606                   (match_operand:SF 2 "general_operand" "fdmF")))]
2607   "TARGET_68881"
2608   "*
2609 {
2610   if (REG_P (operands[2]) && ! DATA_REG_P (operands[2]))
2611     return \"f%$sub%.x %2,%0\";
2612   return \"f%$sub%.s %f2,%0\";
2613 }")
2614 \f
2615 ;; multiply instructions
2616
2617 (define_insn "mulhi3"
2618   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
2619         (mult:HI (match_operand:HI 1 "general_operand" "%0")
2620                  (match_operand:HI 2 "general_src_operand" "dmSn")))]
2621   ""
2622   "*
2623 {
2624 #if defined(MOTOROLA)
2625   return \"muls%.w %2,%0\";
2626 #else
2627   return \"muls %2,%0\";
2628 #endif
2629 }")
2630
2631 (define_insn "mulhisi3"
2632   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2633         (mult:SI (sign_extend:SI
2634                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
2635                  (sign_extend:SI
2636                   (match_operand:HI 2 "nonimmediate_src_operand" "dmS"))))]
2637   ""
2638   "*
2639 {
2640 #if defined(MOTOROLA)
2641   return \"muls%.w %2,%0\";
2642 #else
2643   return \"muls %2,%0\";
2644 #endif
2645 }")
2646
2647 (define_insn ""
2648   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2649         (mult:SI (sign_extend:SI
2650                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
2651                  (match_operand:SI 2 "const_int_operand" "n")))]
2652   "INTVAL (operands[2]) >= -0x8000 && INTVAL (operands[2]) <= 0x7fff"
2653   "*
2654 {
2655 #if defined(MOTOROLA)
2656   return \"muls%.w %2,%0\";
2657 #else
2658   return \"muls %2,%0\";
2659 #endif
2660 }")
2661
2662 (define_expand "mulsi3"
2663   [(set (match_operand:SI 0 "nonimmediate_operand" "")
2664         (mult:SI (match_operand:SI 1 "general_operand" "")
2665                  (match_operand:SI 2 "general_operand" "")))]
2666   "TARGET_68020 || TARGET_COLDFIRE"
2667   "")
2668
2669 (define_insn ""
2670   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2671         (mult:SI (match_operand:SI 1 "general_operand" "%0")
2672                  (match_operand:SI 2 "general_src_operand" "dmSTK")))]
2673
2674   "TARGET_68020"
2675   "muls%.l %2,%0")
2676
2677 (define_insn ""
2678   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2679         (mult:SI (match_operand:SI 1 "general_operand" "%0")
2680                  (match_operand:SI 2 "general_operand" "d<Q>")))]
2681   "TARGET_COLDFIRE"
2682   "muls%.l %2,%0")
2683
2684 (define_insn "umulhisi3"
2685   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2686         (mult:SI (zero_extend:SI
2687                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
2688                  (zero_extend:SI
2689                   (match_operand:HI 2 "nonimmediate_src_operand" "dmS"))))]
2690   ""
2691   "*
2692 {
2693 #if defined(MOTOROLA)
2694   return \"mulu%.w %2,%0\";
2695 #else
2696   return \"mulu %2,%0\";
2697 #endif
2698 }")
2699
2700 (define_insn ""
2701   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
2702         (mult:SI (zero_extend:SI
2703                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
2704                  (match_operand:SI 2 "const_int_operand" "n")))]
2705   "INTVAL (operands[2]) >= 0 && INTVAL (operands[2]) <= 0xffff"
2706   "*
2707 {
2708 #if defined(MOTOROLA)
2709   return \"mulu%.w %2,%0\";
2710 #else
2711   return \"mulu %2,%0\";
2712 #endif
2713 }")
2714
2715 ;; We need a separate DEFINE_EXPAND for u?mulsidi3 to be able to use the
2716 ;; proper matching constraint.  This is because the matching is between
2717 ;; the high-numbered word of the DImode operand[0] and operand[1].
2718 (define_expand "umulsidi3"
2719   [(parallel
2720     [(set (subreg:SI (match_operand:DI 0 "register_operand" "") 4)
2721           (mult:SI (match_operand:SI 1 "register_operand" "")
2722                    (match_operand:SI 2 "register_operand" "")))
2723      (set (subreg:SI (match_dup 0) 0)
2724           (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
2725                                              (zero_extend:DI (match_dup 2)))
2726                                     (const_int 32))))])]
2727   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2728   "")
2729
2730 (define_insn ""
2731   [(set (match_operand:SI 0 "register_operand" "=d")
2732         (mult:SI (match_operand:SI 1 "register_operand" "%0")
2733                   (match_operand:SI 2 "nonimmediate_operand" "dm")))
2734    (set (match_operand:SI 3 "register_operand" "=d")
2735         (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
2736                                            (zero_extend:DI (match_dup 2)))
2737                                   (const_int 32))))]
2738   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2739   "mulu%.l %2,%3:%0")
2740
2741 ; Match immediate case.  For 2.4 only match things < 2^31.
2742 ; It's tricky with larger values in these patterns since we need to match
2743 ; values between the two parallel multiplies, between a CONST_DOUBLE and
2744 ; a CONST_INT.
2745 (define_insn ""
2746   [(set (match_operand:SI 0 "register_operand" "=d")
2747         (mult:SI (match_operand:SI 1 "register_operand" "%0")
2748                  (match_operand:SI 2 "const_int_operand" "n")))
2749    (set (match_operand:SI 3 "register_operand" "=d")
2750         (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
2751                                            (match_dup 2))
2752                                   (const_int 32))))]
2753   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE
2754    && (unsigned) INTVAL (operands[2]) <= 0x7fffffff"
2755   "mulu%.l %2,%3:%0")
2756
2757 (define_expand "mulsidi3"
2758   [(parallel
2759     [(set (subreg:SI (match_operand:DI 0 "register_operand" "") 4)
2760           (mult:SI (match_operand:SI 1 "register_operand" "")
2761                    (match_operand:SI 2 "register_operand" "")))
2762      (set (subreg:SI (match_dup 0) 0)
2763           (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
2764                                              (sign_extend:DI (match_dup 2)))
2765                                     (const_int 32))))])]
2766   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2767   "")
2768
2769 (define_insn ""
2770   [(set (match_operand:SI 0 "register_operand" "=d")
2771         (mult:SI (match_operand:SI 1 "register_operand" "%0")
2772                  (match_operand:SI 2 "nonimmediate_operand" "dm")))
2773    (set (match_operand:SI 3 "register_operand" "=d")
2774         (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
2775                                            (sign_extend:DI (match_dup 2)))
2776                                   (const_int 32))))]
2777   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2778   "muls%.l %2,%3:%0")
2779
2780 (define_insn ""
2781   [(set (match_operand:SI 0 "register_operand" "=d")
2782         (mult:SI (match_operand:SI 1 "register_operand" "%0")
2783                  (match_operand:SI 2 "const_int_operand" "n")))
2784    (set (match_operand:SI 3 "register_operand" "=d")
2785         (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
2786                                            (match_dup 2))
2787                                   (const_int 32))))]
2788   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2789   "muls%.l %2,%3:%0")
2790
2791 (define_expand "umulsi3_highpart"
2792   [(parallel
2793     [(set (match_operand:SI 0 "register_operand" "")
2794           (truncate:SI
2795            (lshiftrt:DI
2796             (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" ""))
2797                      (zero_extend:DI (match_operand:SI 2 "general_operand" "")))
2798             (const_int 32))))
2799      (clobber (match_dup 3))])]
2800   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2801   "
2802 {
2803   operands[3] = gen_reg_rtx (SImode);
2804
2805   if (GET_CODE (operands[2]) == CONST_INT)
2806     {
2807       operands[2] = immed_double_const (INTVAL (operands[2]) & 0xffffffff,
2808                                         0, DImode);
2809
2810       /* We have to adjust the operand order for the matching constraints.  */
2811       emit_insn (gen_const_umulsi3_highpart (operands[0], operands[3],
2812                                              operands[1], operands[2]));
2813       DONE;
2814     }
2815 }")
2816
2817 (define_insn ""
2818   [(set (match_operand:SI 0 "register_operand" "=d")
2819         (truncate:SI
2820          (lshiftrt:DI
2821           (mult:DI (zero_extend:DI (match_operand:SI 2 "register_operand" "%1"))
2822                    (zero_extend:DI (match_operand:SI 3 "nonimmediate_operand" "dm")))
2823           (const_int 32))))
2824    (clobber (match_operand:SI 1 "register_operand" "=d"))]
2825   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2826   "mulu%.l %3,%0:%1")
2827
2828 (define_insn "const_umulsi3_highpart"
2829   [(set (match_operand:SI 0 "register_operand" "=d")
2830         (truncate:SI
2831          (lshiftrt:DI
2832           (mult:DI (zero_extend:DI (match_operand:SI 2 "register_operand" "1"))
2833                    (match_operand:DI 3 "const_uint32_operand" "n"))
2834           (const_int 32))))
2835    (clobber (match_operand:SI 1 "register_operand" "=d"))]
2836   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2837   "mulu%.l %3,%0:%1")
2838
2839 (define_expand "smulsi3_highpart"
2840   [(parallel
2841     [(set (match_operand:SI 0 "register_operand" "")
2842           (truncate:SI
2843            (lshiftrt:DI
2844             (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" ""))
2845                      (sign_extend:DI (match_operand:SI 2 "general_operand" "")))
2846             (const_int 32))))
2847      (clobber (match_dup 3))])]
2848   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2849   "
2850 {
2851   operands[3] = gen_reg_rtx (SImode);
2852   if (GET_CODE (operands[2]) == CONST_INT)
2853     {
2854       /* We have to adjust the operand order for the matching constraints.  */
2855       emit_insn (gen_const_smulsi3_highpart (operands[0], operands[3],
2856                                              operands[1], operands[2]));
2857       DONE;
2858     }
2859 }")
2860
2861 (define_insn ""
2862   [(set (match_operand:SI 0 "register_operand" "=d")
2863         (truncate:SI
2864          (lshiftrt:DI
2865           (mult:DI (sign_extend:DI (match_operand:SI 2 "register_operand" "%1"))
2866                    (sign_extend:DI (match_operand:SI 3 "nonimmediate_operand" "dm")))
2867           (const_int 32))))
2868    (clobber (match_operand:SI 1 "register_operand" "=d"))]
2869   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2870   "muls%.l %3,%0:%1")
2871
2872 (define_insn "const_smulsi3_highpart"
2873   [(set (match_operand:SI 0 "register_operand" "=d")
2874         (truncate:SI
2875          (lshiftrt:DI
2876           (mult:DI (sign_extend:DI (match_operand:SI 2 "register_operand" "1"))
2877                    (match_operand:DI 3 "const_sint32_operand" "n"))
2878           (const_int 32))))
2879    (clobber (match_operand:SI 1 "register_operand" "=d"))]
2880   "TARGET_68020 && !TARGET_68060 && !TARGET_COLDFIRE"
2881   "muls%.l %3,%0:%1")
2882
2883 (define_expand "muldf3"
2884   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2885         (mult:DF (match_operand:DF 1 "general_operand" "")
2886                  (match_operand:DF 2 "general_operand" "")))]
2887   "TARGET_68881"
2888   "")
2889
2890 (define_insn ""
2891   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2892         (mult:DF (float:DF (match_operand:SI 2 "general_operand" "dmi"))
2893                  (match_operand:DF 1 "general_operand" "0")))]
2894   "TARGET_68881"
2895   "f%&mul%.l %2,%0")
2896
2897 (define_insn ""
2898   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2899         (mult:DF (float:DF (match_operand:HI 2 "general_operand" "dmn"))
2900                  (match_operand:DF 1 "general_operand" "0")))]
2901   "TARGET_68881"
2902   "f%&mul%.w %2,%0")
2903
2904 (define_insn ""
2905   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2906         (mult:DF (float:DF (match_operand:QI 2 "general_operand" "dmn"))
2907                  (match_operand:DF 1 "general_operand" "0")))]
2908   "TARGET_68881"
2909   "f%&mul%.b %2,%0")
2910
2911 (define_insn ""
2912   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
2913         (mult:DF (match_operand:DF 1 "general_operand" "%0")
2914                  (match_operand:DF 2 "general_operand" "fmG")))]
2915   "TARGET_68881"
2916   "*
2917 {
2918   if (GET_CODE (operands[2]) == CONST_DOUBLE
2919       && floating_exact_log2 (operands[2]) && !TARGET_68040 && !TARGET_68060)
2920     {
2921       int i = floating_exact_log2 (operands[2]);
2922       operands[2] = GEN_INT (i);
2923       return \"fscale%.l %2,%0\";
2924     }
2925   if (REG_P (operands[2]))
2926     return \"f%&mul%.x %2,%0\";
2927   return \"f%&mul%.d %f2,%0\";
2928 }")
2929
2930 (define_expand "mulsf3"
2931   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2932         (mult:SF (match_operand:SF 1 "general_operand" "")
2933                  (match_operand:SF 2 "general_operand" "")))]
2934   "TARGET_68881"
2935   "")
2936
2937 (define_insn ""
2938   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2939         (mult:SF (float:SF (match_operand:SI 2 "general_operand" "dmi"))
2940                  (match_operand:SF 1 "general_operand" "0")))]
2941   "TARGET_68881"
2942   "*
2943 {
2944   return (TARGET_68040_ONLY
2945           ? \"fsmul%.l %2,%0\"
2946           : \"fsglmul%.l %2,%0\");
2947 }")
2948
2949 (define_insn ""
2950   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2951         (mult:SF (float:SF (match_operand:HI 2 "general_operand" "dmn"))
2952                  (match_operand:SF 1 "general_operand" "0")))]
2953   "TARGET_68881"
2954   "*
2955 {
2956   return (TARGET_68040_ONLY
2957           ? \"fsmul%.w %2,%0\"
2958           : \"fsglmul%.w %2,%0\");
2959 }")
2960
2961 (define_insn ""
2962   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2963         (mult:SF (float:SF (match_operand:QI 2 "general_operand" "dmn"))
2964                  (match_operand:SF 1 "general_operand" "0")))]
2965   "TARGET_68881"
2966   "*
2967 {
2968   return (TARGET_68040_ONLY
2969           ? \"fsmul%.b %2,%0\"
2970           : \"fsglmul%.b %2,%0\");
2971 }")
2972
2973 (define_insn ""
2974   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2975         (mult:SF (match_operand:SF 1 "general_operand" "%0")
2976                  (match_operand:SF 2 "general_operand" "fdmF")))]
2977   "TARGET_68881"
2978   "*
2979 {
2980   if (REG_P (operands[2]) && ! DATA_REG_P (operands[2]))
2981     return (TARGET_68040_ONLY
2982             ? \"fsmul%.x %2,%0\"
2983             : \"fsglmul%.x %2,%0\");
2984   return (TARGET_68040_ONLY
2985           ? \"fsmul%.s %f2,%0\"
2986           : \"fsglmul%.s %f2,%0\");
2987 }")
2988 \f
2989 ;; divide instructions
2990
2991 (define_expand "divdf3"
2992   [(set (match_operand:DF 0 "nonimmediate_operand" "")
2993         (div:DF (match_operand:DF 1 "general_operand" "")
2994                 (match_operand:DF 2 "general_operand" "")))]
2995   "TARGET_68881"
2996   "")
2997
2998 (define_insn ""
2999   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
3000         (div:DF (match_operand:DF 1 "general_operand" "0")
3001                 (float:DF (match_operand:SI 2 "general_operand" "dmi"))))]
3002   "TARGET_68881"
3003   "f%&div%.l %2,%0")
3004
3005 (define_insn ""
3006   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
3007         (div:DF (match_operand:DF 1 "general_operand" "0")
3008                 (float:DF (match_operand:HI 2 "general_operand" "dmn"))))]
3009   "TARGET_68881"
3010   "f%&div%.w %2,%0")
3011
3012 (define_insn ""
3013   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
3014         (div:DF (match_operand:DF 1 "general_operand" "0")
3015                 (float:DF (match_operand:QI 2 "general_operand" "dmn"))))]
3016   "TARGET_68881"
3017   "f%&div%.b %2,%0")
3018
3019 (define_insn ""
3020   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
3021         (div:DF (match_operand:DF 1 "general_operand" "0")
3022                 (match_operand:DF 2 "general_operand" "fmG")))]
3023   "TARGET_68881"
3024   "*
3025 {
3026   if (REG_P (operands[2]))
3027     return \"f%&div%.x %2,%0\";
3028   return \"f%&div%.d %f2,%0\";
3029 }")
3030
3031 (define_expand "divsf3"
3032   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3033         (div:SF (match_operand:SF 1 "general_operand" "")
3034                 (match_operand:SF 2 "general_operand" "")))]
3035   "TARGET_68881"
3036   "")
3037
3038 (define_insn ""
3039   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
3040         (div:SF (match_operand:SF 1 "general_operand" "0")
3041                 (float:SF (match_operand:SI 2 "general_operand" "dmi"))))]
3042   "TARGET_68881"
3043   "*
3044 {
3045   return (TARGET_68040_ONLY
3046           ? \"fsdiv%.l %2,%0\"
3047           : \"fsgldiv%.l %2,%0\");
3048 }")
3049
3050 (define_insn ""
3051   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
3052         (div:SF (match_operand:SF 1 "general_operand" "0")
3053                 (float:SF (match_operand:HI 2 "general_operand" "dmn"))))]
3054   "TARGET_68881"
3055   "*
3056 {
3057   return (TARGET_68040_ONLY
3058           ? \"fsdiv%.w %2,%0\"
3059           : \"fsgldiv%.w %2,%0\");
3060 }")
3061
3062 (define_insn ""
3063   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
3064         (div:SF (match_operand:SF 1 "general_operand" "0")
3065                 (float:SF (match_operand:QI 2 "general_operand" "dmn"))))]
3066   "TARGET_68881"
3067   "*
3068 {
3069   return (TARGET_68040_ONLY
3070           ? \"fsdiv%.b %2,%0\"
3071           : \"fsgldiv%.b %2,%0\");
3072 }")
3073
3074 (define_insn ""
3075   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
3076         (div:SF (match_operand:SF 1 "general_operand" "0")
3077                 (match_operand:SF 2 "general_operand" "fdmF")))]
3078   "TARGET_68881"
3079   "*
3080 {
3081   if (REG_P (operands[2]) && ! DATA_REG_P (operands[2]))
3082     return (TARGET_68040_ONLY
3083             ? \"fsdiv%.x %2,%0\"
3084             : \"fsgldiv%.x %2,%0\");
3085   return (TARGET_68040_ONLY
3086           ? \"fsdiv%.s %f2,%0\"
3087           : \"fsgldiv%.s %f2,%0\");
3088 }")
3089 \f
3090 ;; Remainder instructions.
3091
3092 (define_expand "divmodsi4"
3093   [(parallel
3094     [(set (match_operand:SI 0 "nonimmediate_operand" "")
3095           (div:SI (match_operand:SI 1 "general_operand" "")
3096                   (match_operand:SI 2 "general_src_operand" "")))
3097      (set (match_operand:SI 3 "nonimmediate_operand" "")
3098           (mod:SI (match_dup 1) (match_dup 2)))])]
3099   "TARGET_68020 || TARGET_CF_HWDIV"
3100   "")
3101
3102 (define_insn ""
3103   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3104         (div:SI (match_operand:SI 1 "general_operand" "0")
3105                 (match_operand:SI 2 "general_src_operand" "d<Q>U")))
3106    (set (match_operand:SI 3 "nonimmediate_operand" "=&d")
3107         (mod:SI (match_dup 1) (match_dup 2)))]
3108   "TARGET_CF_HWDIV"
3109   "*
3110 {
3111   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3112     return \"divs%.l %2,%0\";
3113   else if (find_reg_note (insn, REG_UNUSED, operands[0]))
3114     return \"rems%.l %2,%3:%0\";
3115   else
3116     return \"rems%.l %2,%3:%0\;divs%.l %2,%0\";
3117 }")
3118
3119 (define_insn ""
3120   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3121         (div:SI (match_operand:SI 1 "general_operand" "0")
3122                 (match_operand:SI 2 "general_src_operand" "dmSTK")))
3123    (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3124         (mod:SI (match_dup 1) (match_dup 2)))]
3125   "TARGET_68020"
3126   "*
3127 {
3128   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3129     return \"divs%.l %2,%0\";
3130   else
3131     return \"divsl%.l %2,%3:%0\";
3132 }")
3133
3134 (define_expand "udivmodsi4"
3135   [(parallel
3136     [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3137           (udiv:SI (match_operand:SI 1 "general_operand" "0")
3138                    (match_operand:SI 2 "general_src_operand" "dmSTK")))
3139      (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3140           (umod:SI (match_dup 1) (match_dup 2)))])]
3141   "TARGET_68020 || TARGET_CF_HWDIV"
3142   "")
3143
3144 (define_insn ""
3145   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3146         (udiv:SI (match_operand:SI 1 "general_operand" "0")
3147                  (match_operand:SI 2 "general_src_operand" "d<Q>U")))
3148    (set (match_operand:SI 3 "nonimmediate_operand" "=&d")
3149         (umod:SI (match_dup 1) (match_dup 2)))]
3150   "TARGET_CF_HWDIV"
3151   "*
3152 {
3153   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3154     return \"divu%.l %2,%0\";
3155   else if (find_reg_note (insn, REG_UNUSED, operands[0]))
3156     return \"remu%.l %2,%3:%0\";
3157   else
3158     return \"remu%.l %2,%3:%0\;divu%.l %2,%0\";
3159 }")
3160
3161 (define_insn ""
3162   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3163         (udiv:SI (match_operand:SI 1 "general_operand" "0")
3164                  (match_operand:SI 2 "general_src_operand" "dmSTK")))
3165    (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3166         (umod:SI (match_dup 1) (match_dup 2)))]
3167   "TARGET_68020 && !TARGET_COLDFIRE"
3168   "*
3169 {
3170   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3171     return \"divu%.l %2,%0\";
3172   else
3173     return \"divul%.l %2,%3:%0\";
3174 }")
3175
3176 (define_insn "divmodhi4"
3177   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
3178         (div:HI (match_operand:HI 1 "general_operand" "0")
3179                 (match_operand:HI 2 "general_src_operand" "dmSKT")))
3180    (set (match_operand:HI 3 "nonimmediate_operand" "=d")
3181         (mod:HI (match_dup 1) (match_dup 2)))]
3182   "!TARGET_COLDFIRE || TARGET_CF_HWDIV"
3183   "*
3184 {
3185 #ifdef MOTOROLA
3186   output_asm_insn (\"ext%.l %0\;divs%.w %2,%0\", operands);
3187 #else
3188   output_asm_insn (\"extl %0\;divs %2,%0\", operands);
3189 #endif
3190   if (!find_reg_note(insn, REG_UNUSED, operands[3]))
3191     {
3192       CC_STATUS_INIT;
3193       return \"move%.l %0,%3\;swap %3\";
3194     }
3195   else
3196     return \"\";
3197 }")
3198
3199 (define_insn "udivmodhi4"
3200   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
3201         (udiv:HI (match_operand:HI 1 "general_operand" "0")
3202                  (match_operand:HI 2 "general_src_operand" "dmSKT")))
3203    (set (match_operand:HI 3 "nonimmediate_operand" "=d")
3204         (umod:HI (match_dup 1) (match_dup 2)))]
3205   "!TARGET_COLDFIRE || TARGET_CF_HWDIV"
3206   "*
3207 {
3208 #ifdef MOTOROLA
3209   output_asm_insn (\"and%.l %#0xFFFF,%0\;divu%.w %2,%0\", operands);
3210 #else
3211   output_asm_insn (\"and%.l %#0xFFFF,%0\;divu %2,%0\", operands);
3212 #endif
3213   if (!find_reg_note(insn, REG_UNUSED, operands[3]))
3214     {
3215       CC_STATUS_INIT;
3216       return \"move%.l %0,%3\;swap %3\";
3217     }
3218   else
3219     return \"\";
3220 }")
3221 \f
3222 ;; logical-and instructions
3223
3224 ;; "anddi3" is mainly here to help combine().
3225 (define_insn "anddi3"
3226   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3227         (and:DI (match_operand:DI 1 "general_operand" "%0,0")
3228                 (match_operand:DI 2 "general_operand" "dn,don")))]
3229   "!TARGET_COLDFIRE"
3230   "*
3231 {
3232   CC_STATUS_INIT;
3233   /* We can get CONST_DOUBLE, but also const1_rtx etc.  */
3234   if (CONSTANT_P (operands[2]))
3235     {
3236       rtx hi, lo;
3237
3238       split_double (operands[2], &hi, &lo);
3239
3240       switch (INTVAL (hi))
3241         {
3242           case 0 :
3243             output_asm_insn (\"clr%.l %0\", operands);
3244             break;
3245           case -1 :
3246             break;
3247           default :
3248             {
3249             rtx xoperands[3];
3250
3251             xoperands[0] = operands[0];
3252             xoperands[2] = hi;
3253             output_asm_insn (output_andsi3 (xoperands), xoperands);
3254             }
3255         }
3256       if (GET_CODE (operands[0]) == REG)
3257         operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3258       else
3259         operands[0] = adjust_address (operands[0], SImode, 4);
3260       switch (INTVAL (lo))
3261         {
3262           case 0 :
3263             output_asm_insn (\"clr%.l %0\", operands);
3264             break;
3265           case -1 :
3266             break;
3267           default :
3268             {
3269             rtx xoperands[3];
3270
3271             xoperands[0] = operands[0];
3272             xoperands[2] = lo;
3273             output_asm_insn (output_andsi3 (xoperands), xoperands);
3274             }
3275         }
3276       return \"\";
3277     }
3278   if (GET_CODE (operands[0]) != REG)
3279     {
3280       operands[1] = adjust_address (operands[0], SImode, 4);
3281       return \"and%.l %2,%0\;and%.l %R2,%1\";
3282     }
3283   if (GET_CODE (operands[2]) != REG)
3284     {
3285       operands[1] = adjust_address (operands[2], SImode, 4);
3286       return \"and%.l %2,%0\;and%.l %1,%R0\";
3287     }
3288   return \"and%.l %2,%0\;and%.l %R2,%R0\";
3289 }")
3290
3291 ;; Prevent AND from being made with sp.  This doesn't exist in the machine
3292 ;; and reload will cause inefficient code.  Since sp is a FIXED_REG, we
3293 ;; can't allocate pseudos into it.
3294
3295 (define_expand "andsi3"
3296   [(set (match_operand:SI 0 "not_sp_operand" "")
3297         (and:SI (match_operand:SI 1 "general_operand" "")
3298                 (match_operand:SI 2 "general_src_operand" "")))]
3299   ""
3300   "")
3301
3302 (define_insn "andsi3_internal"
3303   [(set (match_operand:SI 0 "not_sp_operand" "=m,d")
3304         (and:SI (match_operand:SI 1 "general_operand" "%0,0")
3305                 (match_operand:SI 2 "general_src_operand" "dKT,dmSM")))]
3306   "!TARGET_COLDFIRE"
3307   "*
3308 {
3309   return output_andsi3 (operands);
3310 }")
3311
3312 (define_insn "andsi3_5200"
3313   [(set (match_operand:SI 0 "not_sp_operand" "=m,d")
3314         (and:SI (match_operand:SI 1 "general_operand" "%0,0")
3315                 (match_operand:SI 2 "general_src_operand" "d,dmsK")))]
3316   "TARGET_COLDFIRE"
3317   "and%.l %2,%0")
3318
3319 (define_insn "andhi3"
3320   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,d")
3321         (and:HI (match_operand:HI 1 "general_operand" "%0,0")
3322                 (match_operand:HI 2 "general_src_operand" "dn,dmSn")))]
3323   "!TARGET_COLDFIRE"
3324   "and%.w %2,%0")
3325
3326 (define_insn ""
3327   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3328         (and:HI (match_dup 0)
3329                 (match_operand:HI 1 "general_src_operand" "dn,dmSn")))]
3330   "!TARGET_COLDFIRE"
3331   "and%.w %1,%0")
3332
3333 (define_insn ""
3334   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3335         (and:HI (match_operand:HI 1 "general_src_operand" "dn,dmSn")
3336                 (match_dup 0)))]
3337   "!TARGET_COLDFIRE"
3338   "and%.w %1,%0")
3339
3340 (define_insn "andqi3"
3341   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
3342         (and:QI (match_operand:QI 1 "general_operand" "%0,0")
3343                 (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
3344   "!TARGET_COLDFIRE"
3345   "and%.b %2,%0")
3346
3347 (define_insn ""
3348   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3349         (and:QI (match_dup 0)
3350                 (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
3351   "!TARGET_COLDFIRE"
3352   "and%.b %1,%0")
3353
3354 (define_insn ""
3355   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3356         (and:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
3357                 (match_dup 0)))]
3358   "!TARGET_COLDFIRE"
3359   "and%.b %1,%0")
3360 \f
3361 ;; inclusive-or instructions
3362
3363 (define_insn "iordi_zext"
3364   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3365     (ior:DI (zero_extend:DI (match_operand 1 "general_operand" "dn,dmn"))
3366         (match_operand:DI 2 "general_operand" "0,0")))]
3367   "!TARGET_COLDFIRE"
3368   "*
3369 {
3370   int byte_mode;
3371
3372   CC_STATUS_INIT;
3373   if (GET_CODE (operands[0]) == REG)
3374     operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3375   else
3376     operands[0] = adjust_address (operands[0], SImode, 4);
3377   if (GET_MODE (operands[1]) == SImode)
3378     return \"or%.l %1,%0\";
3379   byte_mode = (GET_MODE (operands[1]) == QImode);
3380   if (GET_CODE (operands[0]) == MEM)
3381     operands[0] = adjust_address (operands[0], byte_mode ? QImode : HImode,
3382                                   byte_mode ? 3 : 2);
3383   if (byte_mode)
3384     return \"or%.b %1,%0\";
3385   else
3386     return \"or%.w %1,%0\";
3387 }")
3388
3389 ;; "iordi3" is mainly here to help combine().
3390 (define_insn "iordi3"
3391   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3392         (ior:DI (match_operand:DI 1 "general_operand" "%0,0")
3393                 (match_operand:DI 2 "general_operand" "dn,don")))]
3394   "!TARGET_COLDFIRE"
3395   "*
3396 {
3397   CC_STATUS_INIT;
3398   /* We can get CONST_DOUBLE, but also const1_rtx etc.  */
3399   if (CONSTANT_P (operands[2]))
3400     {
3401       rtx hi, lo;
3402
3403       split_double (operands[2], &hi, &lo);
3404
3405       switch (INTVAL (hi))
3406         {
3407           case 0 :
3408             break;
3409           case -1 :
3410             /* FIXME : a scratch register would be welcome here if operand[0]
3411                is not a register */
3412             output_asm_insn (\"move%.l %#-1,%0\", operands);
3413             break;
3414           default :
3415             {
3416             rtx xoperands[3];
3417
3418             xoperands[0] = operands[0];
3419             xoperands[2] = hi;
3420             output_asm_insn (output_iorsi3 (xoperands), xoperands);
3421             }
3422         }
3423       if (GET_CODE (operands[0]) == REG)
3424         operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3425       else
3426         operands[0] = adjust_address (operands[0], SImode, 4);
3427       switch (INTVAL (lo))
3428         {
3429           case 0 :
3430             break;
3431           case -1 :
3432             /* FIXME : a scratch register would be welcome here if operand[0]
3433                is not a register */
3434             output_asm_insn (\"move%.l %#-1,%0\", operands);
3435             break;
3436           default :
3437             {
3438             rtx xoperands[3];
3439
3440             xoperands[0] = operands[0];
3441             xoperands[2] = lo;
3442             output_asm_insn (output_iorsi3 (xoperands), xoperands);
3443             }
3444         }
3445       return \"\";
3446     }
3447   if (GET_CODE (operands[0]) != REG)
3448     {
3449       operands[1] = adjust_address (operands[0], SImode, 4);
3450       return \"or%.l %2,%0\;or%.l %R2,%1\";
3451     }
3452   if (GET_CODE (operands[2]) != REG)
3453     {
3454       operands[1] = adjust_address (operands[2], SImode, 4);
3455       return \"or%.l %2,%0\;or%.l %1,%R0\";
3456     }
3457   return \"or%.l %2,%0\;or%.l %R2,%R0\";
3458 }")
3459
3460 (define_expand "iorsi3"
3461   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3462         (ior:SI (match_operand:SI 1 "general_operand" "")
3463                 (match_operand:SI 2 "general_src_operand" "")))]
3464   ""
3465   "")
3466
3467 (define_insn "iorsi3_internal"
3468   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d")
3469         (ior:SI (match_operand:SI 1