OSDN Git Service

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