OSDN Git Service

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