OSDN Git Service

c312bfb27d1535724c5cf0b83b2545a925a39fd9
[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 ;;- TUNE_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 TUNE_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 (TUNE_68040_60)
622         return MOTOROLA ? "lea 0.w,%0" : "lea 0:w,%0";
623       else
624         return "sub%.l %0,%0";
625     }
626   /* moveq is faster on the 68000.  */
627   if (DATA_REG_P (operands[0]) && TUNE_68000_10)
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_ISAB"
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_ISAB"
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 (TUNE_68040_60)
850             return MOTOROLA ? "lea 0.w,%0" : "lea 0:w,%0";
851           else
852             return "sub%.l %0,%0";
853         }
854       /* moveq is faster on the 68000.  */
855       if (DATA_REG_P (operands[0]) && TUNE_68000_10)
856         return "moveq #0,%0";
857       return "clr%.l %0";
858     }
859   return "move%.l %1,%0";
860 })
861
862 (define_insn "movsf_cf_soft"
863   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,g")
864         (match_operand:SF 1 "general_operand" "g,r"))]
865   "TARGET_COLDFIRE && !TARGET_COLDFIRE_FPU"
866 {
867   return "move%.l %1,%0";
868 })
869
870 (define_insn "movsf_cf_hard"
871   [(set (match_operand:SF 0 "nonimmediate_operand" "=r<Q>U, f,    f,mr,f,r<Q>,f
872 ,m")
873         (match_operand:SF 1 "general_operand"      " f,     r<Q>U,f,rm,F,F,   m
874 ,f"))]
875   "TARGET_COLDFIRE_FPU"
876 {
877   if (which_alternative == 4 || which_alternative == 5) {
878     rtx xoperands[2];
879     REAL_VALUE_TYPE r;
880     long l;
881     REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
882     REAL_VALUE_TO_TARGET_SINGLE (r, l);
883     xoperands[0] = operands[0];
884     xoperands[1] = GEN_INT (l);
885     if (which_alternative == 5) {
886       if (l == 0) {
887         if (ADDRESS_REG_P (xoperands[0]))
888           output_asm_insn ("sub%.l %0,%0", xoperands);
889         else
890           output_asm_insn ("clr%.l %0", xoperands);
891       } else
892         if (GET_CODE (operands[0]) == MEM
893             && symbolic_operand (XEXP (operands[0], 0), SImode))
894           output_asm_insn ("move%.l %1,%-;move%.l %+,%0", xoperands);
895         else
896           output_asm_insn ("move%.l %1,%0", xoperands);
897       return "";
898     }
899     if (l != 0)
900       output_asm_insn ("move%.l %1,%-;fsmove%.s %+,%0", xoperands);
901     else
902       output_asm_insn ("clr%.l %-;fsmove%.s %+,%0", xoperands);
903     return "";
904   }
905   if (FP_REG_P (operands[0]))
906     {
907       if (ADDRESS_REG_P (operands[1]))
908         return "move%.l %1,%-;f%$smove%.s %+,%0";
909       if (FP_REG_P (operands[1]))
910         return "f%$move%.d %1,%0";
911       if (GET_CODE (operands[1]) == CONST_DOUBLE)
912         return output_move_const_single (operands);
913       return "f%$move%.s %f1,%0";
914     }
915   if (FP_REG_P (operands[1]))
916     {
917       if (ADDRESS_REG_P (operands[0]))
918         return "fmove%.s %1,%-;move%.l %+,%0";
919       return "fmove%.s %f1,%0";
920     }
921   if (operands[1] == CONST0_RTX (SFmode))
922     {
923       if (ADDRESS_REG_P (operands[0]))
924         return "sub%.l %0,%0";
925       return "clr%.l %0";
926     }
927   return "move%.l %1,%0";
928 })
929
930 (define_expand "reload_indf"
931   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
932         (match_operand:DF 1 "general_operand" "mf"))
933    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
934   "TARGET_COLDFIRE_FPU"
935 {
936   if (emit_move_sequence (operands, DFmode, operands[2]))
937     DONE;
938
939   /* We don't want the clobber emitted, so handle this ourselves. */
940   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
941   DONE;
942 })
943
944 (define_expand "reload_outdf"
945   [(set (match_operand:DF 0 "general_operand" "")
946         (match_operand:DF 1 "register_operand" "f"))
947    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
948   "TARGET_COLDFIRE_FPU"
949 {
950   if (emit_move_sequence (operands, DFmode, operands[2]))
951     DONE;
952
953   /* We don't want the clobber emitted, so handle this ourselves. */
954   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
955   DONE;
956 })
957
958 (define_expand "movdf"
959   [(set (match_operand:DF 0 "nonimmediate_operand" "")
960         (match_operand:DF 1 "general_operand" ""))]
961   ""
962 {
963   if (TARGET_COLDFIRE_FPU)
964     if (emit_move_sequence (operands, DFmode, 0))
965       DONE;
966 })
967
968 (define_insn ""
969   [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,rf,rf,&rof<>")
970         (match_operand:DF 1 "general_operand" "*rf,m,0,*rofE<>"))]
971 ;  [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,&rf,&rof<>")
972 ;       (match_operand:DF 1 "general_operand" "rf,m,rofF<>"))]
973   "!TARGET_COLDFIRE"
974 {
975   if (FP_REG_P (operands[0]))
976     {
977       if (FP_REG_P (operands[1]))
978         return "f%&move%.x %1,%0";
979       if (REG_P (operands[1]))
980         {
981           rtx xoperands[2];
982           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
983           output_asm_insn ("move%.l %1,%-", xoperands);
984           output_asm_insn ("move%.l %1,%-", operands);
985           return "f%&move%.d %+,%0";
986         }
987       if (GET_CODE (operands[1]) == CONST_DOUBLE)
988         return output_move_const_double (operands);
989       return "f%&move%.d %f1,%0";
990     }
991   else if (FP_REG_P (operands[1]))
992     {
993       if (REG_P (operands[0]))
994         {
995           output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
996           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
997           return "move%.l %+,%0";
998         }
999       else
1000         return "fmove%.d %f1,%0";
1001     }
1002   return output_move_double (operands);
1003 })
1004
1005 (define_insn "movdf_cf_soft"
1006   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,g")
1007         (match_operand:DF 1 "general_operand" "g,r"))]
1008   "TARGET_COLDFIRE && !TARGET_COLDFIRE_FPU"
1009 {
1010   return output_move_double (operands);
1011 })
1012
1013 (define_insn "movdf_cf_hard"
1014   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,    <Q>U,r,f,r,r,m,f")
1015         (match_operand:DF 1 "general_operand"      " f<Q>U,f,   f,r,r,m,r,E"))]
1016   "TARGET_COLDFIRE_FPU"
1017 {
1018   rtx xoperands[3];
1019   REAL_VALUE_TYPE r;
1020   long l[2];
1021
1022   switch (which_alternative)
1023     {
1024     default:
1025       return "fmove%.d %1,%0";
1026     case 2:
1027       return "fmove%.d %1,%-;move%.l %+,%0;move%.l %+,%R0";
1028     case 3:
1029       return "move%.l %R1,%-;move%.l %1,%-;f%&move%.d %+,%0";
1030     case 4:
1031       return "move%.l %1,%0;move%.l %R1,%R0";
1032     case 5: case 6:
1033       return output_move_double (operands);
1034     case 7:
1035       REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
1036       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
1037       xoperands[0] = operands[0];
1038       xoperands[1] = GEN_INT (l[0]);
1039       xoperands[2] = GEN_INT (l[1]);
1040       if (operands[1] == CONST0_RTX (DFmode))
1041         output_asm_insn ("clr%.l %-;clr%.l %-;fdmove%.d %+,%0",
1042                         xoperands);
1043       else
1044         if (l[1] == 0)
1045           output_asm_insn ("clr%.l %-;move%.l %1,%-;fdmove%.d %+,%0",
1046                           xoperands);
1047         else
1048           output_asm_insn ("move%.l %2,%-;move%.l %1,%-;fdmove%.d %+,%0",
1049                           xoperands);
1050       return "";
1051     }
1052 })
1053
1054 ;; ??? The XFmode patterns are schizophrenic about whether constants are
1055 ;; allowed.  Most but not all have predicates and constraint that disallow
1056 ;; constants.  Most but not all have output templates that handle constants.
1057 ;; See also LEGITIMATE_CONSTANT_P.
1058
1059 (define_expand "movxf"
1060   [(set (match_operand:XF 0 "nonimmediate_operand" "")
1061         (match_operand:XF 1 "general_operand" ""))]
1062   ""
1063 {
1064   /* We can't rewrite operands during reload.  */
1065   if (! reload_in_progress)
1066     {
1067       if (CONSTANT_P (operands[1]))
1068         {
1069           operands[1] = force_const_mem (XFmode, operands[1]);
1070           if (! memory_address_p (XFmode, XEXP (operands[1], 0)))
1071             operands[1] = adjust_address (operands[1], XFmode, 0);
1072         }
1073       if (flag_pic && TARGET_PCREL)
1074         {
1075           /* Don't allow writes to memory except via a register; the
1076              m68k doesn't consider PC-relative addresses to be writable.  */
1077           if (GET_CODE (operands[0]) == MEM
1078               && symbolic_operand (XEXP (operands[0], 0), SImode))
1079             operands[0] = gen_rtx_MEM (XFmode,
1080                                    force_reg (SImode, XEXP (operands[0], 0)));
1081         }
1082     }
1083 })
1084
1085 (define_insn ""
1086   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,!r,!f,!r,m,!r")
1087         (match_operand:XF 1 "nonimmediate_operand" "m,f,f,f,r,!r,!r,m"))]
1088   "TARGET_68881"
1089 {
1090   if (FP_REG_P (operands[0]))
1091     {
1092       if (FP_REG_P (operands[1]))
1093         return "fmove%.x %1,%0";
1094       if (REG_P (operands[1]))
1095         {
1096           rtx xoperands[2];
1097           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1098           output_asm_insn ("move%.l %1,%-", xoperands);
1099           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1100           output_asm_insn ("move%.l %1,%-", xoperands);
1101           output_asm_insn ("move%.l %1,%-", operands);
1102           return "fmove%.x %+,%0";
1103         }
1104       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1105         return "fmove%.x %1,%0";
1106       return "fmove%.x %f1,%0";
1107     }
1108   if (FP_REG_P (operands[1]))
1109     {
1110       if (REG_P (operands[0]))
1111         {
1112           output_asm_insn ("fmove%.x %f1,%-\;move%.l %+,%0", operands);
1113           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1114           output_asm_insn ("move%.l %+,%0", operands);
1115           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1116           return "move%.l %+,%0";
1117         }
1118       /* Must be memory destination.  */
1119       return "fmove%.x %f1,%0";
1120     }
1121   return output_move_double (operands);
1122 })
1123
1124 (define_insn ""
1125   [(set (match_operand:XF 0 "nonimmediate_operand" "=rm,rf,&rof<>")
1126         (match_operand:XF 1 "nonimmediate_operand" "rf,m,rof<>"))]
1127   "! TARGET_68881 && ! TARGET_COLDFIRE"
1128 {
1129   if (FP_REG_P (operands[0]))
1130     {
1131       if (FP_REG_P (operands[1]))
1132         return "fmove%.x %1,%0";
1133       if (REG_P (operands[1]))
1134         {
1135           rtx xoperands[2];
1136           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1137           output_asm_insn ("move%.l %1,%-", xoperands);
1138           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1139           output_asm_insn ("move%.l %1,%-", xoperands);
1140           output_asm_insn ("move%.l %1,%-", operands);
1141           return "fmove%.x %+,%0";
1142         }
1143       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1144         return "fmove%.x %1,%0";
1145       return "fmove%.x %f1,%0";
1146     }
1147   if (FP_REG_P (operands[1]))
1148     {
1149       if (REG_P (operands[0]))
1150         {
1151           output_asm_insn ("fmove%.x %f1,%-\;move%.l %+,%0", operands);
1152           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1153           output_asm_insn ("move%.l %+,%0", operands);
1154           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1155           return "move%.l %+,%0";
1156         }
1157       else
1158         return "fmove%.x %f1,%0";
1159     }
1160   return output_move_double (operands);
1161 })
1162
1163 (define_insn ""
1164   [(set (match_operand:XF 0 "nonimmediate_operand" "=r,g")
1165         (match_operand:XF 1 "nonimmediate_operand" "g,r"))]
1166   "! TARGET_68881 && TARGET_COLDFIRE"
1167   "* return output_move_double (operands);")
1168
1169 (define_expand "movdi"
1170   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1171   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1172         (match_operand:DI 1 "general_operand" ""))]
1173   ""
1174   "")
1175
1176 ;; movdi can apply to fp regs in some cases
1177 (define_insn ""
1178   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1179   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,r,&ro<>")
1180         (match_operand:DI 1 "general_operand" "rF,m,roi<>F"))]
1181 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&r,&ro<>,!&rm,!&f")
1182 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF"))]
1183 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&rf,&ro<>,!&rm,!&f")
1184 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF,rfF"))]
1185   "!TARGET_COLDFIRE"
1186 {
1187   if (FP_REG_P (operands[0]))
1188     {
1189       if (FP_REG_P (operands[1]))
1190         return "fmove%.x %1,%0";
1191       if (REG_P (operands[1]))
1192         {
1193           rtx xoperands[2];
1194           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1195           output_asm_insn ("move%.l %1,%-", xoperands);
1196           output_asm_insn ("move%.l %1,%-", operands);
1197           return "fmove%.d %+,%0";
1198         }
1199       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1200         return output_move_const_double (operands);
1201       return "fmove%.d %f1,%0";
1202     }
1203   else if (FP_REG_P (operands[1]))
1204     {
1205       if (REG_P (operands[0]))
1206         {
1207           output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
1208           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1209           return "move%.l %+,%0";
1210         }
1211       else
1212         return "fmove%.d %f1,%0";
1213     }
1214   return output_move_double (operands);
1215 })
1216
1217 (define_insn ""
1218   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,g")
1219         (match_operand:DI 1 "general_operand" "g,r"))]
1220   "TARGET_COLDFIRE"
1221   "* return output_move_double (operands);")
1222
1223 ;; Thus goes after the move instructions
1224 ;; because the move instructions are better (require no spilling)
1225 ;; when they can apply.  It goes before the add/sub insns
1226 ;; so we will prefer it to them.
1227
1228 (define_insn "pushasi"
1229   [(set (match_operand:SI 0 "push_operand" "=m")
1230         (match_operand:SI 1 "address_operand" "p"))]
1231   ""
1232   "pea %a1")
1233 \f
1234 ;; truncation instructions
1235 (define_insn "truncsiqi2"
1236   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1237         (truncate:QI
1238          (match_operand:SI 1 "general_src_operand" "doJS,i")))]
1239   ""
1240 {
1241   if (GET_CODE (operands[0]) == REG)
1242     {
1243       /* Must clear condition codes, since the move.l bases them on
1244          the entire 32 bits, not just the desired 8 bits.  */
1245       CC_STATUS_INIT;
1246       return "move%.l %1,%0";
1247     }
1248   if (GET_CODE (operands[1]) == MEM)
1249     operands[1] = adjust_address (operands[1], QImode, 3);
1250   return "move%.b %1,%0";
1251 })
1252
1253 (define_insn "trunchiqi2"
1254   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1255         (truncate:QI
1256          (match_operand:HI 1 "general_src_operand" "doJS,i")))]
1257   ""
1258 {
1259   if (GET_CODE (operands[0]) == REG
1260       && (GET_CODE (operands[1]) == MEM
1261           || GET_CODE (operands[1]) == CONST_INT))
1262     {
1263       /* Must clear condition codes, since the move.w bases them on
1264          the entire 16 bits, not just the desired 8 bits.  */
1265       CC_STATUS_INIT;
1266       return "move%.w %1,%0";
1267     }
1268   if (GET_CODE (operands[0]) == REG)
1269     {
1270       /* Must clear condition codes, since the move.l bases them on
1271          the entire 32 bits, not just the desired 8 bits.  */
1272       CC_STATUS_INIT;
1273       return "move%.l %1,%0";
1274     }
1275   if (GET_CODE (operands[1]) == MEM)
1276     operands[1] = adjust_address (operands[1], QImode, 1);
1277   return "move%.b %1,%0";
1278 })
1279
1280 (define_insn "truncsihi2"
1281   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm,d")
1282         (truncate:HI
1283          (match_operand:SI 1 "general_src_operand" "roJS,i")))]
1284   ""
1285 {
1286   if (GET_CODE (operands[0]) == REG)
1287     {
1288       /* Must clear condition codes, since the move.l bases them on
1289          the entire 32 bits, not just the desired 8 bits.  */
1290       CC_STATUS_INIT;
1291       return "move%.l %1,%0";
1292     }
1293   if (GET_CODE (operands[1]) == MEM)
1294     operands[1] = adjust_address (operands[1], QImode, 2);
1295   return "move%.w %1,%0";
1296 })
1297 \f
1298 ;; zero extension instructions
1299
1300 ;; two special patterns to match various post_inc/pre_dec patterns
1301 (define_insn_and_split "*zero_extend_inc"
1302   [(set (match_operand 0 "post_inc_operand" "")
1303         (zero_extend (match_operand 1 "register_operand" "")))]
1304   "GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT &&
1305    GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT &&
1306    GET_MODE_SIZE (GET_MODE (operands[0])) == GET_MODE_SIZE (GET_MODE (operands[1])) * 2"
1307   "#"
1308   ""
1309   [(set (match_dup 0)
1310         (const_int 0))
1311    (set (match_dup 0)
1312         (match_dup 1))]
1313 {
1314   operands[0] = adjust_address (operands[0], GET_MODE (operands[1]), 0);
1315 })
1316
1317 (define_insn_and_split "*zero_extend_dec"
1318   [(set (match_operand 0 "pre_dec_operand" "")
1319         (zero_extend (match_operand 1 "register_operand" "")))]
1320   "(GET_MODE (operands[0]) != HImode || XEXP (XEXP (operands[0], 0), 0) != stack_pointer_rtx) &&
1321    GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT &&
1322    GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT &&
1323    GET_MODE_SIZE (GET_MODE (operands[0])) == GET_MODE_SIZE (GET_MODE (operands[1])) * 2"
1324   "#"
1325   ""
1326   [(set (match_dup 0)
1327         (match_dup 1))
1328    (set (match_dup 0)
1329         (const_int 0))]
1330 {
1331   operands[0] = adjust_address (operands[0], GET_MODE (operands[1]), 0);
1332 })
1333
1334 (define_insn_and_split "zero_extendqidi2"
1335   [(set (match_operand:DI 0 "register_operand" "")
1336         (zero_extend:DI (match_operand:QI 1 "nonimmediate_src_operand" "")))]
1337   ""
1338   "#"
1339   ""
1340   [(set (match_dup 2)
1341         (zero_extend:SI (match_dup 1)))
1342    (set (match_dup 3)
1343         (const_int 0))]
1344 {
1345   operands[2] = gen_lowpart (SImode, operands[0]);
1346   operands[3] = gen_highpart (SImode, operands[0]);
1347 })
1348
1349 (define_insn_and_split "zero_extendhidi2"
1350   [(set (match_operand:DI 0 "register_operand" "")
1351         (zero_extend:DI (match_operand:HI 1 "nonimmediate_src_operand" "")))]
1352   ""
1353   "#"
1354   ""
1355   [(set (match_dup 2)
1356         (zero_extend:SI (match_dup 1)))
1357    (set (match_dup 3)
1358         (const_int 0))]
1359 {
1360   operands[2] = gen_lowpart (SImode, operands[0]);
1361   operands[3] = gen_highpart (SImode, operands[0]);
1362 })
1363
1364 (define_expand "zero_extendsidi2"
1365   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1366         (zero_extend:DI (match_operand:SI 1 "nonimmediate_src_operand" "")))]
1367   ""
1368 {
1369   if (GET_CODE (operands[0]) == MEM
1370       && GET_CODE (operands[1]) == MEM)
1371     operands[1] = force_reg (SImode, operands[1]);
1372 })
1373
1374 (define_insn_and_split "*zero_extendsidi2"
1375   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1376         (zero_extend:DI (match_operand:SI 1 "nonimmediate_src_operand" "")))]
1377   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
1378   "#"
1379   ""
1380   [(set (match_dup 2)
1381         (match_dup 1))
1382    (set (match_dup 3)
1383         (const_int 0))]
1384 {
1385   operands[2] = gen_lowpart (SImode, operands[0]);
1386   operands[3] = gen_highpart (SImode, operands[0]);
1387 })
1388
1389 (define_insn "*zero_extendhisi2_cf"
1390   [(set (match_operand:SI 0 "register_operand" "=d")
1391         (zero_extend:SI (match_operand:HI 1 "nonimmediate_src_operand" "rmS")))]
1392   "TARGET_ISAB"
1393   "mvz%.w %1,%0")
1394
1395 (define_insn "zero_extendhisi2"
1396   [(set (match_operand:SI 0 "register_operand" "=d")
1397         (zero_extend:SI (match_operand:HI 1 "nonimmediate_src_operand" "rmS")))]
1398   ""
1399   "#")
1400
1401 (define_expand "zero_extendqihi2"
1402   [(set (match_operand:HI 0 "register_operand" "")
1403         (zero_extend:HI (match_operand:QI 1 "nonimmediate_src_operand" "")))]
1404   "!TARGET_COLDFIRE"
1405   "")
1406
1407 (define_insn "*zero_extendqihi2"
1408   [(set (match_operand:HI 0 "register_operand" "=d")
1409         (zero_extend:HI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1410   "!TARGET_COLDFIRE"
1411   "#")
1412
1413 (define_insn "*zero_extendqisi2_cfv4"
1414   [(set (match_operand:SI 0 "register_operand" "=d")
1415         (zero_extend:SI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1416   "TARGET_ISAB"
1417   "mvz%.b %1,%0")
1418
1419 (define_insn "zero_extendqisi2"
1420   [(set (match_operand:SI 0 "register_operand" "=d")
1421         (zero_extend:SI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1422   ""
1423   "#")
1424
1425 ;; these two pattern split everything else which isn't matched by
1426 ;; something else above
1427 (define_split
1428   [(set (match_operand 0 "register_operand" "")
1429         (zero_extend (match_operand 1 "nonimmediate_src_operand" "")))]
1430   "!TARGET_ISAB
1431    && reload_completed
1432    && 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_ISAB && 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_ISAB)
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_ISAB)
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_ISAB"
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_ISAB"
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_ISAB"
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_ISAB)"
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 && TUNE_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 && TUNE_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 && TUNE_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 && !TUNE_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 && !TUNE_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 (TUNE_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]) && !TUNE_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 (TUNE_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]) && !TUNE_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 (TUNE_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]) && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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 && !TUNE_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]) && !TUNE_68040_60)
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_ISAB)
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_ISAB
3224       && DATA_REG_P (operands[0])
3225       && GET_CODE (operands[2]) == CONST_INT)
3226     {
3227       if (INTVAL (operands[2]) == 0x000000ff)
3228         return "mvz%.b %0,%0";
3229       else if (INTVAL (operands[2]) == 0x0000ffff)
3230         return "mvz%.w %0,%0";
3231     }
3232   return output_andsi3 (operands);
3233 })
3234
3235 (define_insn "andhi3"
3236   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,d")
3237         (and:HI (match_operand:HI 1 "general_operand" "%0,0")
3238                 (match_operand:HI 2 "general_src_operand" "dn,dmSn")))]
3239   "!TARGET_COLDFIRE"
3240   "and%.w %2,%0")
3241
3242 (define_insn ""
3243   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3244         (and:HI (match_dup 0)
3245                 (match_operand:HI 1 "general_src_operand" "dn,dmSn")))]
3246   "!TARGET_COLDFIRE"
3247   "and%.w %1,%0")
3248
3249 (define_insn ""
3250   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3251         (and:HI (match_operand:HI 1 "general_src_operand" "dn,dmSn")
3252                 (match_dup 0)))]
3253   "!TARGET_COLDFIRE"
3254   "and%.w %1,%0")
3255
3256 (define_insn "andqi3"
3257   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
3258         (and:QI (match_operand:QI 1 "general_operand" "%0,0")
3259                 (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
3260   "!TARGET_COLDFIRE"
3261   "and%.b %2,%0")
3262
3263 (define_insn ""
3264   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3265         (and:QI (match_dup 0)
3266                 (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
3267   "!TARGET_COLDFIRE"
3268   "and%.b %1,%0")
3269
3270 (define_insn ""
3271   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3272         (and:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
3273                 (match_dup 0)))]
3274   "!TARGET_COLDFIRE"
3275   "and%.b %1,%0")
3276 \f
3277 ;; inclusive-or instructions
3278
3279 (define_insn "iordi_zext"
3280   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3281     (ior:DI (zero_extend:DI (match_operand 1 "general_operand" "dn,dmn"))
3282         (match_operand:DI 2 "general_operand" "0,0")))]
3283   "!TARGET_COLDFIRE"
3284 {
3285   int byte_mode;
3286
3287   CC_STATUS_INIT;
3288   if (GET_CODE (operands[0]) == REG)
3289     operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3290   else
3291     operands[0] = adjust_address (operands[0], SImode, 4);
3292   if (GET_MODE (operands[1]) == SImode)
3293     return "or%.l %1,%0";
3294   byte_mode = (GET_MODE (operands[1]) == QImode);
3295   if (GET_CODE (operands[0]) == MEM)
3296     operands[0] = adjust_address (operands[0], byte_mode ? QImode : HImode,
3297                                   byte_mode ? 3 : 2);
3298   if (byte_mode)
3299     return "or%.b %1,%0";
3300   else
3301     return "or%.w %1,%0";
3302 })
3303
3304 ;; "iordi3" is mainly here to help combine().
3305 (define_insn "iordi3"
3306   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3307         (ior:DI (match_operand:DI 1 "general_operand" "%0,0")
3308                 (match_operand:DI 2 "general_operand" "dn,don")))]
3309   "!TARGET_COLDFIRE"
3310 {
3311   CC_STATUS_INIT;
3312   /* We can get CONST_DOUBLE, but also const1_rtx etc.  */
3313   if (CONSTANT_P (operands[2]))
3314     {
3315       rtx hi, lo;
3316
3317       split_double (operands[2], &hi, &lo);
3318
3319       switch (INTVAL (hi))
3320         {
3321           case 0 :
3322             break;
3323           case -1 :
3324             /* FIXME : a scratch register would be welcome here if operand[0]
3325                is not a register */
3326             output_asm_insn ("move%.l #-1,%0", operands);
3327             break;
3328           default :
3329             {
3330             rtx xoperands[3];
3331
3332             xoperands[0] = operands[0];
3333             xoperands[2] = hi;
3334             output_asm_insn (output_iorsi3 (xoperands), xoperands);
3335             }
3336         }
3337       if (GET_CODE (operands[0]) == REG)
3338         operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3339       else
3340         operands[0] = adjust_address (operands[0], SImode, 4);
3341       switch (INTVAL (lo))
3342         {
3343           case 0 :
3344             break;
3345           case -1 :
3346             /* FIXME : a scratch register would be welcome here if operand[0]
3347                is not a register */
3348             output_asm_insn ("move%.l #-1,%0", operands);
3349             break;
3350           default :
3351             {
3352             rtx xoperands[3];
3353
3354             xoperands[0] = operands[0];
3355             xoperands[2] = lo;
3356             output_asm_insn (output_iorsi3 (xoperands), xoperands);
3357             }
3358         }
3359       return "";
3360     }
3361   if (GET_CODE (operands[0]) != REG)
3362     {
3363       operands[1] = adjust_address (operands[0], SImode, 4);
3364       return "or%.l %2,%0\;or%.l %R2,%1";
3365     }
3366   if (GET_CODE (operands[2]) != REG)
3367     {
3368       operands[1] = adjust_address (operands[2], SImode, 4);
3369       return "or%.l %2,%0\;or%.l %1,%R0";
3370     }
3371   return "or%.l %2,%0\;or%.l %R2,%R0";
3372 })
3373
3374 (define_expand "iorsi3"
3375   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3376         (ior:SI (match_operand:SI 1 "general_operand" "")
3377                 (match_operand:SI 2 "general_src_operand" "")))]
3378   ""
3379   "")
3380
3381 (define_insn "iorsi3_internal"
3382   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d")
3383         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
3384                 (match_operand:SI 2 "general_src_operand" "dKT,dmSMT")))]
3385   "! TARGET_COLDFIRE"
3386 {
3387   return output_iorsi3 (operands);
3388 })
3389
3390 (define_insn "iorsi3_5200"
3391   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d")
3392         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
3393                 (match_operand:SI 2 "general_src_operand" "d,dmsK")))]
3394   "TARGET_COLDFIRE"
3395 {
3396   return output_iorsi3 (operands);
3397 })
3398
3399 (define_insn "iorhi3"
3400   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,d")
3401         (ior:HI (match_operand:HI 1 "general_operand" "%0,0")
3402                 (match_operand:HI 2 "general_src_operand" "dn,dmSn")))]
3403   "!TARGET_COLDFIRE"
3404   "or%.w %2,%0")
3405
3406 (define_insn ""
3407   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3408         (ior:HI (match_dup 0)
3409                 (match_operand:HI 1 "general_src_operand" "dn,dmSn")))]
3410   "!TARGET_COLDFIRE"
3411   "or%.w %1,%0")
3412
3413 (define_insn ""
3414   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3415         (ior:HI (match_operand:HI 1 "general_src_operand" "dn,dmSn")
3416                 (match_dup 0)))]
3417   "!TARGET_COLDFIRE"
3418   "or%.w %1,%0")
3419
3420 (define_insn "iorqi3"
3421   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
3422         (ior:QI (match_operand:QI 1 "general_operand" "%0,0")
3423                 (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
3424   "!TARGET_COLDFIRE"
3425   "or%.b %2,%0")
3426
3427 (define_insn ""
3428   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3429         (ior:QI (match_dup 0)
3430                 (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
3431   "!TARGET_COLDFIRE"
3432   "or%.b %1,%0")
3433
3434 (define_insn ""
3435   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3436         (ior:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
3437                 (match_dup 0)))]
3438   "!TARGET_COLDFIRE"
3439   "or%.b %1,%0")
3440
3441 ;; On all 68k models, this makes faster code in a special case.
3442 ;; See also ashlsi_16, ashrsi_16 and lshrsi_16.
3443
3444 (define_insn "iorsi_zexthi_ashl16"
3445   [(set (match_operand:SI 0 "nonimmediate_operand" "=&d")
3446     (ior:SI (zero_extend:SI (match_operand:HI 1 "general_operand" "rmn"))
3447         (ashift:SI (match_operand:SI 2 "general_operand" "or")
3448             (const_int 16))))]
3449   ""
3450 {
3451   CC_STATUS_INIT;
3452   if (GET_CODE (operands[2]) != REG)
3453       operands[2] = adjust_address (operands[2], HImode, 2);
3454   if (GET_CODE (operands[2]) != REG
3455   || REGNO (operands[2]) != REGNO (operands[0]))
3456     output_asm_insn ("move%.w %2,%0", operands);
3457   return "swap %0\;mov%.w %1,%0";
3458 })
3459
3460 (define_insn "iorsi_zext"
3461   [(set (match_operand:SI 0 "nonimmediate_operand" "=o,d")
3462     (ior:SI (zero_extend:SI (match_operand 1 "general_operand" "dn,dmn"))
3463         (match_operand:SI 2 "general_operand" "0,0")))]
3464   "!TARGET_COLDFIRE"
3465 {
3466   int byte_mode;
3467
3468   CC_STATUS_INIT;
3469   byte_mode = (GET_MODE (operands[1]) == QImode);
3470   if (GET_CODE (operands[0]) == MEM)
3471     operands[0] = adjust_address (operands[0], byte_mode ? QImode : HImode,
3472                                   byte_mode ? 3 : 2);
3473   if (byte_mode)
3474     return "or%.b %1,%0";
3475   else
3476     return "or%.w %1,%0";
3477 })
3478 \f
3479 ;; xor instructions
3480
3481 ;; "xordi3" is mainly here to help combine().
3482 (define_insn "xordi3"
3483   [(set (match_operand:DI 0 "nonimmediate_operand" "=od")
3484         (xor:DI (match_operand:DI 1 "general_operand" "%0")
3485                 (match_operand:DI 2 "general_operand" "dn")))]
3486   "!TARGET_COLDFIRE"
3487 {
3488   CC_STATUS_INIT;
3489   /* We can get CONST_DOUBLE, but also const1_rtx etc.  */
3490
3491   if (CONSTANT_P (operands[2]))
3492     {
3493       rtx hi, lo;
3494
3495       split_double (operands[2], &hi, &lo);
3496
3497       switch (INTVAL (hi))
3498         {
3499           case 0 :
3500             break;
3501           case -1 :
3502             output_asm_insn ("not%.l %0", operands);
3503             break;
3504           default :
3505             /* FIXME : a scratch register would be welcome here if
3506                -128 <= INTVAL (hi) < -1 */
3507             {
3508             rtx xoperands[3];
3509
3510             xoperands[0] = operands[0];
3511             xoperands[2] = hi;
3512             output_asm_insn (output_xorsi3 (xoperands), xoperands);
3513             }
3514         }
3515       if (GET_CODE (operands[0]) == REG)
3516         operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3517       else
3518         operands[0] = adjust_address (operands[0], SImode, 4);
3519       switch (INTVAL (lo))
3520         {
3521           case 0 :
3522             break;
3523           case -1 :
3524             output_asm_insn ("not%.l %0", operands);
3525             break;
3526           default :
3527             /* FIXME : a scratch register would be welcome here if
3528                -128 <= INTVAL (lo) < -1 */
3529             operands[2] = lo;
3530             /* FIXME : this should be merged with xorsi3 */
3531             {
3532             rtx xoperands[3];
3533
3534             xoperands[0] = operands[0];
3535             xoperands[2] = lo;
3536             output_asm_insn (output_xorsi3 (xoperands), xoperands);
3537             }
3538         }
3539       return "";
3540     }
3541   if (GET_CODE (operands[0]) != REG)
3542     {
3543       operands[1] = adjust_address (operands[0], SImode, 4);
3544       return "eor%.l %2,%0\;eor%.l %R2,%1";
3545     }
3546   if (GET_CODE (operands[2]) != REG)
3547     {
3548       operands[1] = adjust_address (operands[2], SImode, 4);
3549       return "eor%.l %2,%0\;eor%.l %1,%R0";
3550     }
3551   return "eor%.l %2,%0\;eor%.l %R2,%R0";
3552 })
3553
3554 (define_expand "xorsi3"
3555   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3556         (xor:SI (match_operand:SI 1 "general_operand" "")
3557                 (match_operand:SI 2 "general_operand" "")))]
3558   ""
3559   "")
3560
3561 (define_insn "xorsi3_internal"
3562   [(set (match_operand:SI 0 "nonimmediate_operand" "=do,m")
3563         (xor:SI (match_operand:SI 1 "general_operand" "%0,0")
3564                 (match_operand:SI 2 "general_operand" "di,dKT")))]
3565
3566   "!TARGET_COLDFIRE"
3567 {
3568   return output_xorsi3 (operands);
3569 })
3570
3571 (define_insn "xorsi3_5200"
3572   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm,d")
3573         (xor:SI (match_operand:SI 1 "general_operand" "%0,0")
3574                 (match_operand:SI 2 "general_operand" "d,Ks")))]
3575   "TARGET_COLDFIRE"
3576 {
3577   return output_xorsi3 (operands);
3578 })
3579
3580 (define_insn "xorhi3"
3581   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
3582         (xor:HI (match_operand:HI 1 "general_operand" "%0")
3583                 (match_operand:HI 2 "general_operand" "dn")))]
3584   "!TARGET_COLDFIRE"
3585   "eor%.w %2,%0")
3586
3587 (define_insn ""
3588   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3589         (xor:HI (match_dup 0)
3590                 (match_operand:HI 1 "general_operand" "dn")))]
3591   "!TARGET_COLDFIRE"
3592   "eor%.w %1,%0")
3593
3594 (define_insn ""
3595   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3596         (xor:HI (match_operand:HI 1 "general_operand" "dn")
3597                 (match_dup 0)))]
3598   "!TARGET_COLDFIRE"
3599   "eor%.w %1,%0")
3600
3601 (define_insn "xorqi3"
3602   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
3603         (xor:QI (match_operand:QI 1 "general_operand" "%0")
3604                 (match_operand:QI 2 "general_operand" "dn")))]
3605   "!TARGET_COLDFIRE"
3606   "eor%.b %2,%0")
3607
3608 (define_insn ""
3609   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3610         (xor:QI (match_dup 0)
3611                 (match_operand:QI 1 "general_operand" "dn")))]
3612   "!TARGET_COLDFIRE"
3613   "eor%.b %1,%0")
3614
3615 (define_insn ""
3616   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3617         (xor:QI (match_operand:QI 1 "general_operand" "dn")
3618                 (match_dup 0)))]
3619   "!TARGET_COLDFIRE"
3620   "eor%.b %1,%0")
3621 \f
3622 ;; negation instructions
3623
3624 (define_expand "negdi2"
3625   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3626         (neg:DI (match_operand:DI 1 "general_operand" "")))]
3627   ""
3628 {
3629   if (TARGET_COLDFIRE)
3630     emit_insn (gen_negdi2_5200 (operands[0], operands[1]));
3631   else
3632     emit_insn (gen_negdi2_internal (operands[0], operands[1]));
3633   DONE;
3634 })
3635
3636 (define_insn "negdi2_internal"
3637   [(set (match_operand:DI 0 "nonimmediate_operand" "=<,do,!*a")
3638         (neg:DI (match_operand:DI 1 "general_operand" "0,0,0")))]
3639   "!TARGET_COLDFIRE"
3640 {
3641   if (which_alternative == 0)
3642     return "neg%.l %0\;negx%.l %0";
3643   if (GET_CODE (operands[0]) == REG)
3644     operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3645   else
3646     operands[1] = adjust_address (operands[0], SImode, 4);
3647   if (ADDRESS_REG_P (operands[0]))
3648     return "exg %/d0,%1\;neg%.l %/d0\;exg %/d0,%1\;exg %/d0,%0\;negx%.l %/d0\;exg %/d0,%0";
3649   else
3650     return "neg%.l %1\;negx%.l %0";
3651 })
3652
3653 (define_insn "negdi2_5200"
3654   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
3655         (neg:DI (match_operand:DI 1 "general_operand" "0")))]
3656   "TARGET_COLDFIRE"
3657 {
3658   operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3659   return "neg%.l %1\;negx%.l %0";
3660 })
3661
3662 (define_expand "negsi2"
3663   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3664         (neg:SI (match_operand:SI 1 "general_operand" "")))]
3665   ""
3666 {
3667   if (TARGET_COLDFIRE)
3668     emit_insn (gen_negsi2_5200 (operands[0], operands[1]));
3669   else
3670     emit_insn (gen_negsi2_internal (operands[0], operands[1]));
3671   DONE;
3672 })
3673
3674 (define_insn "negsi2_internal"
3675   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
3676         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
3677   "!TARGET_COLDFIRE"
3678   "neg%.l %0")
3679
3680 (define_insn "negsi2_5200"
3681   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3682         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
3683   "TARGET_COLDFIRE"
3684   "neg%.l %0")
3685
3686 (define_insn "neghi2"
3687   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
3688         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
3689   "!TARGET_COLDFIRE"
3690   "neg%.w %0")
3691
3692 (define_insn ""
3693   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3694         (neg:HI (match_dup 0)))]
3695   "!TARGET_COLDFIRE"
3696   "neg%.w %0")
3697
3698 (define_insn "negqi2"
3699   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
3700         (neg:QI (match_operand:QI 1 "general_operand" "0")))]
3701   "!TARGET_COLDFIRE"
3702   "neg%.b %0")
3703
3704 (define_insn ""
3705   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3706         (neg:QI (match_dup 0)))]
3707   "!TARGET_COLDFIRE"
3708   "neg%.b %0")
3709
3710 ;; If using software floating point, just flip the sign bit.
3711
3712 (define_expand "negsf2"
3713   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3714         (neg:SF (match_operand:SF 1 "general_operand" "")))]
3715   ""
3716 {
3717   if (!TARGET_HARD_FLOAT)
3718     {
3719       rtx result;
3720       rtx target;
3721
3722       target = operand_subword_force (operands[0], 0, SFmode);
3723       result = expand_binop (SImode, xor_optab,
3724                              operand_subword_force (operands[1], 0, SFmode),
3725                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
3726       gcc_assert (result);
3727
3728       if (result != target)
3729         emit_move_insn (result, target);
3730
3731       /* Make a place for REG_EQUAL.  */
3732       emit_move_insn (operands[0], operands[0]);
3733       DONE;
3734     }
3735 })
3736
3737 (define_expand "negdf2"
3738   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3739         (neg:DF (match_operand:DF 1 "general_operand" "")))]
3740   ""
3741 {
3742   if (!TARGET_HARD_FLOAT)
3743     {
3744       rtx result;
3745       rtx target;
3746       rtx insns;
3747
3748       start_sequence ();
3749       target = operand_subword (operands[0], 0, 1, DFmode);
3750       result = expand_binop (SImode, xor_optab,
3751                              operand_subword_force (operands[1], 0, DFmode),
3752                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
3753       gcc_assert (result);
3754
3755       if (result != target)
3756         emit_move_insn (result, target);
3757
3758       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
3759                       operand_subword_force (operands[1], 1, DFmode));
3760
3761       insns = get_insns ();
3762       end_sequence ();
3763
3764       emit_no_conflict_block (insns, operands[0], operands[1], 0, 0);
3765       DONE;
3766     }
3767 })
3768
3769 (define_expand "negxf2"
3770   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3771         (neg:XF (match_operand:XF 1 "nonimmediate_operand" "")))]
3772   ""
3773 {
3774   if (!TARGET_68881)
3775     {
3776       rtx result;
3777       rtx target;
3778       rtx insns;
3779
3780       start_sequence ();
3781       target = operand_subword (operands[0], 0, 1, XFmode);
3782       result = expand_binop (SImode, xor_optab,
3783                              operand_subword_force (operands[1], 0, XFmode),
3784                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
3785       gcc_assert (result);
3786
3787       if (result != target)
3788         emit_move_insn (result, target);
3789
3790       emit_move_insn (operand_subword (operands[0], 1, 1, XFmode),
3791                       operand_subword_force (operands[1], 1, XFmode));
3792       emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
3793                       operand_subword_force (operands[1], 2, XFmode));
3794
3795       insns = get_insns ();
3796       end_sequence ();
3797
3798       emit_no_conflict_block (insns, operands[0], operands[1], 0, 0);
3799       DONE;
3800     }
3801 })
3802
3803 (define_insn "neg<mode>2_68881"
3804   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
3805         (neg:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m<FP:const>,0")))]
3806   "TARGET_68881"
3807 {
3808   if (DATA_REG_P (operands[0]))
3809     {
3810       operands[1] = GEN_INT (31);
3811       return "bchg %1,%0";
3812     }
3813   if (FP_REG_P (operands[1]))
3814     return "f<FP:round>neg%.x %1,%0";
3815   return "f<FP:round>neg%.<FP:prec> %f1,%0";
3816 })
3817
3818 (define_insn "neg<mode>2_cf"
3819   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
3820         (neg:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U,0")))]
3821   "TARGET_COLDFIRE_FPU"
3822 {
3823   if (DATA_REG_P (operands[0]))
3824     {
3825       operands[1] = GEN_INT (31);
3826       return "bchg %1,%0";
3827     }
3828   if (FP_REG_P (operands[1]))
3829     return "f<FP:prec>neg%.d %1,%0";
3830   return "f<FP:prec>neg%.<FP:prec> %1,%0";
3831 })
3832 \f
3833 ;; Sqrt instruction for the 68881
3834
3835 (define_expand "sqrt<mode>2"
3836   [(set (match_operand:FP 0 "nonimmediate_operand" "")
3837         (sqrt:FP (match_operand:FP 1 "general_operand" "")))]
3838   "TARGET_HARD_FLOAT"
3839   "")
3840
3841 (define_insn "sqrt<mode>2_68881"
3842   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3843         (sqrt:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m")))]
3844   "TARGET_68881"
3845 {
3846   if (FP_REG_P (operands[1]))
3847     return "f<FP:round>sqrt%.x %1,%0";
3848   return "f<FP:round>sqrt%.<FP:prec> %1,%0";
3849 })
3850
3851 (define_insn "sqrt<mode>2_cf"
3852   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3853         (sqrt:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U")))]
3854   "TARGET_COLDFIRE_FPU"
3855 {
3856   if (FP_REG_P (operands[1]))
3857     return "f<FP:prec>sqrt%.d %1,%0";
3858   return "f<FP:prec>sqrt%.<FP:prec> %1,%0";
3859 })
3860 ;; Absolute value instructions
3861 ;; If using software floating point, just zero the sign bit.
3862
3863 (define_expand "abssf2"
3864   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3865         (abs:SF (match_operand:SF 1 "general_operand" "")))]
3866   ""
3867 {
3868   if (!TARGET_HARD_FLOAT)
3869     {
3870       rtx result;
3871       rtx target;
3872
3873       target = operand_subword_force (operands[0], 0, SFmode);
3874       result = expand_binop (SImode, and_optab,
3875                              operand_subword_force (operands[1], 0, SFmode),
3876                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
3877       gcc_assert (result);
3878
3879       if (result != target)
3880         emit_move_insn (result, target);
3881
3882       /* Make a place for REG_EQUAL.  */
3883       emit_move_insn (operands[0], operands[0]);
3884       DONE;
3885     }
3886 })
3887
3888 (define_expand "absdf2"
3889   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3890         (abs:DF (match_operand:DF 1 "general_operand" "")))]
3891   ""
3892 {
3893   if (!TARGET_HARD_FLOAT)
3894     {
3895       rtx result;
3896       rtx target;
3897       rtx insns;
3898
3899       start_sequence ();
3900       target = operand_subword (operands[0], 0, 1, DFmode);
3901       result = expand_binop (SImode, and_optab,
3902                              operand_subword_force (operands[1], 0, DFmode),
3903                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
3904       gcc_assert (result);
3905
3906       if (result != target)
3907         emit_move_insn (result, target);
3908
3909       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
3910                       operand_subword_force (operands[1], 1, DFmode));
3911
3912       insns = get_insns ();
3913       end_sequence ();
3914
3915       emit_no_conflict_block (insns, operands[0], operands[1], 0, 0);
3916       DONE;
3917     }
3918 })
3919
3920 (define_expand "absxf2"
3921   [(set (match_operand:XF 0 "nonimmediate_operand" "")
3922         (abs:XF (match_operand:XF 1 "nonimmediate_operand" "")))]
3923   ""
3924 {
3925   if (!TARGET_68881)
3926     {
3927       rtx result;
3928       rtx target;
3929       rtx insns;
3930
3931       start_sequence ();
3932       target = operand_subword (operands[0], 0, 1, XFmode);
3933       result = expand_binop (SImode, and_optab,
3934                              operand_subword_force (operands[1], 0, XFmode),
3935                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
3936       gcc_assert (result);
3937
3938       if (result != target)
3939         emit_move_insn (result, target);
3940
3941       emit_move_insn (operand_subword (operands[0], 1, 1, XFmode),
3942                       operand_subword_force (operands[1], 1, XFmode));
3943       emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
3944                       operand_subword_force (operands[1], 2, XFmode));
3945
3946       insns = get_insns ();
3947       end_sequence ();
3948
3949       emit_no_conflict_block (insns, operands[0], operands[1], 0, 0);
3950       DONE;
3951     }
3952 })
3953
3954 (define_insn "abs<mode>2_68881"
3955   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
3956         (abs:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m<FP:const>,0")))]
3957   "TARGET_68881"
3958 {
3959   if (DATA_REG_P (operands[0]))
3960     {
3961       operands[1] = GEN_INT (31);
3962       return "bclr %1,%0";
3963     }
3964   if (FP_REG_P (operands[1]))
3965     return "f<FP:round>abs%.x %1,%0";
3966   return "f<FP:round>abs%.<FP:prec> %f1,%0";
3967 })
3968
3969 (define_insn "abs<mode>2_cf"
3970   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
3971         (abs:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U,0")))]
3972   "TARGET_COLDFIRE_FPU"
3973 {
3974   if (DATA_REG_P (operands[0]))
3975     {
3976       operands[1] = GEN_INT (31);
3977       return "bclr %1,%0";
3978     }
3979   if (FP_REG_P (operands[1]))
3980     return "f<FP:prec>abs%.d %1,%0";
3981   return "f<FP:prec>abs%.<FP:prec> %1,%0";
3982 })
3983 \f
3984 ;; one complement instructions
3985
3986 ;; "one_cmpldi2" is mainly here to help combine().
3987 (define_insn "one_cmpldi2"
3988   [(set (match_operand:DI 0 "nonimmediate_operand" "=dm")
3989         (not:DI (match_operand:DI 1 "general_operand" "0")))]
3990   "!TARGET_COLDFIRE"
3991 {
3992   CC_STATUS_INIT;
3993   if (GET_CODE (operands[0]) == REG)
3994     operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3995   else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC
3996         || GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
3997     operands[1] = operands[0];
3998   else
3999     operands[1] = adjust_address (operands[0], SImode, 4);
4000   return "not%.l %1\;not%.l %0";
4001 })
4002
4003 (define_expand "one_cmplsi2"
4004   [(set (match_operand:SI 0 "nonimmediate_operand" "")
4005         (not:SI (match_operand:SI 1 "general_operand" "")))]
4006   ""
4007 {
4008   if (TARGET_COLDFIRE)
4009     emit_insn (gen_one_cmplsi2_5200 (operands[0], operands[1]));
4010   else
4011     emit_insn (gen_one_cmplsi2_internal (operands[0], operands[1]));
4012   DONE;
4013 })
4014
4015 (define_insn "one_cmplsi2_internal"
4016   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
4017         (not:SI (match_operand:SI 1 "general_operand" "0")))]
4018   "!TARGET_COLDFIRE"
4019   "not%.l %0")
4020
4021 (define_insn "one_cmplsi2_5200"
4022   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
4023         (not:SI (match_operand:SI 1 "general_operand" "0")))]
4024   "TARGET_COLDFIRE"
4025   "not%.l %0")
4026
4027 (define_insn "one_cmplhi2"
4028   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
4029         (not:HI (match_operand:HI 1 "general_operand" "0")))]
4030   "!TARGET_COLDFIRE"
4031   "not%.w %0")
4032
4033 (define_insn ""
4034   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
4035         (not:HI (match_dup 0)))]
4036   "!TARGET_COLDFIRE"
4037   "not%.w %0")
4038
4039 (define_insn "one_cmplqi2"
4040   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
4041         (not:QI (match_operand:QI 1 "general_operand" "0")))]
4042   "!TARGET_COLDFIRE"
4043   "not%.b %0")
4044
4045 (define_insn ""
4046   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
4047         (not:QI (match_dup 0)))]
4048   "!TARGET_COLDFIRE"
4049   "not%.b %0")
4050 \f
4051 ;; arithmetic shift instructions
4052 ;; We don't need the shift memory by 1 bit instruction
4053
4054 (define_insn "ashldi_extsi"
4055   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro")
4056     (ashift:DI
4057       (match_operator:DI 2 "extend_operator"
4058         [(match_operand:SI 1 "general_operand" "rm")])
4059       (const_int 32)))]