OSDN Git Service

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