OSDN Git Service

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