OSDN Git Service

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