gcc/config/m68k/m68k.md

   1 ;;- Machine description for GNU compiler, Motorola 68000 Version
   2 ;;  Copyright (C) 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001,
   3 ;;  2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012
   4 ;;  Free Software Foundation, Inc.
   5
   6 ;; This file is part of GCC.
   7
   8 ;; GCC is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation; either version 3, or (at your option)
  11 ;; any later version.
  12
  13 ;; GCC is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with GCC; see the file COPYING3.  If not see
  20 ;; <http://www.gnu.org/licenses/>.
  21
  22 ;;- Information about MCF5200 port.
  23
  24 ;;- The MCF5200 "ColdFire" architecture is a reduced version of the
  25 ;;- 68k ISA.  Differences include reduced support for byte and word
  26 ;;- operands and the removal of BCD, bitfield, rotate, and integer
  27 ;;- divide instructions.  The TARGET_COLDFIRE flag turns the use of the
  28 ;;- removed opcodes and addressing modes off.
  29 ;;-
  30
  31
  32 ;;- instruction definitions
  33
  34 ;;- @@The original PO technology requires these to be ordered by speed,
  35 ;;- @@    so that assigner will pick the fastest.
  36
  37 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  38
  39 ;;- When naming insn's (operand 0 of define_insn) be careful about using
  40 ;;- names from other targets machine descriptions.
  41
  42 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  43 ;;- updates for most instructions.
  44
  45 ;;- Operand classes for the register allocator:
  46 ;;- 'a' one of the address registers can be used.
  47 ;;- 'd' one of the data registers can be used.
  48 ;;- 'f' one of the m68881/fpu registers can be used
  49 ;;- 'r' either a data or an address register can be used.
  50
  51 ;;- Immediate Floating point operator constraints
  52 ;;- 'G' a floating point constant that is *NOT* one of the standard
  53 ;;   68881 constant values (to force calling output_move_const_double
  54 ;;   to get it from rom if it is a 68881 constant).
  55 ;;
  56 ;;   See the functions standard_XXX_constant_p in output-m68k.c for more
  57 ;; info.
  58
  59 ;;- Immediate integer operand constraints:
  60 ;;- 'I'  1 .. 8
  61 ;;- 'J'  -32768 .. 32767
  62 ;;- 'K'  all integers EXCEPT -128 .. 127
  63 ;;- 'L'  -8 .. -1
  64 ;;- 'M'  all integers EXCEPT -256 .. 255
  65 ;;- 'N'  24 .. 31
  66 ;;- 'O'  16
  67 ;;- 'P'  8 .. 15
  68
  69 ;;- Assembler specs:
  70 ;;- "%."    size separator ("." or "")                  move%.l d0,d1
  71 ;;- "%-"    push operand "sp@-"                         move%.l d0,%-
  72 ;;- "%+"    pop operand "sp@+"                          move%.l d0,%+
  73 ;;- "%@"    top of stack "sp@"                          move%.l d0,%@
  74 ;;- "%!"    fpcr register
  75 ;;- "%$"    single-precision fp specifier ("s" or "")   f%$add.x fp0,fp1
  76 ;;- "%&"    double-precision fp specifier ("d" or "")   f%&add.x fp0,fp1
  77
  78 ;;- Information about 68040 port.
  79
  80 ;;- The 68040 executes all 68030 and 68881/2 instructions, but some must
  81 ;;- be emulated in software by the OS.  It is faster to avoid these
  82 ;;- instructions and issue a library call rather than trapping into
  83 ;;- the kernel.  The affected instructions are fintrz and fscale.  The
  84 ;;- TUNE_68040 flag turns the use of the opcodes off.
  85
  86 ;;- The '040 also implements a set of new floating-point instructions
  87 ;;- which specify the rounding precision in the opcode.  This finally
  88 ;;- permit the 68k series to be truly IEEE compliant, and solves all
  89 ;;- issues of excess precision accumulating in the extended registers.
  90 ;;- By default, GCC does not use these instructions, since such code will
  91 ;;- not run on an '030.  To use these instructions, use the -m68040-only
  92 ;;- switch.
  93
  94 ;;- These new instructions aren't directly in the md.  They are brought
  95 ;;- into play by defining "%$" and "%&" to expand to "s" and "d" rather
  96 ;;- than "".
  97
  98 ;;- Information about 68060 port.
  99
 100 ;;- The 68060 executes all 68030 and 68881/2 instructions, but some must
 101 ;;- be emulated in software by the OS.  It is faster to avoid these
 102 ;;- instructions and issue a library call rather than trapping into
 103 ;;- the kernel.  The affected instructions are: divs.l <ea>,Dr:Dq;
 104 ;;- divu.l <ea>,Dr:Dq; muls.l <ea>,Dr:Dq; mulu.l <ea>,Dr:Dq; and
 105 ;;- fscale.  The TUNE_68060 flag turns the use of the opcodes off.
 106
 107 ;;- Some of these insn's are composites of several m68000 op codes.
 108 ;;- The assembler (or final @@??) insures that the appropriate one is
 109 ;;- selected.
 110
 111 ;; UNSPEC usage:
 112
 113 (define_constants
 114   [(UNSPEC_SIN 1)
 115    (UNSPEC_COS 2)
 116    (UNSPEC_GOT 3)
 117    (UNSPEC_IB 4)
 118    (UNSPEC_TIE 5)
 119    (UNSPEC_RELOC16 6)
 120    (UNSPEC_RELOC32 7)
 121   ])
 122
 123 ;; UNSPEC_VOLATILE usage:
 124
 125 (define_constants
 126   [(UNSPECV_BLOCKAGE    0)
 127    (UNSPECV_CAS_1       1)
 128    (UNSPECV_CAS_2       2)
 129    (UNSPECV_TAS_1       3)
 130    (UNSPECV_TAS_2       4)
 131   ])
 132
 133 ;; Registers by name.
 134 (define_constants
 135   [(D0_REG              0)
 136    (A0_REG              8)
 137    (A1_REG              9)
 138    (PIC_REG             13)
 139    (A6_REG              14)
 140    (SP_REG              15)
 141    (FP0_REG             16)
 142   ])
 143
 144 (include "predicates.md")
 145 (include "constraints.md")
 146 \f
 147 ;; ::::::::::::::::::::
 148 ;; ::
 149 ;; :: Attributes
 150 ;; ::
 151 ;; ::::::::::::::::::::
 152
 153 ;; Processor type.
 154 (define_attr "cpu" "cfv1, cfv2, cfv3, cfv4, unknown"
 155   (const (symbol_ref "m68k_sched_cpu")))
 156
 157 ;; MAC type.
 158 (define_attr "mac" "no, cf_mac, cf_emac"
 159   (const (symbol_ref "m68k_sched_mac")))
 160
 161 ;; Instruction type for use in scheduling description.
 162 ;; _l and _w suffixes indicate size of the operands of instruction.
 163 ;; alu - usual arithmetic or logic instruction.
 164 ;; aluq - arithmetic or logic instruction which has a quick immediate (the one
 165 ;;        that is encoded in the instruction word) for its Y operand.
 166 ;; alux - Arithmetic instruction that uses carry bit (e.g., addx and subx).
 167 ;; bcc - conditional branch.
 168 ;; bitr - bit operation that only updates flags.
 169 ;; bitrw - bit operation that updates flags and output operand.
 170 ;; bra, bsr, clr, cmp, div, ext - corresponding instruction.
 171 ;; falu, fbcc, fcmp, fdiv, fmove, fmul, fneg, fsqrt, ftst - corresponding
 172 ;;                                                          instruction.
 173 ;; ib - fake instruction to subscribe slots in ColdFire V1,V2,V3 instruction
 174 ;;      buffer.
 175 ;; ignore - fake instruction.
 176 ;; jmp, jsr, lea, link, mov3q, move, moveq, mul - corresponding instruction.
 177 ;; mvsz - mvs or mvz instruction.
 178 ;; neg, nop, pea, rts, scc - corresponding instruction.
 179 ;; shift - arithmetic or logical shift instruction.
 180 ;; trap, tst, unlk - corresponding instruction.
 181 (define_attr "type"
 182   "alu_l,aluq_l,alux_l,bcc,bitr,bitrw,bra,bsr,clr,clr_l,cmp,cmp_l,
 183    div_w,div_l,ext,
 184    falu,fbcc,fcmp,fdiv,fmove,fmul,fneg,fsqrt,ftst,
 185    ib,ignore,
 186    jmp,jsr,lea,link,mov3q_l,move,move_l,moveq_l,mul_w,mul_l,mvsz,neg_l,nop,
 187    pea,rts,scc,shift,
 188    trap,tst,tst_l,unlk,
 189    unknown"
 190   (const_string "unknown"))
 191
 192 ;; Index of the X or Y operand in recog_data.operand[].
 193 ;; Should be used only within opx_type and opy_type.
 194 (define_attr "opx" "" (const_int 0))
 195 (define_attr "opy" "" (const_int 1))
 196
 197 ;; Type of the Y operand.
 198 ;; See m68k.c: enum attr_op_type.
 199 (define_attr "opy_type"
 200   "none,Rn,FPn,mem1,mem234,mem5,mem6,mem7,imm_q,imm_w,imm_l"
 201   (cond [(eq_attr "type" "ext,fbcc,ftst,neg_l,bcc,bra,bsr,clr,clr_l,ib,ignore,
 202                           jmp,jsr,nop,rts,scc,trap,tst,tst_l,
 203                           unlk,unknown") (const_string "none")
 204          (eq_attr "type" "lea,pea")
 205          (symbol_ref "m68k_sched_attr_opy_type (insn, 1)")]
 206         (symbol_ref "m68k_sched_attr_opy_type (insn, 0)")))
 207
 208 ;; Type of the X operand.
 209 ;; See m68k.c: enum attr_op_type.
 210 (define_attr "opx_type"
 211   "none,Rn,FPn,mem1,mem234,mem5,mem6,mem7,imm_q,imm_w,imm_l"
 212   (cond [(eq_attr "type" "ib,ignore,nop,rts,trap,unlk,
 213                           unknown") (const_string "none")
 214          (eq_attr "type" "pea") (const_string "mem1")
 215          (eq_attr "type" "jmp,jsr")
 216          (symbol_ref "m68k_sched_attr_opx_type (insn, 1)")]
 217         (symbol_ref "m68k_sched_attr_opx_type (insn, 0)")))
 218
 219 ;; Access to the X operand: none, read, write, read/write, unknown.
 220 ;; Access to the Y operand is either none (if opy_type is none)
 221 ;; or read otherwise.
 222 (define_attr "opx_access" "none, r, w, rw"
 223   (cond [(eq_attr "type" "ib,ignore,nop,rts,trap,unlk,
 224                           unknown") (const_string "none")
 225          (eq_attr "type" "bcc,bra,bsr,bitr,cmp,cmp_l,fbcc,fcmp,ftst,
 226                           jmp,jsr,tst,tst_l") (const_string "r")
 227          (eq_attr "type" "clr,clr_l,fneg,fmove,lea,
 228                           mov3q_l,move,move_l,moveq_l,mvsz,
 229                           pea,scc") (const_string "w")
 230          (eq_attr "type" "alu_l,aluq_l,alux_l,bitrw,div_w,div_l,ext,
 231                           falu,fdiv,fmul,fsqrt,link,mul_w,mul_l,
 232                           neg_l,shift") (const_string "rw")]
 233         ;; Should never be used.
 234         (symbol_ref "(gcc_unreachable (), OPX_ACCESS_NONE)")))
 235
 236 ;; Memory accesses of the insn.
 237 ;; 00 - no memory references
 238 ;; 10 - memory is read
 239 ;; i0 - indexed memory is read
 240 ;; 01 - memory is written
 241 ;; 0i - indexed memory is written
 242 ;; 11 - memory is read, memory is written
 243 ;; i1 - indexed memory is read, memory is written
 244 ;; 1i - memory is read, indexed memory is written
 245 (define_attr "op_mem" "00, 10, i0, 01, 0i, 11, i1, 1i"
 246   (symbol_ref "m68k_sched_attr_op_mem (insn)"))
 247
 248 ;; Instruction size in words.
 249 (define_attr "size" "1,2,3"
 250   (symbol_ref "m68k_sched_attr_size (insn)"))
 251
 252 ;; Alternative is OK for ColdFire.
 253 (define_attr "ok_for_coldfire" "yes,no" (const_string "yes"))
 254
 255 ;; Define 'enabled' attribute.
 256 (define_attr "enabled" ""
 257   (cond [(and (match_test "TARGET_COLDFIRE")
 258               (eq_attr "ok_for_coldfire" "no"))
 259          (const_int 0)]
 260         (const_int 1)))
 261 \f
 262 ;; Mode macros for integer operations.
 263 (define_mode_iterator I [QI HI SI])
 264 (define_mode_attr sz [(QI "%.b") (HI "%.w") (SI "%.l")])
 265
 266 ;; Mode macros for floating point operations.
 267 ;; Valid floating point modes
 268 (define_mode_iterator FP [SF DF (XF "TARGET_68881")])
 269 ;; Mnemonic infix to round result
 270 (define_mode_attr round [(SF "%$") (DF "%&") (XF "")])
 271 ;; Mnemonic infix to round result for mul or div instruction
 272 (define_mode_attr round_mul [(SF "sgl") (DF "%&") (XF "")])
 273 ;; Suffix specifying source operand format
 274 (define_mode_attr prec [(SF "s") (DF "d") (XF "x")])
 275 ;; Allowable D registers
 276 (define_mode_attr dreg [(SF "d") (DF "") (XF "")])
 277 ;; Allowable 68881 constant constraints
 278 (define_mode_attr const [(SF "F") (DF "G") (XF "")])
 279 \f
 280
 281 (define_insn_and_split "*movdf_internal"
 282   [(set (match_operand:DF 0 "push_operand"   "=m, m")
 283         (match_operand:DF 1 "general_operand" "f, ro<>E"))]
 284   ""
 285   "@
 286    fmove%.d %f1,%0
 287    #"
 288   "&& reload_completed && (extract_constrain_insn_cached (insn), which_alternative == 1)"
 289   [(const_int 0)]
 290 {
 291   m68k_emit_move_double (operands);
 292   DONE;
 293 }
 294   [(set_attr "type" "fmove,*")])
 295
 296 (define_insn_and_split "pushdi"
 297   [(set (match_operand:DI 0 "push_operand" "=m")
 298         (match_operand:DI 1 "general_operand" "ro<>Fi"))]
 299   ""
 300   "#"
 301   "&& reload_completed"
 302   [(const_int 0)]
 303 {
 304   m68k_emit_move_double (operands);
 305   DONE;
 306 })
 307 \f
 308 ;; We don't want to allow a constant operand for test insns because
 309 ;; (set (cc0) (const_int foo)) has no mode information.  Such insns will
 310 ;; be folded while optimizing anyway.
 311
 312 (define_insn "tstdi"
 313   [(set (cc0)
 314         (compare (match_operand:DI 0 "nonimmediate_operand" "am,d")
 315                  (const_int 0)))
 316    (clobber (match_scratch:SI 1 "=X,d"))
 317    (clobber (match_scratch:DI 2 "=d,X"))]
 318   ""
 319 {
 320   if (which_alternative == 0)
 321     {
 322       rtx xoperands[2];
 323
 324       xoperands[0] = operands[2];
 325       xoperands[1] = operands[0];
 326       output_move_double (xoperands);
 327       cc_status.flags |= CC_REVERSED; /*|*/
 328       return "neg%.l %R2\;negx%.l %2";
 329     }
 330   if (find_reg_note (insn, REG_DEAD, operands[0]))
 331     {
 332       cc_status.flags |= CC_REVERSED; /*|*/
 333       return "neg%.l %R0\;negx%.l %0";
 334     }
 335   else
 336     /*
 337        'sub' clears %1, and also clears the X cc bit
 338        'tst' sets the Z cc bit according to the low part of the DImode operand
 339        'subx %1' (i.e. subx #0) acts as a (non-existent) tstx on the high part.
 340     */
 341     return "sub%.l %1,%1\;tst%.l %R0\;subx%.l %1,%0";
 342 })
 343
 344 ;; If you think that the 68020 does not support tstl a0,
 345 ;; reread page B-167 of the 68020 manual more carefully.
 346 (define_insn "*tstsi_internal_68020_cf"
 347   [(set (cc0)
 348         (compare (match_operand:SI 0 "nonimmediate_operand" "rm")
 349                  (const_int 0)))]
 350   "TARGET_68020 || TARGET_COLDFIRE"
 351   "tst%.l %0"
 352   [(set_attr "type" "tst_l")])
 353
 354 ;; On an address reg, cmpw may replace cmpl.
 355 (define_insn "*tstsi_internal"
 356   [(set (cc0)
 357         (compare (match_operand:SI 0 "nonimmediate_operand" "dm,r")
 358                  (const_int 0)))]
 359   "!(TARGET_68020 || TARGET_COLDFIRE)"
 360   "@
 361    tst%.l %0
 362    cmp%.w #0,%0"
 363   [(set_attr "type" "tst_l,cmp")])
 364
 365 ;; This can't use an address register, because comparisons
 366 ;; with address registers as second operand always test the whole word.
 367 (define_insn "*tsthi_internal"
 368   [(set (cc0)
 369         (compare (match_operand:HI 0 "nonimmediate_operand" "dm")
 370                  (const_int 0)))]
 371   ""
 372   "tst%.w %0"
 373   [(set_attr "type" "tst")])
 374
 375 (define_insn "*tstqi_internal"
 376   [(set (cc0)
 377         (compare (match_operand:QI 0 "nonimmediate_operand" "dm")
 378                  (const_int 0)))]
 379   ""
 380   "tst%.b %0"
 381   [(set_attr "type" "tst")])
 382
 383 (define_insn "tst<mode>_68881"
 384   [(set (cc0)
 385         (compare (match_operand:FP 0 "general_operand" "f<FP:dreg>m")
 386                  (match_operand:FP 1 "const0_operand" "H")))]
 387   "TARGET_68881"
 388 {
 389   cc_status.flags = CC_IN_68881;
 390   if (FP_REG_P (operands[0]))
 391     return "ftst%.x %0";
 392   return "ftst%.<FP:prec> %0";
 393 }
 394   [(set_attr "type" "ftst")])
 395
 396 (define_insn "tst<mode>_cf"
 397   [(set (cc0)
 398         (compare (match_operand:FP 0 "general_operand" "f<FP:dreg><Q>U")
 399                  (match_operand:FP 1 "const0_operand" "H")))]
 400   "TARGET_COLDFIRE_FPU"
 401 {
 402   cc_status.flags = CC_IN_68881;
 403   if (FP_REG_P (operands[0]))
 404     return "ftst%.d %0";
 405   return "ftst%.<FP:prec> %0";
 406 }
 407   [(set_attr "type" "ftst")])
 408
 409 \f
 410 ;; compare instructions.
 411
 412 (define_insn "*cmpdi_internal"
 413  [(set (cc0)
 414        (compare (match_operand:DI 1 "nonimmediate_operand" "0,d")
 415                 (match_operand:DI 2 "general_operand" "d,0")))
 416   (clobber (match_scratch:DI 0 "=d,d"))]
 417   ""
 418 {
 419   if (rtx_equal_p (operands[0], operands[1]))
 420     return "sub%.l %R2,%R0\;subx%.l %2,%0";
 421   else
 422     {
 423       cc_status.flags |= CC_REVERSED; /*|*/
 424       return "sub%.l %R1,%R0\;subx%.l %1,%0";
 425     }
 426 })
 427
 428 (define_insn "cmpdi"
 429  [(set (cc0)
 430        (compare (match_operand:DI 0 "nonimmediate_operand")
 431                 (match_operand:DI 1 "general_operand")))
 432   (clobber (match_scratch:DI 2))]
 433   ""
 434   "")
 435
 436
 437 (define_expand "cbranchdi4"
 438   [(set (pc)
 439         (if_then_else (match_operator 0 "ordered_comparison_operator"
 440                        [(match_operand:DI 1 "nonimmediate_operand")
 441                         (match_operand:DI 2 "general_operand")])
 442                       (label_ref (match_operand 3 ""))
 443                       (pc)))]
 444   ""
 445 {
 446   if (operands[2] == const0_rtx)
 447     emit_insn (gen_tstdi (operands[1]));
 448   else
 449     emit_insn (gen_cmpdi (operands[1], operands[2]));
 450   operands[1] = cc0_rtx;
 451   operands[2] = const0_rtx;
 452 })
 453
 454 (define_expand "cstoredi4"
 455   [(set (match_operand:QI 0 "register_operand")
 456         (match_operator:QI 1 "ordered_comparison_operator"
 457          [(match_operand:DI 2 "nonimmediate_operand")
 458           (match_operand:DI 3 "general_operand")]))]
 459   ""
 460 {
 461   if (operands[3] == const0_rtx)
 462     emit_insn (gen_tstdi (operands[2]));
 463   else
 464     emit_insn (gen_cmpdi (operands[2], operands[3]));
 465   operands[2] = cc0_rtx;
 466   operands[3] = const0_rtx;
 467 })
 468
 469
 470 (define_expand "cbranchsi4"
 471   [(set (cc0)
 472         (compare (match_operand:SI 1 "nonimmediate_operand" "")
 473                  (match_operand:SI 2 "general_operand" "")))
 474    (set (pc)
 475         (if_then_else (match_operator 0 "ordered_comparison_operator"
 476                        [(cc0) (const_int 0)])
 477                       (label_ref (match_operand 3 ""))
 478                       (pc)))]
 479   ""
 480   "")
 481
 482 (define_expand "cstoresi4"
 483   [(set (cc0)
 484         (compare (match_operand:SI 2 "nonimmediate_operand" "")
 485                  (match_operand:SI 3 "general_operand" "")))
 486    (set (match_operand:QI 0 "register_operand")
 487         (match_operator:QI 1 "ordered_comparison_operator"
 488          [(cc0) (const_int 0)]))]
 489   ""
 490   "")
 491
 492
 493 ;; A composite of the cmp, cmpa, cmpi & cmpm m68000 op codes.
 494 (define_insn ""
 495   [(set (cc0)
 496         (compare (match_operand:SI 0 "nonimmediate_operand" "rKT,rKs,mSr,mSa,>")
 497                  (match_operand:SI 1 "general_src_operand" "mSr,mSa,KTr,Ksr,>")))]
 498   "!TARGET_COLDFIRE"
 499 {
 500   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
 501     return "cmpm%.l %1,%0";
 502   if (REG_P (operands[1])
 503       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
 504     {
 505       cc_status.flags |= CC_REVERSED; /*|*/
 506       return "cmp%.l %d0,%d1";
 507     }
 508   if (ADDRESS_REG_P (operands[0])
 509       && GET_CODE (operands[1]) == CONST_INT
 510       && INTVAL (operands[1]) < 0x8000
 511       && INTVAL (operands[1]) >= -0x8000)
 512     return "cmp%.w %1,%0";
 513   return "cmp%.l %d1,%d0";
 514 })
 515
 516 (define_insn "*cmpsi_cf"
 517   [(set (cc0)
 518         (compare (match_operand:SI 0 "nonimmediate_operand" "mrKs,r")
 519                  (match_operand:SI 1 "general_operand" "r,mrKs")))]
 520   "TARGET_COLDFIRE"
 521 {
 522   if (REG_P (operands[1])
 523       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
 524     {
 525       cc_status.flags |= CC_REVERSED; /*|*/
 526       return "cmp%.l %d0,%d1";
 527     }
 528   return "cmp%.l %d1,%d0";
 529 }
 530   [(set_attr "type" "cmp_l")])
 531
 532 (define_expand "cbranchhi4"
 533   [(set (cc0)
 534         (compare (match_operand:HI 1 "nonimmediate_src_operand" "")
 535                  (match_operand:HI 2 "m68k_subword_comparison_operand" "")))
 536    (set (pc)
 537         (if_then_else (match_operator 0 "ordered_comparison_operator"
 538                        [(cc0) (const_int 0)])
 539                       (label_ref (match_operand 3 ""))
 540                       (pc)))]
 541   ""
 542   "")
 543
 544 (define_expand "cstorehi4"
 545   [(set (cc0)
 546         (compare (match_operand:HI 2 "nonimmediate_operand" "")
 547                  (match_operand:HI 3 "m68k_subword_comparison_operand" "")))
 548    (set (match_operand:QI 0 "register_operand")
 549         (match_operator:QI 1 "ordered_comparison_operator"
 550          [(cc0) (const_int 0)]))]
 551   ""
 552   "")
 553
 554 (define_insn ""
 555   [(set (cc0)
 556         (compare (match_operand:HI 0 "nonimmediate_src_operand" "rnmS,d,n,mS,>")
 557                  (match_operand:HI 1 "general_src_operand" "d,rnmS,mS,n,>")))]
 558   "!TARGET_COLDFIRE"
 559 {
 560   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
 561     return "cmpm%.w %1,%0";
 562   if ((REG_P (operands[1]) && !ADDRESS_REG_P (operands[1]))
 563       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
 564     {
 565       cc_status.flags |= CC_REVERSED; /*|*/
 566       return "cmp%.w %d0,%d1";
 567     }
 568   return "cmp%.w %d1,%d0";
 569 })
 570
 571 (define_expand "cbranchqi4"
 572   [(set (cc0)
 573         (compare (match_operand:QI 1 "nonimmediate_src_operand" "")
 574                  (match_operand:QI 2 "m68k_subword_comparison_operand" "")))
 575    (set (pc)
 576         (if_then_else (match_operator 0 "ordered_comparison_operator"
 577                        [(cc0) (const_int 0)])
 578                       (label_ref (match_operand 3 ""))
 579                       (pc)))]
 580   ""
 581   "")
 582
 583 (define_expand "cstoreqi4"
 584   [(set (cc0)
 585         (compare (match_operand:QI 2 "nonimmediate_src_operand" "")
 586                  (match_operand:QI 3 "m68k_subword_comparison_operand" "")))
 587    (set (match_operand:QI 0 "register_operand")
 588         (match_operator:QI 1 "ordered_comparison_operator"
 589          [(cc0) (const_int 0)]))]
 590   ""
 591   "")
 592
 593 (define_insn ""
 594   [(set (cc0)
 595         (compare (match_operand:QI 0 "nonimmediate_src_operand" "dn,dmS,>")
 596                  (match_operand:QI 1 "general_src_operand" "dmS,nd,>")))]
 597   "!TARGET_COLDFIRE"
 598 {
 599   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
 600     return "cmpm%.b %1,%0";
 601   if (REG_P (operands[1])
 602       || (!REG_P (operands[0]) && GET_CODE (operands[0]) != MEM))
 603     {
 604       cc_status.flags |= CC_REVERSED; /*|*/
 605       return "cmp%.b %d0,%d1";
 606     }
 607   return "cmp%.b %d1,%d0";
 608 })
 609
 610 (define_expand "cbranch<mode>4"
 611   [(set (cc0)
 612         (compare (match_operand:FP 1 "register_operand" "")
 613                  (match_operand:FP 2 "fp_src_operand" "")))
 614    (set (pc)
 615         (if_then_else (match_operator 0 "comparison_operator"
 616                        [(cc0) (const_int 0)])
 617                       (label_ref (match_operand 3 ""))
 618                       (pc)))]
 619   "TARGET_HARD_FLOAT"
 620   "")
 621
 622 (define_expand "cstore<mode>4"
 623   [(set (cc0)
 624         (compare (match_operand:FP 2 "register_operand" "")
 625                  (match_operand:FP 3 "fp_src_operand" "")))
 626    (set (match_operand:QI 0 "register_operand")
 627         (match_operator:QI 1 "m68k_cstore_comparison_operator"
 628          [(cc0) (const_int 0)]))]
 629   "TARGET_HARD_FLOAT && !(TUNE_68060 || TARGET_COLDFIRE_FPU)"
 630   "if (TARGET_COLDFIRE && operands[2] != const0_rtx)
 631      FAIL;")
 632
 633 (define_insn "*cmp<mode>_68881"
 634   [(set (cc0)
 635         (compare (match_operand:FP 0 "fp_src_operand" "f,f,<FP:dreg>mF")
 636                  (match_operand:FP 1 "fp_src_operand" "f,<FP:dreg>mF,f")))]
 637   "TARGET_68881
 638    && (register_operand (operands[0], <MODE>mode)
 639        || register_operand (operands[1], <MODE>mode))"
 640   "@
 641    fcmp%.x %1,%0
 642    fcmp%.<FP:prec> %f1,%0
 643    fcmp%.<FP:prec> %0,%f1"
 644   [(set_attr "type" "fcmp")])
 645
 646 (define_insn "*cmp<mode>_cf"
 647   [(set (cc0)
 648         (compare (match_operand:FP 0 "fp_src_operand" "f,f,<FP:dreg><Q>U")
 649                  (match_operand:FP 1 "fp_src_operand" "f,<FP:dreg><Q>U,f")))]
 650   "TARGET_COLDFIRE_FPU
 651    && (register_operand (operands[0], <MODE>mode)
 652        || register_operand (operands[1], <MODE>mode))"
 653   "@
 654    fcmp%.d %1,%0
 655    fcmp%.<FP:prec> %f1,%0
 656    fcmp%.<FP:prec> %0,%f1"
 657   [(set_attr "type" "fcmp")])
 658 \f
 659 ;; Recognizers for btst instructions.
 660
 661 ;; ColdFire/5200 only allows "<Q>" type addresses when the bit position is
 662 ;; specified as a constant, so we must disable all patterns that may extract
 663 ;; from a MEM at a constant bit position if we can't use this as a constraint.
 664
 665 (define_insn ""
 666   [(set
 667     (cc0)
 668     (compare (zero_extract:SI (match_operand:QI 0 "memory_src_operand" "oS")
 669                                (const_int 1)
 670                                (minus:SI (const_int 7)
 671                                          (match_operand:SI 1 "general_operand" "di")))
 672              (const_int 0)))]
 673   "!TARGET_COLDFIRE"
 674 {
 675   return output_btst (operands, operands[1], operands[0], insn, 7);
 676 })
 677
 678 ;; This is the same as the above pattern except for the constraints.  The 'i'
 679 ;; has been deleted.
 680
 681 (define_insn ""
 682   [(set
 683     (cc0)
 684     (compare (zero_extract:SI (match_operand:QI 0 "memory_operand" "o")
 685                                (const_int 1)
 686                                (minus:SI (const_int 7)
 687                                          (match_operand:SI 1 "general_operand" "d")))
 688              (const_int 0)))]
 689   "TARGET_COLDFIRE"
 690 {
 691   return output_btst (operands, operands[1], operands[0], insn, 7);
 692 })
 693
 694 (define_insn ""
 695   [(set
 696     (cc0)
 697     (compare (zero_extract:SI (match_operand:SI 0 "register_operand" "d")
 698                                (const_int 1)
 699                                (minus:SI (const_int 31)
 700                                          (match_operand:SI 1 "general_operand" "di")))
 701              (const_int 0)))]
 702   ""
 703 {
 704   return output_btst (operands, operands[1], operands[0], insn, 31);
 705 })
 706
 707 ;; The following two patterns are like the previous two
 708 ;; except that they use the fact that bit-number operands
 709 ;; are automatically masked to 3 or 5 bits.
 710
 711 (define_insn ""
 712   [(set
 713     (cc0)
 714     (compare (zero_extract:SI (match_operand:QI 0 "memory_operand" "o")
 715                                (const_int 1)
 716                                (minus:SI (const_int 7)
 717                                          (and:SI
 718                                           (match_operand:SI 1 "register_operand" "d")
 719                                           (const_int 7))))
 720              (const_int 0)))]
 721   ""
 722 {
 723   return output_btst (operands, operands[1], operands[0], insn, 7);
 724 })
 725
 726 (define_insn ""
 727   [(set
 728     (cc0)
 729     (compare (zero_extract:SI (match_operand:SI 0 "register_operand" "d")
 730                                (const_int 1)
 731                                (minus:SI (const_int 31)
 732                                          (and:SI
 733                                           (match_operand:SI 1 "register_operand" "d")
 734                                           (const_int 31))))
 735              (const_int 0)))]
 736   ""
 737 {
 738   return output_btst (operands, operands[1], operands[0], insn, 31);
 739 })
 740
 741 ;; Nonoffsettable mem refs are ok in this one pattern
 742 ;; since we don't try to adjust them.
 743 (define_insn ""
 744   [(set
 745     (cc0)
 746     (compare (zero_extract:SI (match_operand:QI 0 "memory_operand" "m")
 747                               (const_int 1)
 748                               (match_operand:SI 1 "const_int_operand" "n"))
 749              (const_int 0)))]
 750   "(unsigned) INTVAL (operands[1]) < 8 && !TARGET_COLDFIRE"
 751 {
 752   operands[1] = GEN_INT (7 - INTVAL (operands[1]));
 753   return output_btst (operands, operands[1], operands[0], insn, 7);
 754 })
 755
 756 (define_insn ""
 757   [(set
 758     (cc0)
 759     (compare (zero_extract:SI (match_operand:SI 0 "register_operand" "do")
 760                               (const_int 1)
 761                             (match_operand:SI 1 "const_int_operand" "n"))
 762              (const_int 0)))]
 763   "!TARGET_COLDFIRE"
 764 {
 765   if (GET_CODE (operands[0]) == MEM)
 766     {
 767       operands[0] = adjust_address (operands[0], QImode,
 768                                     INTVAL (operands[1]) / 8);
 769       operands[1] = GEN_INT (7 - INTVAL (operands[1]) % 8);
 770       return output_btst (operands, operands[1], operands[0], insn, 7);
 771     }
 772   operands[1] = GEN_INT (31 - INTVAL (operands[1]));
 773   return output_btst (operands, operands[1], operands[0], insn, 31);
 774 })
 775
 776 ;; This is the same as the above pattern except for the constraints.
 777 ;; The 'o' has been replaced with 'Q'.
 778
 779 (define_insn ""
 780   [(set
 781     (cc0)
 782     (compare (zero_extract:SI (match_operand:SI 0 "register_operand" "dQ")
 783                               (const_int 1)
 784                               (match_operand:SI 1 "const_int_operand" "n"))
 785              (const_int 0)))]
 786   "TARGET_COLDFIRE"
 787 {
 788   if (GET_CODE (operands[0]) == MEM)
 789     {
 790       operands[0] = adjust_address (operands[0], QImode,
 791                                     INTVAL (operands[1]) / 8);
 792       operands[1] = GEN_INT (7 - INTVAL (operands[1]) % 8);
 793       return output_btst (operands, operands[1], operands[0], insn, 7);
 794     }
 795   operands[1] = GEN_INT (31 - INTVAL (operands[1]));
 796   return output_btst (operands, operands[1], operands[0], insn, 31);
 797 })
 798
 799 \f
 800 ;; move instructions
 801
 802 ;; A special case in which it is not desirable
 803 ;; to reload the constant into a data register.
 804 (define_insn "pushexthisi_const"
 805   [(set (match_operand:SI 0 "push_operand" "=m,m,m")
 806         (match_operand:SI 1 "const_int_operand" "C0,R,J"))]
 807   "INTVAL (operands[1]) >= -0x8000 && INTVAL (operands[1]) < 0x8000"
 808   "@
 809    clr%.l %0
 810    mov3q%.l %1,%-
 811    pea %a1"
 812   [(set_attr "type" "clr_l,mov3q_l,pea")])
 813
 814 ;This is never used.
 815 ;(define_insn "swapsi"
 816 ;  [(set (match_operand:SI 0 "nonimmediate_operand" "+r")
 817 ;       (match_operand:SI 1 "general_operand" "+r"))
 818 ;   (set (match_dup 1) (match_dup 0))]
 819 ;  ""
 820 ;  "exg %1,%0")
 821
 822 ;; Special case of fullword move when source is zero for 68000_10.
 823 ;; moveq is faster on the 68000.
 824 (define_insn "*movsi_const0_68000_10"
 825   [(set (match_operand:SI 0 "movsi_const0_operand" "=d,a,g")
 826         (const_int 0))]
 827   "TUNE_68000_10"
 828   "@
 829    moveq #0,%0
 830    sub%.l %0,%0
 831    clr%.l %0"
 832   [(set_attr "type" "moveq_l,alu_l,clr_l")
 833    (set_attr "opy" "*,0,*")])
 834
 835 ;; Special case of fullword move when source is zero for 68040_60.
 836 ;; On the '040, 'subl an,an' takes 2 clocks while lea takes only 1
 837 (define_insn "*movsi_const0_68040_60"
 838   [(set (match_operand:SI 0 "movsi_const0_operand" "=a,g")
 839         (const_int 0))]
 840   "TUNE_68040_60"
 841 {
 842   if (which_alternative == 0)
 843     return MOTOROLA ? "lea 0.w,%0" : "lea 0:w,%0";
 844   else if (which_alternative == 1)
 845     return "clr%.l %0";
 846   else
 847     {
 848       gcc_unreachable ();
 849       return "";
 850     }
 851 }
 852   [(set_attr "type" "lea,clr_l")])
 853
 854 ;; Special case of fullword move when source is zero.
 855 (define_insn "*movsi_const0"
 856   [(set (match_operand:SI 0 "movsi_const0_operand" "=a,g")
 857         (const_int 0))]
 858   "!(TUNE_68000_10 || TUNE_68040_60)"
 859   "@
 860    sub%.l %0,%0
 861    clr%.l %0"
 862   [(set_attr "type" "alu_l,clr_l")
 863    (set_attr "opy" "0,*")])
 864
 865 ;; General case of fullword move.
 866 ;;
 867 ;; This is the main "hook" for PIC code.  When generating
 868 ;; PIC, movsi is responsible for determining when the source address
 869 ;; needs PIC relocation and appropriately calling legitimize_pic_address
 870 ;; to perform the actual relocation.
 871 ;;
 872 ;; In both the PIC and non-PIC cases the patterns generated will
 873 ;; matched by the next define_insn.
 874 (define_expand "movsi"
 875   [(set (match_operand:SI 0 "" "")
 876         (match_operand:SI 1 "" ""))]
 877   ""
 878 {
 879   rtx tmp, base, offset;
 880
 881   /* Recognize the case where operand[1] is a reference to thread-local
 882      data and load its address to a register.  */
 883   if (!TARGET_PCREL && m68k_tls_reference_p (operands[1], false))
 884     {
 885       rtx tmp = operands[1];
 886       rtx addend = NULL;
 887
 888       if (GET_CODE (tmp) == CONST && GET_CODE (XEXP (tmp, 0)) == PLUS)
 889         {
 890           addend = XEXP (XEXP (tmp, 0), 1);
 891           tmp = XEXP (XEXP (tmp, 0), 0);
 892         }
 893
 894       gcc_assert (GET_CODE (tmp) == SYMBOL_REF);
 895       gcc_assert (SYMBOL_REF_TLS_MODEL (tmp) != 0);
 896
 897       tmp = m68k_legitimize_tls_address (tmp);
 898
 899       if (addend)
 900         {
 901           if (!REG_P (tmp))
 902             {
 903               rtx reg;
 904
 905               reg = gen_reg_rtx (Pmode);
 906               emit_move_insn (reg, tmp);
 907               tmp = reg;
 908             }
 909
 910           tmp = gen_rtx_PLUS (SImode, tmp, addend);
 911         }
 912
 913       operands[1] = tmp;
 914     }
 915   else if (flag_pic && !TARGET_PCREL && symbolic_operand (operands[1], SImode))
 916     {
 917       /* The source is an address which requires PIC relocation.
 918          Call legitimize_pic_address with the source, mode, and a relocation
 919          register (a new pseudo, or the final destination if reload_in_progress
 920          is set).   Then fall through normally */
 921       rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
 922       operands[1] = legitimize_pic_address (operands[1], SImode, temp);
 923     }
 924   else if (flag_pic && TARGET_PCREL && ! reload_in_progress)
 925     {
 926       /* Don't allow writes to memory except via a register;
 927          the m68k doesn't consider PC-relative addresses to be writable.  */
 928       if (symbolic_operand (operands[0], SImode))
 929         operands[0] = force_reg (SImode, XEXP (operands[0], 0));
 930       else if (GET_CODE (operands[0]) == MEM
 931                && symbolic_operand (XEXP (operands[0], 0), SImode))
 932         operands[0] = gen_rtx_MEM (SImode,
 933                                force_reg (SImode, XEXP (operands[0], 0)));
 934     }
 935   if (M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P)
 936     {
 937       split_const (operands[1], &base, &offset);
 938       if (GET_CODE (base) == SYMBOL_REF
 939           && !offset_within_block_p (base, INTVAL (offset)))
 940         {
 941           tmp = !can_create_pseudo_p () ? operands[0] : gen_reg_rtx (SImode);
 942           emit_move_insn (tmp, base);
 943           emit_insn (gen_addsi3 (operands[0], tmp, offset));
 944           DONE;
 945         }
 946     }
 947 })
 948
 949 ;; General case of fullword move.
 950 (define_insn "*movsi_m68k"
 951   ;; Notes: make sure no alternative allows g vs g.
 952   ;; We don't allow f-regs since fixed point cannot go in them.
 953   [(set (match_operand:SI 0 "nonimmediate_operand" "=g,d,a<")
 954         (match_operand:SI 1 "general_src_operand" "damSnT,n,i"))]
 955   "!TARGET_COLDFIRE && reload_completed"
 956 {
 957   return output_move_simode (operands);
 958 })
 959
 960 ;; Before reload is completed the register constraints
 961 ;; force integer constants in range for a moveq to be reloaded
 962 ;; if they are headed for memory.
 963 (define_insn "*movsi_m68k2"
 964   [(set (match_operand:SI 0 "nonimmediate_operand" "=g,d,a<")
 965         (match_operand:SI 1 "general_src_operand" "damSKT,n,i"))]
 966
 967   "!TARGET_COLDFIRE"
 968 {
 969   return output_move_simode (operands);
 970 })
 971
 972 ;; ColdFire move instructions can have at most one operand of mode >= 6.
 973 (define_insn "*movsi_cf"
 974   [(set (match_operand:SI 0 "nonimmediate_operand" "=g,d, d, d, d, d, a,Ap,  a,  r<Q>,g,    U")
 975         (match_operand:SI 1 "general_operand"      " R,CQ,CW,CZ,CS,Ci,J,J Cs,Cs, g,   Rr<Q>,U"))]
 976   "TARGET_COLDFIRE"
 977 {
 978   switch (which_alternative)
 979     {
 980     case 0:
 981       return "mov3q%.l %1,%0";
 982
 983     case 1:
 984       return "moveq %1,%0";
 985
 986     case 2:
 987       {
 988         unsigned u = INTVAL (operands[1]);
 989
 990         operands[1] = GEN_INT ((u << 16) | (u >> 16));  /*|*/
 991         return "moveq %1,%0\n\tswap %0";
 992       }
 993
 994     case 3:
 995       return "mvz%.w %1,%0";
 996
 997     case 4:
 998       return "mvs%.w %1,%0";
 999
1000     case 5:
1001       return "move%.l %1,%0";
1002
1003     case 6:
1004       return "move%.w %1,%0";
1005
1006     case 7:
1007       return "pea %a1";
1008
1009     case 8:
1010       return "lea %a1,%0";
1011
1012     case 9:
1013     case 10:
1014     case 11:
1015       return "move%.l %1,%0";
1016
1017     default:
1018       gcc_unreachable ();
1019       return "";
1020     }
1021 }
1022   [(set_attr "type" "mov3q_l,moveq_l,*,mvsz,mvsz,move_l,move,pea,lea,move_l,move_l,move_l")])
1023
1024 ;; Special case of fullword move, where we need to get a non-GOT PIC
1025 ;; reference into an address register.
1026 (define_insn ""
1027   [(set (match_operand:SI 0 "nonimmediate_operand" "=a<")
1028         (match_operand:SI 1 "pcrel_address" ""))]
1029   "TARGET_PCREL"
1030 {
1031   if (push_operand (operands[0], SImode))
1032     return "pea %a1";
1033   return "lea %a1,%0";
1034 })
1035
1036 (define_expand "movhi"
1037   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1038         (match_operand:HI 1 "general_operand" ""))]
1039   ""
1040   "")
1041
1042 (define_insn ""
1043   [(set (match_operand:HI 0 "nonimmediate_operand" "=g")
1044         (match_operand:HI 1 "general_src_operand" "gS"))]
1045   "!TARGET_COLDFIRE"
1046   "* return output_move_himode (operands);")
1047
1048 (define_insn ""
1049   [(set (match_operand:HI 0 "nonimmediate_operand" "=r<Q>,g,U")
1050         (match_operand:HI 1 "general_operand" "g,r<Q>,U"))]
1051   "TARGET_COLDFIRE"
1052   "* return output_move_himode (operands);")
1053
1054 (define_expand "movstricthi"
1055   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" ""))
1056         (match_operand:HI 1 "general_src_operand" ""))]
1057   ""
1058   "")
1059
1060 (define_insn ""
1061   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
1062         (match_operand:HI 1 "general_src_operand" "rmSn"))]
1063   "!TARGET_COLDFIRE"
1064   "* return output_move_stricthi (operands);")
1065
1066 (define_insn ""
1067   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+d,m"))
1068         (match_operand:HI 1 "general_src_operand" "rmn,r"))]
1069   "TARGET_COLDFIRE"
1070   "* return output_move_stricthi (operands);")
1071
1072 (define_expand "movqi"
1073   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1074         (match_operand:QI 1 "general_src_operand" ""))]
1075   ""
1076   "")
1077
1078 (define_insn ""
1079   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,*a,m")
1080         (match_operand:QI 1 "general_src_operand" "dmSi*a,di*a,dmSi"))]
1081   "!TARGET_COLDFIRE"
1082   "* return output_move_qimode (operands);")
1083
1084 (define_insn ""
1085   [(set (match_operand:QI 0 "nonimmediate_operand" "=d<Q>,dm,U,d*a")
1086         (match_operand:QI 1 "general_src_operand" "dmi,d<Q>,U,di*a"))]
1087   "TARGET_COLDFIRE"
1088   "* return output_move_qimode (operands);")
1089
1090 (define_expand "movstrictqi"
1091   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" ""))
1092         (match_operand:QI 1 "general_src_operand" ""))]
1093   ""
1094   "")
1095
1096 (define_insn ""
1097   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
1098         (match_operand:QI 1 "general_src_operand" "dmSn"))]
1099   "!TARGET_COLDFIRE"
1100   "* return output_move_strictqi (operands);")
1101
1102 (define_insn "*movstrictqi_cf"
1103   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+d, Ac, d,m"))
1104         (match_operand:QI 1 "general_src_operand"                    "C0,C0, dmn,d"))]
1105   "TARGET_COLDFIRE"
1106   "@
1107    clr%.b %0
1108    clr%.b %0
1109    move%.b %1,%0
1110    move%.b %1,%0"
1111   [(set_attr "type" "clr,clr,move,move")])
1112
1113 (define_expand "pushqi1"
1114   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -2)))
1115    (set (mem:QI (plus:SI (reg:SI SP_REG) (const_int 1)))
1116         (match_operand:QI 0 "general_operand" ""))]
1117   "!TARGET_COLDFIRE"
1118   "")
1119
1120 (define_expand "reload_insf"
1121   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
1122         (match_operand:SF 1 "general_operand" "mf"))
1123    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
1124   "TARGET_COLDFIRE_FPU"
1125 {
1126   if (emit_move_sequence (operands, SFmode, operands[2]))
1127     DONE;
1128
1129   /* We don't want the clobber emitted, so handle this ourselves. */
1130   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
1131   DONE;
1132 })
1133
1134 (define_expand "reload_outsf"
1135   [(set (match_operand:SF 0 "general_operand" "")
1136         (match_operand:SF 1 "register_operand" "f"))
1137    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
1138   "TARGET_COLDFIRE_FPU"
1139 {
1140   if (emit_move_sequence (operands, SFmode, operands[2]))
1141     DONE;
1142
1143   /* We don't want the clobber emitted, so handle this ourselves. */
1144   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
1145   DONE;
1146 })
1147
1148 (define_expand "movsf"
1149   [(set (match_operand:SF 0 "nonimmediate_operand" "")
1150         (match_operand:SF 1 "general_operand" ""))]
1151   ""
1152   "")
1153
1154 (define_insn ""
1155   [(set (match_operand:SF 0 "nonimmediate_operand" "=rmf")
1156         (match_operand:SF 1 "general_operand" "rmfF"))]
1157   "!TARGET_COLDFIRE"
1158 {
1159   if (FP_REG_P (operands[0]))
1160     {
1161       if (FP_REG_P (operands[1]))
1162         return "f%$move%.x %1,%0";
1163       else if (ADDRESS_REG_P (operands[1]))
1164         return "move%.l %1,%-\;f%$move%.s %+,%0";
1165       else if (GET_CODE (operands[1]) == CONST_DOUBLE)
1166         return output_move_const_single (operands);
1167       return "f%$move%.s %f1,%0";
1168     }
1169   if (FP_REG_P (operands[1]))
1170     {
1171       if (ADDRESS_REG_P (operands[0]))
1172         return "fmove%.s %1,%-\;move%.l %+,%0";
1173       return "fmove%.s %f1,%0";
1174     }
1175   if (operands[1] == CONST0_RTX (SFmode)
1176       /* clr insns on 68000 read before writing.  */
1177       && ((TARGET_68010 || TARGET_COLDFIRE)
1178           || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))))
1179     {
1180       if (ADDRESS_REG_P (operands[0]))
1181         {
1182           /* On the '040, 'subl an,an' takes 2 clocks while lea takes only 1 */
1183           if (TUNE_68040_60)
1184             return MOTOROLA ? "lea 0.w,%0" : "lea 0:w,%0";
1185           else
1186             return "sub%.l %0,%0";
1187         }
1188       /* moveq is faster on the 68000.  */
1189       if (DATA_REG_P (operands[0]) && TUNE_68000_10)
1190         return "moveq #0,%0";
1191       return "clr%.l %0";
1192     }
1193   return "move%.l %1,%0";
1194 })
1195
1196 (define_insn "movsf_cf_soft"
1197   [(set (match_operand:SF 0 "nonimmediate_operand" "=r<Q>,g,U")
1198         (match_operand:SF 1 "general_operand" "g,r<Q>,U"))]
1199   "TARGET_COLDFIRE && !TARGET_COLDFIRE_FPU"
1200   "move%.l %1,%0"
1201   [(set_attr "type" "move_l")])
1202
1203 ;; SFmode MEMs are restricted to modes 2-4 if TARGET_COLDFIRE_FPU.
1204 ;; The move instructions can handle all combinations.
1205 (define_insn "movsf_cf_hard"
1206   [(set (match_operand:SF 0 "nonimmediate_operand" "=r<Q>U, f,    f,mr,f,r<Q>,f
1207 ,m")
1208         (match_operand:SF 1 "general_operand"      " f,     r<Q>U,f,rm,F,F,   m
1209 ,f"))]
1210   "TARGET_COLDFIRE_FPU"
1211 {
1212   if (which_alternative == 4 || which_alternative == 5) {
1213     rtx xoperands[2];
1214     REAL_VALUE_TYPE r;
1215     long l;
1216     REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
1217     REAL_VALUE_TO_TARGET_SINGLE (r, l);
1218     xoperands[0] = operands[0];
1219     xoperands[1] = GEN_INT (l);
1220     if (which_alternative == 5) {
1221       if (l == 0) {
1222         if (ADDRESS_REG_P (xoperands[0]))
1223           output_asm_insn ("sub%.l %0,%0", xoperands);
1224         else
1225           output_asm_insn ("clr%.l %0", xoperands);
1226       } else
1227         if (GET_CODE (operands[0]) == MEM
1228             && symbolic_operand (XEXP (operands[0], 0), SImode))
1229           output_asm_insn ("move%.l %1,%-;move%.l %+,%0", xoperands);
1230         else
1231           output_asm_insn ("move%.l %1,%0", xoperands);
1232       return "";
1233     }
1234     if (l != 0)
1235       output_asm_insn ("move%.l %1,%-;fsmove%.s %+,%0", xoperands);
1236     else
1237       output_asm_insn ("clr%.l %-;fsmove%.s %+,%0", xoperands);
1238     return "";
1239   }
1240   if (FP_REG_P (operands[0]))
1241     {
1242       if (ADDRESS_REG_P (operands[1]))
1243         return "move%.l %1,%-;fsmove%.s %+,%0";
1244       if (FP_REG_P (operands[1]))
1245         return "fsmove%.d %1,%0";
1246       return "fsmove%.s %f1,%0";
1247     }
1248   if (FP_REG_P (operands[1]))
1249     {
1250       if (ADDRESS_REG_P (operands[0]))
1251         return "fmove%.s %1,%-;move%.l %+,%0";
1252       return "fmove%.s %f1,%0";
1253     }
1254   if (operands[1] == CONST0_RTX (SFmode))
1255     {
1256       if (ADDRESS_REG_P (operands[0]))
1257         return "sub%.l %0,%0";
1258       return "clr%.l %0";
1259     }
1260   return "move%.l %1,%0";
1261 })
1262
1263 (define_expand "reload_indf"
1264   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
1265         (match_operand:DF 1 "general_operand" "mf"))
1266    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
1267   "TARGET_COLDFIRE_FPU"
1268 {
1269   if (emit_move_sequence (operands, DFmode, operands[2]))
1270     DONE;
1271
1272   /* We don't want the clobber emitted, so handle this ourselves. */
1273   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
1274   DONE;
1275 })
1276
1277 (define_expand "reload_outdf"
1278   [(set (match_operand:DF 0 "general_operand" "")
1279         (match_operand:DF 1 "register_operand" "f"))
1280    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
1281   "TARGET_COLDFIRE_FPU"
1282 {
1283   if (emit_move_sequence (operands, DFmode, operands[2]))
1284     DONE;
1285
1286   /* We don't want the clobber emitted, so handle this ourselves. */
1287   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
1288   DONE;
1289 })
1290
1291 (define_expand "movdf"
1292   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1293         (match_operand:DF 1 "general_operand" ""))]
1294   ""
1295 {
1296   if (TARGET_COLDFIRE_FPU)
1297     if (emit_move_sequence (operands, DFmode, 0))
1298       DONE;
1299 })
1300
1301 (define_insn ""
1302   [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,rf,rf,&rof<>")
1303         (match_operand:DF 1 "general_operand" "*rf,m,0,*rofE<>"))]
1304 ;  [(set (match_operand:DF 0 "nonimmediate_operand" "=rm,&rf,&rof<>")
1305 ;       (match_operand:DF 1 "general_operand" "rf,m,rofF<>"))]
1306   "!TARGET_COLDFIRE"
1307 {
1308   if (FP_REG_P (operands[0]))
1309     {
1310       if (FP_REG_P (operands[1]))
1311         return "f%&move%.x %1,%0";
1312       if (REG_P (operands[1]))
1313         {
1314           rtx xoperands[2];
1315           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1316           output_asm_insn ("move%.l %1,%-", xoperands);
1317           output_asm_insn ("move%.l %1,%-", operands);
1318           return "f%&move%.d %+,%0";
1319         }
1320       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1321         return output_move_const_double (operands);
1322       return "f%&move%.d %f1,%0";
1323     }
1324   else if (FP_REG_P (operands[1]))
1325     {
1326       if (REG_P (operands[0]))
1327         {
1328           output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
1329           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1330           return "move%.l %+,%0";
1331         }
1332       else
1333         return "fmove%.d %f1,%0";
1334     }
1335   return output_move_double (operands);
1336 })
1337
1338 (define_insn_and_split "movdf_cf_soft"
1339   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,g")
1340         (match_operand:DF 1 "general_operand" "g,r"))]
1341   "TARGET_COLDFIRE && !TARGET_COLDFIRE_FPU"
1342   "#"
1343   "&& reload_completed"
1344   [(const_int 0)]
1345 {
1346   m68k_emit_move_double (operands);
1347   DONE;
1348 })
1349
1350 (define_insn "movdf_cf_hard"
1351   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,    <Q>U,r,f,r,r,m,f")
1352         (match_operand:DF 1 "general_operand"      " f<Q>U,f,   f,r,r,m,r,E"))]
1353   "TARGET_COLDFIRE_FPU"
1354 {
1355   rtx xoperands[3];
1356   REAL_VALUE_TYPE r;
1357   long l[2];
1358
1359   switch (which_alternative)
1360     {
1361     default:
1362       return "fdmove%.d %1,%0";
1363     case 1:
1364       return "fmove%.d %1,%0";
1365     case 2:
1366       return "fmove%.d %1,%-;move%.l %+,%0;move%.l %+,%R0";
1367     case 3:
1368       return "move%.l %R1,%-;move%.l %1,%-;fdmove%.d %+,%0";
1369     case 4: case 5: case 6:
1370       return output_move_double (operands);
1371     case 7:
1372       REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
1373       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
1374       xoperands[0] = operands[0];
1375       xoperands[1] = GEN_INT (l[0]);
1376       xoperands[2] = GEN_INT (l[1]);
1377       if (operands[1] == CONST0_RTX (DFmode))
1378         output_asm_insn ("clr%.l %-;clr%.l %-;fdmove%.d %+,%0",
1379                         xoperands);
1380       else
1381         if (l[1] == 0)
1382           output_asm_insn ("clr%.l %-;move%.l %1,%-;fdmove%.d %+,%0",
1383                           xoperands);
1384         else
1385           output_asm_insn ("move%.l %2,%-;move%.l %1,%-;fdmove%.d %+,%0",
1386                           xoperands);
1387       return "";
1388     }
1389 })
1390
1391 ;; ??? The XFmode patterns are schizophrenic about whether constants are
1392 ;; allowed.  Most but not all have predicates and constraint that disallow
1393 ;; constants.  Most but not all have output templates that handle constants.
1394 ;; See also TARGET_LEGITIMATE_CONSTANT_P.
1395
1396 (define_expand "movxf"
1397   [(set (match_operand:XF 0 "nonimmediate_operand" "")
1398         (match_operand:XF 1 "general_operand" ""))]
1399   ""
1400 {
1401   /* We can't rewrite operands during reload.  */
1402   if (! reload_in_progress)
1403     {
1404       if (CONSTANT_P (operands[1]))
1405         {
1406           operands[1] = force_const_mem (XFmode, operands[1]);
1407           if (! memory_address_p (XFmode, XEXP (operands[1], 0)))
1408             operands[1] = adjust_address (operands[1], XFmode, 0);
1409         }
1410       if (flag_pic && TARGET_PCREL)
1411         {
1412           /* Don't allow writes to memory except via a register; the
1413              m68k doesn't consider PC-relative addresses to be writable.  */
1414           if (GET_CODE (operands[0]) == MEM
1415               && symbolic_operand (XEXP (operands[0], 0), SImode))
1416             operands[0] = gen_rtx_MEM (XFmode,
1417                                    force_reg (SImode, XEXP (operands[0], 0)));
1418         }
1419     }
1420 })
1421
1422 (define_insn ""
1423   [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,!r,!f,!r,m,!r")
1424         (match_operand:XF 1 "nonimmediate_operand" "m,f,f,f,r,!r,!r,m"))]
1425   "TARGET_68881"
1426 {
1427   if (FP_REG_P (operands[0]))
1428     {
1429       if (FP_REG_P (operands[1]))
1430         return "fmove%.x %1,%0";
1431       if (REG_P (operands[1]))
1432         {
1433           rtx xoperands[2];
1434           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1435           output_asm_insn ("move%.l %1,%-", xoperands);
1436           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1437           output_asm_insn ("move%.l %1,%-", xoperands);
1438           output_asm_insn ("move%.l %1,%-", operands);
1439           return "fmove%.x %+,%0";
1440         }
1441       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1442         return "fmove%.x %1,%0";
1443       return "fmove%.x %f1,%0";
1444     }
1445   if (FP_REG_P (operands[1]))
1446     {
1447       if (REG_P (operands[0]))
1448         {
1449           output_asm_insn ("fmove%.x %f1,%-\;move%.l %+,%0", operands);
1450           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1451           output_asm_insn ("move%.l %+,%0", operands);
1452           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1453           return "move%.l %+,%0";
1454         }
1455       /* Must be memory destination.  */
1456       return "fmove%.x %f1,%0";
1457     }
1458   return output_move_double (operands);
1459 })
1460
1461 (define_insn ""
1462   [(set (match_operand:XF 0 "nonimmediate_operand" "=rm,rf,&rof<>")
1463         (match_operand:XF 1 "nonimmediate_operand" "rf,m,rof<>"))]
1464   "! TARGET_68881 && ! TARGET_COLDFIRE"
1465 {
1466   if (FP_REG_P (operands[0]))
1467     {
1468       if (FP_REG_P (operands[1]))
1469         return "fmove%.x %1,%0";
1470       if (REG_P (operands[1]))
1471         {
1472           rtx xoperands[2];
1473           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
1474           output_asm_insn ("move%.l %1,%-", xoperands);
1475           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1476           output_asm_insn ("move%.l %1,%-", xoperands);
1477           output_asm_insn ("move%.l %1,%-", operands);
1478           return "fmove%.x %+,%0";
1479         }
1480       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1481         return "fmove%.x %1,%0";
1482       return "fmove%.x %f1,%0";
1483     }
1484   if (FP_REG_P (operands[1]))
1485     {
1486       if (REG_P (operands[0]))
1487         {
1488           output_asm_insn ("fmove%.x %f1,%-\;move%.l %+,%0", operands);
1489           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1490           output_asm_insn ("move%.l %+,%0", operands);
1491           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1492           return "move%.l %+,%0";
1493         }
1494       else
1495         return "fmove%.x %f1,%0";
1496     }
1497   return output_move_double (operands);
1498 })
1499
1500 (define_insn ""
1501   [(set (match_operand:XF 0 "nonimmediate_operand" "=r,g")
1502         (match_operand:XF 1 "nonimmediate_operand" "g,r"))]
1503   "! TARGET_68881 && TARGET_COLDFIRE"
1504   "* return output_move_double (operands);")
1505
1506 (define_expand "movdi"
1507   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1508   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1509         (match_operand:DI 1 "general_operand" ""))]
1510   ""
1511   "")
1512
1513 ;; movdi can apply to fp regs in some cases
1514 (define_insn ""
1515   ;; Let's see if it really still needs to handle fp regs, and, if so, why.
1516   [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,r,&ro<>")
1517         (match_operand:DI 1 "general_operand" "rF,m,roi<>F"))]
1518 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&r,&ro<>,!&rm,!&f")
1519 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF"))]
1520 ;  [(set (match_operand:DI 0 "nonimmediate_operand" "=rm,&rf,&ro<>,!&rm,!&f")
1521 ;       (match_operand:DI 1 "general_operand" "r,m,roi<>,fF,rfF"))]
1522   "!TARGET_COLDFIRE"
1523 {
1524   if (FP_REG_P (operands[0]))
1525     {
1526       if (FP_REG_P (operands[1]))
1527         return "fmove%.x %1,%0";
1528       if (REG_P (operands[1]))
1529         {
1530           rtx xoperands[2];
1531           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
1532           output_asm_insn ("move%.l %1,%-", xoperands);
1533           output_asm_insn ("move%.l %1,%-", operands);
1534           return "fmove%.d %+,%0";
1535         }
1536       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1537         return output_move_const_double (operands);
1538       return "fmove%.d %f1,%0";
1539     }
1540   else if (FP_REG_P (operands[1]))
1541     {
1542       if (REG_P (operands[0]))
1543         {
1544           output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
1545           operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1546           return "move%.l %+,%0";
1547         }
1548       else
1549         return "fmove%.d %f1,%0";
1550     }
1551   return output_move_double (operands);
1552 })
1553
1554 (define_insn ""
1555   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,g")
1556         (match_operand:DI 1 "general_operand" "g,r"))]
1557   "TARGET_COLDFIRE"
1558   "* return output_move_double (operands);")
1559
1560 ;; Thus goes after the move instructions
1561 ;; because the move instructions are better (require no spilling)
1562 ;; when they can apply.  It goes before the add/sub insns
1563 ;; so we will prefer it to them.
1564
1565 (define_insn "pushasi"
1566   [(set (match_operand:SI 0 "push_operand" "=m")
1567         (match_operand:SI 1 "address_operand" "p"))]
1568   ""
1569   "pea %a1"
1570   [(set_attr "type" "pea")])
1571 \f
1572 ;; truncation instructions
1573 (define_insn "truncsiqi2"
1574   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1575         (truncate:QI
1576          (match_operand:SI 1 "general_src_operand" "doJS,i")))]
1577   ""
1578 {
1579   if (GET_CODE (operands[0]) == REG)
1580     {
1581       /* Must clear condition codes, since the move.l bases them on
1582          the entire 32 bits, not just the desired 8 bits.  */
1583       CC_STATUS_INIT;
1584       return "move%.l %1,%0";
1585     }
1586   if (GET_CODE (operands[1]) == MEM)
1587     operands[1] = adjust_address (operands[1], QImode, 3);
1588   return "move%.b %1,%0";
1589 })
1590
1591 (define_insn "trunchiqi2"
1592   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,d")
1593         (truncate:QI
1594          (match_operand:HI 1 "general_src_operand" "doJS,i")))]
1595   ""
1596 {
1597   if (GET_CODE (operands[0]) == REG
1598       && (GET_CODE (operands[1]) == MEM
1599           || GET_CODE (operands[1]) == CONST_INT))
1600     {
1601       /* Must clear condition codes, since the move.w bases them on
1602          the entire 16 bits, not just the desired 8 bits.  */
1603       CC_STATUS_INIT;
1604       return "move%.w %1,%0";
1605     }
1606   if (GET_CODE (operands[0]) == REG)
1607     {
1608       /* Must clear condition codes, since the move.l bases them on
1609          the entire 32 bits, not just the desired 8 bits.  */
1610       CC_STATUS_INIT;
1611       return "move%.l %1,%0";
1612     }
1613   if (GET_CODE (operands[1]) == MEM)
1614     operands[1] = adjust_address (operands[1], QImode, 1);
1615   return "move%.b %1,%0";
1616 })
1617
1618 (define_insn "truncsihi2"
1619   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm,d")
1620         (truncate:HI
1621          (match_operand:SI 1 "general_src_operand" "roJS,i")))]
1622   ""
1623 {
1624   if (GET_CODE (operands[0]) == REG)
1625     {
1626       /* Must clear condition codes, since the move.l bases them on
1627          the entire 32 bits, not just the desired 8 bits.  */
1628       CC_STATUS_INIT;
1629       return "move%.l %1,%0";
1630     }
1631   if (GET_CODE (operands[1]) == MEM)
1632     operands[1] = adjust_address (operands[1], QImode, 2);
1633   return "move%.w %1,%0";
1634 })
1635 \f
1636 ;; zero extension instructions
1637
1638 ;; two special patterns to match various post_inc/pre_dec patterns
1639 (define_insn_and_split "*zero_extend_inc"
1640   [(set (match_operand 0 "post_inc_operand" "")
1641         (zero_extend (match_operand 1 "register_operand" "")))]
1642   "GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT &&
1643    GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT &&
1644    GET_MODE_SIZE (GET_MODE (operands[0])) == GET_MODE_SIZE (GET_MODE (operands[1])) * 2"
1645   "#"
1646   ""
1647   [(set (match_dup 0)
1648         (const_int 0))
1649    (set (match_dup 0)
1650         (match_dup 1))]
1651 {
1652   operands[0] = adjust_address (operands[0], GET_MODE (operands[1]), 0);
1653 })
1654
1655 (define_insn_and_split "*zero_extend_dec"
1656   [(set (match_operand 0 "pre_dec_operand" "")
1657         (zero_extend (match_operand 1 "register_operand" "")))]
1658   "(GET_MODE (operands[0]) != HImode || XEXP (XEXP (operands[0], 0), 0) != stack_pointer_rtx) &&
1659    GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT &&
1660    GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT &&
1661    GET_MODE_SIZE (GET_MODE (operands[0])) == GET_MODE_SIZE (GET_MODE (operands[1])) * 2"
1662   "#"
1663   ""
1664   [(set (match_dup 0)
1665         (match_dup 1))
1666    (set (match_dup 0)
1667         (const_int 0))]
1668 {
1669   operands[0] = adjust_address (operands[0], GET_MODE (operands[1]), 0);
1670 })
1671
1672 (define_insn_and_split "zero_extendqidi2"
1673   [(set (match_operand:DI 0 "register_operand" "")
1674         (zero_extend:DI (match_operand:QI 1 "nonimmediate_src_operand" "")))]
1675   ""
1676   "#"
1677   ""
1678   [(set (match_dup 2)
1679         (zero_extend:SI (match_dup 1)))
1680    (set (match_dup 3)
1681         (const_int 0))]
1682 {
1683   operands[2] = gen_lowpart (SImode, operands[0]);
1684   operands[3] = gen_highpart (SImode, operands[0]);
1685 })
1686
1687 (define_insn_and_split "zero_extendhidi2"
1688   [(set (match_operand:DI 0 "register_operand" "")
1689         (zero_extend:DI (match_operand:HI 1 "nonimmediate_src_operand" "")))]
1690   ""
1691   "#"
1692   ""
1693   [(set (match_dup 2)
1694         (zero_extend:SI (match_dup 1)))
1695    (set (match_dup 3)
1696         (const_int 0))]
1697 {
1698   operands[2] = gen_lowpart (SImode, operands[0]);
1699   operands[3] = gen_highpart (SImode, operands[0]);
1700 })
1701
1702 (define_expand "zero_extendsidi2"
1703   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1704         (zero_extend:DI (match_operand:SI 1 "nonimmediate_src_operand" "")))]
1705   ""
1706 {
1707   if (GET_CODE (operands[0]) == MEM
1708       && GET_CODE (operands[1]) == MEM)
1709     operands[1] = force_reg (SImode, operands[1]);
1710 })
1711
1712 (define_insn_and_split "*zero_extendsidi2"
1713   [(set (match_operand:DI 0 "nonimmediate_operand" "")
1714         (zero_extend:DI (match_operand:SI 1 "nonimmediate_src_operand" "")))]
1715   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
1716   "#"
1717   ""
1718   [(set (match_dup 2)
1719         (match_dup 1))
1720    (set (match_dup 3)
1721         (const_int 0))]
1722 {
1723   operands[2] = gen_lowpart (SImode, operands[0]);
1724   operands[3] = gen_highpart (SImode, operands[0]);
1725 })
1726
1727 (define_insn "*zero_extendhisi2_cf"
1728   [(set (match_operand:SI 0 "register_operand" "=d")
1729         (zero_extend:SI (match_operand:HI 1 "nonimmediate_src_operand" "rmS")))]
1730   "ISA_HAS_MVS_MVZ"
1731   "mvz%.w %1,%0"
1732   [(set_attr "type" "mvsz")])
1733
1734 (define_insn "zero_extendhisi2"
1735   [(set (match_operand:SI 0 "register_operand" "=d")
1736         (zero_extend:SI (match_operand:HI 1 "nonimmediate_src_operand" "rmS")))]
1737   ""
1738   "#")
1739
1740 (define_expand "zero_extendqihi2"
1741   [(set (match_operand:HI 0 "register_operand" "")
1742         (zero_extend:HI (match_operand:QI 1 "nonimmediate_src_operand" "")))]
1743   "!TARGET_COLDFIRE"
1744   "")
1745
1746 (define_insn "*zero_extendqihi2"
1747   [(set (match_operand:HI 0 "register_operand" "=d")
1748         (zero_extend:HI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1749   "!TARGET_COLDFIRE"
1750   "#")
1751
1752 (define_insn "*zero_extendqisi2_cfv4"
1753   [(set (match_operand:SI 0 "register_operand" "=d")
1754         (zero_extend:SI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1755   "ISA_HAS_MVS_MVZ"
1756   "mvz%.b %1,%0"
1757   [(set_attr "type" "mvsz")])
1758
1759 (define_insn "zero_extendqisi2"
1760   [(set (match_operand:SI 0 "register_operand" "=d")
1761         (zero_extend:SI (match_operand:QI 1 "nonimmediate_src_operand" "dmS")))]
1762   ""
1763   "#")
1764
1765 ;; these two pattern split everything else which isn't matched by
1766 ;; something else above
1767 (define_split
1768   [(set (match_operand 0 "register_operand" "")
1769         (zero_extend (match_operand 1 "nonimmediate_src_operand" "")))]
1770   "!ISA_HAS_MVS_MVZ
1771    && reload_completed
1772    && reg_mentioned_p (operands[0], operands[1])"
1773   [(set (strict_low_part (match_dup 2))
1774         (match_dup 1))
1775    (set (match_dup 0)
1776         (match_op_dup 4 [(match_dup 0) (match_dup 3)]))]
1777 {
1778   operands[2] = gen_lowpart (GET_MODE (operands[1]), operands[0]);
1779   operands[3] = GEN_INT (GET_MODE_MASK (GET_MODE (operands[1])));
1780   operands[4] = gen_rtx_AND (GET_MODE (operands[0]), operands[0], operands[3]);
1781 })
1782
1783 (define_split
1784   [(set (match_operand 0 "register_operand" "")
1785         (zero_extend (match_operand 1 "nonimmediate_src_operand" "")))]
1786   "!ISA_HAS_MVS_MVZ && reload_completed"
1787   [(set (match_dup 0)
1788         (const_int 0))
1789    (set (strict_low_part (match_dup 2))
1790         (match_dup 1))]
1791 {
1792   operands[2] = gen_lowpart (GET_MODE (operands[1]), operands[0]);
1793 })
1794 \f
1795 ;; sign extension instructions
1796
1797 (define_insn "extendqidi2"
1798   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1799         (sign_extend:DI (match_operand:QI 1 "general_src_operand" "rmS")))]
1800   ""
1801 {
1802   CC_STATUS_INIT;
1803   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1804   if (ISA_HAS_MVS_MVZ)
1805     return "mvs%.b %1,%2\;smi %0\;extb%.l %0";
1806   if (TARGET_68020 || TARGET_COLDFIRE)
1807     {
1808       if (ADDRESS_REG_P (operands[1]))
1809         return "move%.w %1,%2\;extb%.l %2\;smi %0\;extb%.l %0";
1810       else
1811         return "move%.b %1,%2\;extb%.l %2\;smi %0\;extb%.l %0";
1812     }
1813   else
1814     {
1815       if (ADDRESS_REG_P (operands[1]))
1816         return "move%.w %1,%2\;ext%.w %2\;ext%.l %2\;move%.l %2,%0\;smi %0";
1817       else
1818         return "move%.b %1,%2\;ext%.w %2\;ext%.l %2\;move%.l %2,%0\;smi %0";
1819     }
1820 })
1821
1822 (define_insn "extendhidi2"
1823   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
1824         (sign_extend:DI
1825          (match_operand:HI 1 "general_src_operand" "rmS")))]
1826   ""
1827 {
1828   CC_STATUS_INIT;
1829   operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1830   if (ISA_HAS_MVS_MVZ)
1831     return "mvs%.w %1,%2\;smi %0\;extb%.l %0";
1832   if (TARGET_68020 || TARGET_COLDFIRE)
1833     return "move%.w %1,%2\;ext%.l %2\;smi %0\;extb%.l %0";
1834   else
1835     return "move%.w %1,%2\;ext%.l %2\;smi %0\;ext%.w %0\;ext%.l %0";
1836 })
1837
1838 (define_insn "extendsidi2"
1839   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,o,o,<")
1840         (sign_extend:DI
1841          (match_operand:SI 1 "nonimmediate_src_operand" "rm,rm,r<Q>,rm")))
1842    (clobber (match_scratch:SI 2 "=X,d,d,d"))]
1843   ""
1844 {
1845   CC_STATUS_INIT;
1846
1847   if (which_alternative == 0)
1848     /* Handle alternative 0.  */
1849     {
1850       if (TARGET_68020 || TARGET_COLDFIRE)
1851         return "move%.l %1,%R0\;smi %0\;extb%.l %0";
1852       else
1853         return "move%.l %1,%R0\;smi %0\;ext%.w %0\;ext%.l %0";
1854     }
1855
1856   /* Handle alternatives 1, 2 and 3.  We don't need to adjust address by 4
1857      in alternative 3 because autodecrement will do that for us.  */
1858   operands[3] = adjust_address (operands[0], SImode,
1859                                 which_alternative == 3 ? 0 : 4);
1860   operands[0] = adjust_address (operands[0], SImode, 0);
1861
1862   if (TARGET_68020 || TARGET_COLDFIRE)
1863     return "move%.l %1,%3\;smi %2\;extb%.l %2\;move%.l %2,%0";
1864   else
1865     return "move%.l %1,%3\;smi %2\;ext%.w %2\;ext%.l %2\;move%.l %2,%0";
1866 }
1867   [(set_attr "ok_for_coldfire" "yes,no,yes,yes")])
1868
1869 ;; Special case when one can avoid register clobbering, copy and test
1870 ;; Maybe there is a way to make that the general case, by forcing the
1871 ;; result of the SI tree to be in the lower register of the DI target
1872
1873 (define_insn "extendplussidi"
1874   [(set (match_operand:DI 0 "register_operand" "=d")
1875     (sign_extend:DI (plus:SI (match_operand:SI 1 "general_operand" "%rmn")
1876             (match_operand:SI 2 "general_operand" "rmn"))))]
1877   ""
1878 {
1879   CC_STATUS_INIT;
1880   operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1881   if (GET_CODE (operands[1]) == CONST_INT
1882   && (unsigned) INTVAL (operands[1]) > 8)
1883     {
1884       rtx tmp = operands[1];
1885
1886       operands[1] = operands[2];
1887       operands[2] = tmp;
1888     }
1889   if (GET_CODE (operands[1]) == REG
1890       && REGNO (operands[1]) == REGNO (operands[3]))
1891     output_asm_insn ("add%.l %2,%3", operands);
1892   else
1893     output_asm_insn ("move%.l %2,%3\;add%.l %1,%3", operands);
1894   if (TARGET_68020 || TARGET_COLDFIRE)
1895     return "smi %0\;extb%.l %0";
1896   else
1897     return "smi %0\;ext%.w %0\;ext%.l %0";
1898 })
1899
1900 (define_expand "extendhisi2"
1901   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1902         (sign_extend:SI
1903          (match_operand:HI 1 "nonimmediate_src_operand" "")))]
1904   ""
1905   "")
1906
1907 (define_insn "*cfv4_extendhisi2"
1908   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
1909         (sign_extend:SI
1910          (match_operand:HI 1 "nonimmediate_src_operand" "rmS")))]
1911   "ISA_HAS_MVS_MVZ"
1912   "mvs%.w %1,%0"
1913   [(set_attr "type" "mvsz")])
1914
1915 (define_insn "*68k_extendhisi2"
1916   [(set (match_operand:SI 0 "nonimmediate_operand" "=*d,a")
1917         (sign_extend:SI
1918          (match_operand:HI 1 "nonimmediate_src_operand" "0,rmS")))]
1919   "!ISA_HAS_MVS_MVZ"
1920   "@
1921    ext%.l %0
1922    move%.w %1,%0"
1923   [(set_attr "type" "ext,move")])
1924
1925 (define_insn "extendqihi2"
1926   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
1927         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "0")))]
1928   ""
1929   "ext%.w %0"
1930   [(set_attr "type" "ext")])
1931
1932 (define_expand "extendqisi2"
1933   [(set (match_operand:SI 0 "nonimmediate_operand" "")
1934         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "")))]
1935   "TARGET_68020 || TARGET_COLDFIRE"
1936   "")
1937
1938 (define_insn "*cfv4_extendqisi2"
1939   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
1940         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "rms")))]
1941   "ISA_HAS_MVS_MVZ"
1942   "mvs%.b %1,%0"
1943   [(set_attr "type" "mvsz")])
1944
1945 (define_insn "*68k_extendqisi2"
1946   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
1947         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "0")))]
1948   "TARGET_68020 || (TARGET_COLDFIRE && !ISA_HAS_MVS_MVZ)"
1949   "extb%.l %0"
1950   [(set_attr "type" "ext")])
1951 \f
1952 ;; Conversions between float and double.
1953
1954 (define_expand "extendsfdf2"
1955   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1956         (float_extend:DF
1957          (match_operand:SF 1 "general_operand" "")))]
1958   "TARGET_HARD_FLOAT"
1959   "")
1960
1961 (define_insn ""
1962   [(set (match_operand:DF 0 "nonimmediate_operand" "=*fdm,f")
1963         (float_extend:DF
1964           (match_operand:SF 1 "general_operand" "f,dmF")))]
1965   "TARGET_68881"
1966 {
1967   if (FP_REG_P (operands[0]) && FP_REG_P (operands[1]))
1968     {
1969       if (REGNO (operands[0]) == REGNO (operands[1]))
1970         {
1971           /* Extending float to double in an fp-reg is a no-op.
1972              NOTICE_UPDATE_CC has already assumed that the
1973              cc will be set.  So cancel what it did.  */
1974           cc_status = cc_prev_status;
1975           return "";
1976         }
1977       return "f%&move%.x %1,%0";
1978     }
1979   if (FP_REG_P (operands[0]))
1980     return "f%&move%.s %f1,%0";
1981   if (DATA_REG_P (operands[0]) && FP_REG_P (operands[1]))
1982     {
1983       output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
1984       operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
1985       return "move%.l %+,%0";
1986     }
1987   return "fmove%.d %f1,%0";
1988 })
1989
1990 (define_insn "extendsfdf2_cf"
1991   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f")
1992         (float_extend:DF
1993          (match_operand:SF 1 "general_operand" "f,<Q>U")))]
1994   "TARGET_COLDFIRE_FPU"
1995 {
1996   if (FP_REG_P (operands[0]) && FP_REG_P (operands[1]))
1997     {
1998       if (REGNO (operands[0]) == REGNO (operands[1]))
1999         {
2000           /* Extending float to double in an fp-reg is a no-op.
2001              NOTICE_UPDATE_CC has already assumed that the
2002              cc will be set.  So cancel what it did.  */
2003           cc_status = cc_prev_status;
2004           return "";
2005         }
2006       return "fdmove%.d %1,%0";
2007     }
2008   return "fdmove%.s %f1,%0";
2009 })
2010
2011 ;; This cannot output into an f-reg because there is no way to be
2012 ;; sure of truncating in that case.
2013 (define_expand "truncdfsf2"
2014   [(set (match_operand:SF 0 "nonimmediate_operand" "")
2015         (float_truncate:SF
2016           (match_operand:DF 1 "general_operand" "")))]
2017   "TARGET_HARD_FLOAT"
2018   "")
2019
2020 ;; On the '040 we can truncate in a register accurately and easily.
2021 (define_insn ""
2022   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
2023         (float_truncate:SF
2024           (match_operand:DF 1 "general_operand" "fmG")))]
2025   "TARGET_68881 && TARGET_68040"
2026 {
2027   if (FP_REG_P (operands[1]))
2028     return "f%$move%.x %1,%0";
2029   return "f%$move%.d %f1,%0";
2030 })
2031
2032 (define_insn "truncdfsf2_cf"
2033   [(set (match_operand:SF 0 "nonimmediate_operand" "=f,d<Q>U")
2034         (float_truncate:SF
2035           (match_operand:DF 1 "general_operand" "<Q>U,f")))]
2036   "TARGET_COLDFIRE_FPU"
2037   "@
2038   fsmove%.d %1,%0
2039   fmove%.s %1,%0"
2040   [(set_attr "type" "fmove")])
2041
2042 (define_insn "*truncdfsf2_68881"
2043   [(set (match_operand:SF 0 "nonimmediate_operand" "=dm")
2044         (float_truncate:SF
2045           (match_operand:DF 1 "general_operand" "f")))]
2046   "TARGET_68881"
2047   "fmove%.s %f1,%0"
2048   [(set_attr "type" "fmove")])
2049 \f
2050 ;; Conversion between fixed point and floating point.
2051 ;; Note that among the fix-to-float insns
2052 ;; the ones that start with SImode come first.
2053 ;; That is so that an operand that is a CONST_INT
2054 ;; (and therefore lacks a specific machine mode).
2055 ;; will be recognized as SImode (which is always valid)
2056 ;; rather than as QImode or HImode.
2057
2058 (define_expand "floatsi<mode>2"
2059   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2060         (float:FP (match_operand:SI 1 "general_operand" "")))]
2061   "TARGET_HARD_FLOAT"
2062   "")
2063
2064 (define_insn "floatsi<mode>2_68881"
2065   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2066         (float:FP (match_operand:SI 1 "general_operand" "dmi")))]
2067   "TARGET_68881"
2068   "f<FP:round>move%.l %1,%0"
2069   [(set_attr "type" "fmove")])
2070
2071 (define_insn "floatsi<mode>2_cf"
2072   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2073         (float:FP (match_operand:SI 1 "general_operand" "d<Q>U")))]
2074   "TARGET_COLDFIRE_FPU"
2075   "f<FP:prec>move%.l %1,%0"
2076   [(set_attr "type" "fmove")])
2077
2078
2079 (define_expand "floathi<mode>2"
2080   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2081         (float:FP (match_operand:HI 1 "general_operand" "")))]
2082   "TARGET_HARD_FLOAT"
2083   "")
2084
2085 (define_insn "floathi<mode>2_68881"
2086   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2087         (float:FP (match_operand:HI 1 "general_operand" "dmn")))]
2088   "TARGET_68881"
2089   "fmove%.w %1,%0"
2090   [(set_attr "type" "fmove")])
2091
2092 (define_insn "floathi<mode>2_cf"
2093   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2094         (float:FP (match_operand:HI 1 "general_operand" "d<Q>U")))]
2095   "TARGET_COLDFIRE_FPU"
2096   "fmove%.w %1,%0"
2097   [(set_attr "type" "fmove")])
2098
2099
2100 (define_expand "floatqi<mode>2"
2101   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2102         (float:FP (match_operand:QI 1 "general_operand" "")))]
2103   "TARGET_HARD_FLOAT"
2104   "")
2105
2106 (define_insn "floatqi<mode>2_68881"
2107   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2108         (float:FP (match_operand:QI 1 "general_operand" "dmn")))]
2109   "TARGET_68881"
2110   "fmove%.b %1,%0"
2111   [(set_attr "type" "fmove")])
2112
2113 (define_insn "floatqi<mode>2_cf"
2114   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2115         (float:FP (match_operand:QI 1 "general_operand" "d<Q>U")))]
2116   "TARGET_COLDFIRE_FPU"
2117   "fmove%.b %1,%0"
2118   [(set_attr "type" "fmove")])
2119
2120
2121 ;; New routines to convert floating-point values to integers
2122 ;; to be used on the '040.  These should be faster than trapping
2123 ;; into the kernel to emulate fintrz.  They should also be faster
2124 ;; than calling the subroutines fixsfsi or fixdfsi.
2125
2126 (define_insn "fix_truncdfsi2"
2127   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
2128         (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
2129    (clobber (match_scratch:SI 2 "=d"))
2130    (clobber (match_scratch:SI 3 "=d"))]
2131   "TARGET_68881 && TUNE_68040"
2132 {
2133   CC_STATUS_INIT;
2134   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,%!";
2135 })
2136
2137 (define_insn "fix_truncdfhi2"
2138   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
2139         (fix:HI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
2140    (clobber (match_scratch:SI 2 "=d"))
2141    (clobber (match_scratch:SI 3 "=d"))]
2142   "TARGET_68881 && TUNE_68040"
2143 {
2144   CC_STATUS_INIT;
2145   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,%!";
2146 })
2147
2148 (define_insn "fix_truncdfqi2"
2149   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
2150         (fix:QI (fix:DF (match_operand:DF 1 "register_operand" "f"))))
2151    (clobber (match_scratch:SI 2 "=d"))
2152    (clobber (match_scratch:SI 3 "=d"))]
2153   "TARGET_68881 && TUNE_68040"
2154 {
2155   CC_STATUS_INIT;
2156   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,%!";
2157 })
2158
2159 ;; Convert a float to a float whose value is an integer.
2160 ;; This is the first stage of converting it to an integer type.
2161
2162 (define_expand "ftrunc<mode>2"
2163   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2164         (fix:FP (match_operand:FP 1 "general_operand" "")))]
2165   "TARGET_HARD_FLOAT && !TUNE_68040"
2166   "")
2167
2168 (define_insn "ftrunc<mode>2_68881"
2169   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2170         (fix:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m")))]
2171   "TARGET_68881 && !TUNE_68040"
2172 {
2173   if (FP_REG_P (operands[1]))
2174     return "fintrz%.x %f1,%0";
2175   return "fintrz%.<FP:prec> %f1,%0";
2176 }
2177   [(set_attr "type" "falu")])
2178
2179 (define_insn "ftrunc<mode>2_cf"
2180   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2181         (fix:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U")))]
2182   "TARGET_COLDFIRE_FPU"
2183 {
2184   if (FP_REG_P (operands[1]))
2185     return "fintrz%.d %f1,%0";
2186   return "fintrz%.<FP:prec> %f1,%0";
2187 }
2188   [(set_attr "type" "falu")])
2189
2190 ;; Convert a float whose value is an integer
2191 ;; to an actual integer.  Second stage of converting float to integer type.
2192 (define_expand "fix<mode>qi2"
2193   [(set (match_operand:QI 0 "nonimmediate_operand" "")
2194         (fix:QI (match_operand:FP 1 "general_operand" "")))]
2195   "TARGET_HARD_FLOAT"
2196   "")
2197
2198 (define_insn "fix<mode>qi2_68881"
2199   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
2200         (fix:QI (match_operand:FP 1 "general_operand" "f")))]
2201   "TARGET_68881"
2202   "fmove%.b %1,%0"
2203   [(set_attr "type" "fmove")])
2204
2205 (define_insn "fix<mode>qi2_cf"
2206   [(set (match_operand:QI 0 "nonimmediate_operand" "=d<Q>U")
2207         (fix:QI (match_operand:FP 1 "general_operand" "f")))]
2208   "TARGET_COLDFIRE_FPU"
2209   "fmove%.b %1,%0"
2210   [(set_attr "type" "fmove")])
2211
2212 (define_expand "fix<mode>hi2"
2213   [(set (match_operand:HI 0 "nonimmediate_operand" "")
2214         (fix:HI (match_operand:FP 1 "general_operand" "")))]
2215   "TARGET_HARD_FLOAT"
2216   "")
2217
2218 (define_insn "fix<mode>hi2_68881"
2219   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
2220         (fix:HI (match_operand:FP 1 "general_operand" "f")))]
2221   "TARGET_68881"
2222   "fmove%.w %1,%0"
2223   [(set_attr "type" "fmove")])
2224
2225 (define_insn "fix<mode>hi2_cf"
2226   [(set (match_operand:HI 0 "nonimmediate_operand" "=d<Q>U")
2227         (fix:HI (match_operand:FP 1 "general_operand" "f")))]
2228   "TARGET_COLDFIRE_FPU"
2229   "fmove%.w %1,%0"
2230   [(set_attr "type" "fmove")])
2231
2232 (define_expand "fix<mode>si2"
2233   [(set (match_operand:SI 0 "nonimmediate_operand" "")
2234         (fix:SI (match_operand:FP 1 "general_operand" "")))]
2235   "TARGET_HARD_FLOAT"
2236   "")
2237
2238 (define_insn "fix<mode>si2_68881"
2239   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
2240         (fix:SI (match_operand:FP 1 "general_operand" "f")))]
2241   "TARGET_68881"
2242   "fmove%.l %1,%0"
2243   [(set_attr "type" "fmove")])
2244
2245 (define_insn "fix<mode>si2_cf"
2246   [(set (match_operand:SI 0 "nonimmediate_operand" "=d<Q>U")
2247         (fix:SI (match_operand:FP 1 "general_operand" "f")))]
2248   "TARGET_COLDFIRE_FPU"
2249   "fmove%.l %1,%0"
2250   [(set_attr "type" "fmove")])
2251
2252 \f
2253 ;; add instructions
2254
2255 (define_insn "adddi_lshrdi_63"
2256   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
2257     (plus:DI (lshiftrt:DI (match_operand:DI 1 "general_operand" "rm")
2258             (const_int 63))
2259         (match_dup 1)))
2260    (clobber (match_scratch:SI 2 "=d"))]
2261   ""
2262 {
2263   operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2264   if (REG_P (operands[1]) && REGNO (operands[1]) == REGNO (operands[0]))
2265     return
2266     "move%.l %1,%2\;add%.l %2,%2\;subx%.l %2,%2\;sub%.l %2,%3\;subx%.l %2,%0";
2267   if (GET_CODE (operands[1]) == REG)
2268     operands[4] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2269   else if (GET_CODE (XEXP (operands[1], 0)) == POST_INC
2270         || GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)
2271     operands[4] = operands[1];
2272   else
2273     operands[4] = adjust_address (operands[1], SImode, 4);
2274   if (GET_CODE (operands[1]) == MEM
2275    && GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)
2276     output_asm_insn ("move%.l %4,%3", operands);
2277   output_asm_insn ("move%.l %1,%0\;smi %2", operands);
2278   if (TARGET_68020 || TARGET_COLDFIRE)
2279     output_asm_insn ("extb%.l %2", operands);
2280   else
2281     output_asm_insn ("ext%.w %2\;ext%.l %2", operands);
2282   if (GET_CODE (operands[1]) != MEM
2283    || GET_CODE (XEXP (operands[1], 0)) != PRE_DEC)
2284     output_asm_insn ("move%.l %4,%3", operands);
2285   return "sub%.l %2,%3\;subx%.l %2,%0";
2286 })
2287
2288 (define_insn "adddi_sexthishl32"
2289   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,a,*d,*d")
2290     (plus:DI (ashift:DI (sign_extend:DI
2291           (match_operand:HI 1 "general_operand" "rm,rm,rm,rm"))
2292             (const_int 32))
2293         (match_operand:DI 2 "general_operand" "0,0,0,0")))
2294    (clobber (match_scratch:SI 3 "=&d,X,a,?d"))]
2295   "!TARGET_COLDFIRE"
2296 {
2297   CC_STATUS_INIT;
2298   if (ADDRESS_REG_P (operands[0]))
2299     return "add%.w %1,%0";
2300   else if (ADDRESS_REG_P (operands[3]))
2301     return "move%.w %1,%3\;add%.l %3,%0";
2302   else
2303     return "move%.w %1,%3\;ext%.l %3\;add%.l %3,%0";
2304 })
2305
2306 (define_insn "*adddi_dilshr32"
2307   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,o")
2308         (plus:DI (lshiftrt:DI (match_operand:DI 1 "general_operand" "ro,d")
2309                               (const_int 32))
2310                  (match_operand:DI 2 "general_operand" "0,0")))]
2311   "!TARGET_COLDFIRE"
2312 {
2313   CC_STATUS_INIT;
2314   if (GET_CODE (operands[0]) == REG)
2315     operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2316   else
2317     operands[2] = adjust_address (operands[0], SImode, 4);
2318   return "add%.l %1,%2\;negx%.l %0\;neg%.l %0";
2319 })
2320
2321 (define_insn "*adddi_dilshr32_cf"
2322   [(set (match_operand:DI 0 "register_operand" "=d")
2323         (plus:DI (lshiftrt:DI (match_operand:DI 1 "nonimmediate_operand" "ro")
2324                               (const_int 32))
2325                  (match_operand:DI 2 "register_operand" "0")))]
2326   "TARGET_COLDFIRE"
2327 {
2328   CC_STATUS_INIT;
2329   return "add%.l %1,%R0\;negx%.l %0\;neg%.l %0";
2330 })
2331
2332 (define_insn "adddi_dishl32"
2333   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,o")
2334 ;;    (plus:DI (match_operand:DI 2 "general_operand" "%0")
2335 ;;      (ashift:DI (match_operand:DI 1 "general_operand" "ro")
2336 ;;            (const_int 32))))]
2337     (plus:DI (ashift:DI (match_operand:DI 1 "general_operand" "ro,d")
2338             (const_int 32))
2339         (match_operand:DI 2 "general_operand" "0,0")))]
2340   ""
2341 {
2342   CC_STATUS_INIT;
2343   if (GET_CODE (operands[1]) == REG)
2344     operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2345   else
2346     operands[1] = adjust_address (operands[1], SImode, 4);
2347   return "add%.l %1,%0";
2348 }
2349   [(set_attr "type" "alu_l")])
2350
2351 (define_insn "adddi3"
2352   [(set (match_operand:DI 0 "nonimmediate_operand" "=o<>,d,d,d")
2353         (plus:DI (match_operand:DI 1 "general_operand" "%0,0,0,0")
2354                  (match_operand:DI 2 "general_operand" "d,no>,d,a")))
2355    (clobber (match_scratch:SI 3 "=&d,&d,X,&d"))]
2356   ""
2357 {
2358   if (DATA_REG_P (operands[0]))
2359     {
2360       if (DATA_REG_P (operands[2]))
2361         return "add%.l %R2,%R0\;addx%.l %2,%0";
2362       else if (GET_CODE (operands[2]) == MEM
2363           && GET_CODE (XEXP (operands[2], 0)) == POST_INC)
2364         return "move%.l %2,%3\;add%.l %2,%R0\;addx%.l %3,%0";
2365       else
2366         {
2367           rtx high, low;
2368           rtx xoperands[2];
2369
2370           if (GET_CODE (operands[2]) == REG)
2371             {
2372               low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
2373               high = operands[2];
2374             }
2375           else if (CONSTANT_P (operands[2]))
2376             split_double (operands[2], &high, &low);
2377           else
2378             {
2379               low = adjust_address (operands[2], SImode, 4);
2380               high = operands[2];
2381             }
2382
2383           operands[1] = low, operands[2] = high;
2384           xoperands[0] = operands[3];
2385           if (GET_CODE (operands[1]) == CONST_INT
2386               && INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2387             xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
2388           else
2389             xoperands[1] = operands[2];
2390
2391           output_asm_insn (output_move_simode (xoperands), xoperands);
2392           if (GET_CODE (operands[1]) == CONST_INT)
2393             {
2394               if (INTVAL (operands[1]) > 0 && INTVAL (operands[1]) <= 8)
2395                 return "addq%.l %1,%R0\;addx%.l %3,%0";
2396               else if (INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2397                 {
2398                   operands[1] = GEN_INT (-INTVAL (operands[1]));
2399                   return "subq%.l %1,%R0\;subx%.l %3,%0";
2400                 }
2401             }
2402           return "add%.l %1,%R0\;addx%.l %3,%0";
2403         }
2404     }
2405   else
2406     {
2407       gcc_assert (GET_CODE (operands[0]) == MEM);
2408       CC_STATUS_INIT;
2409       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2410         {
2411           operands[1] = gen_rtx_MEM (SImode,
2412                                      plus_constant (Pmode,
2413                                                     XEXP(operands[0], 0), -8));
2414           return "move%.l %0,%3\;add%.l %R2,%0\;addx%.l %2,%3\;move%.l %3,%1";
2415         }
2416       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2417         {
2418           operands[1] = XEXP(operands[0], 0);
2419           return "add%.l %R2,%0\;move%.l %0,%3\;addx%.l %2,%3\;move%.l %3,%1";
2420         }
2421       else
2422         {
2423           operands[1] = adjust_address (operands[0], SImode, 4);
2424           return "add%.l %R2,%1\;move%.l %0,%3\;addx%.l %2,%3\;move%.l %3,%0";
2425         }
2426     }
2427 })
2428
2429 (define_insn "addsi_lshrsi_31"
2430   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm,dm,d<Q>")
2431     (plus:SI (lshiftrt:SI (match_operand:SI 1 "general_operand" "rm,r<Q>,rm")
2432             (const_int 31))
2433         (match_dup 1)))]
2434   ""
2435 {
2436   operands[2] = operands[0];
2437   operands[3] = gen_label_rtx();
2438   if (GET_CODE (operands[0]) == MEM)
2439     {
2440       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2441         operands[0] = gen_rtx_MEM (SImode, XEXP (XEXP (operands[0], 0), 0));
2442       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2443         operands[2] = gen_rtx_MEM (SImode, XEXP (XEXP (operands[0], 0), 0));
2444     }
2445   output_asm_insn ("move%.l %1,%0", operands);
2446   output_asm_insn ("jpl %l3", operands);
2447   output_asm_insn ("addq%.l #1,%2", operands);
2448   (*targetm.asm_out.internal_label) (asm_out_file, "L",
2449                                 CODE_LABEL_NUMBER (operands[3]));
2450   return "";
2451 }
2452   [(set_attr "ok_for_coldfire" "no,yes,yes")])
2453
2454 (define_expand "addsi3"
2455   [(set (match_operand:SI 0 "nonimmediate_operand" "")
2456         (plus:SI (match_operand:SI 1 "general_operand" "")
2457                  (match_operand:SI 2 "general_src_operand" "")))]
2458   ""
2459   "")
2460
2461 ;; Note that the middle two alternatives are near-duplicates
2462 ;; in order to handle insns generated by reload.
2463 ;; This is needed since they are not themselves reloaded,
2464 ;; so commutativity won't apply to them.
2465 (define_insn "*addsi3_internal"
2466   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,?a,?a,d,a")
2467         (plus:SI (match_operand:SI 1 "general_operand" "%0,a,rJK,0,0")
2468                  (match_operand:SI 2 "general_src_operand" "dIKLT,rJK,a,mSrIKLT,mSrIKLs")))]
2469
2470
2471   "! TARGET_COLDFIRE"
2472   "* return output_addsi3 (operands);")
2473
2474 (define_insn_and_split "*addsi3_5200"
2475   [(set (match_operand:SI 0 "nonimmediate_operand"         "=mr,mr,a,  m,r,  ?a, ?a,?a,?a")
2476         (plus:SI (match_operand:SI 1 "general_operand"     "%0, 0, 0,  0,0,   a,  a, r, a")
2477                  (match_operand:SI 2 "general_src_operand" " I, L, JCu,d,mrKi,Cj, r, a, JCu")))]
2478   "TARGET_COLDFIRE"
2479 {
2480   switch (which_alternative)
2481     {
2482     case 0:
2483       return "addq%.l %2,%0";
2484
2485     case 1:
2486       operands[2] = GEN_INT (- INTVAL (operands[2]));
2487       return "subq%.l %2,%0";
2488
2489     case 3:
2490     case 4:
2491       return "add%.l %2,%0";
2492
2493     case 5:
2494       /* move%.l %2,%0\n\tadd%.l %1,%0 */
2495       return "#";
2496
2497     case 6:
2498       return MOTOROLA ? "lea (%1,%2.l),%0" : "lea %1@(0,%2:l),%0";
2499
2500     case 7:
2501       return MOTOROLA ? "lea (%2,%1.l),%0" : "lea %2@(0,%1:l),%0";
2502
2503     case 2:
2504     case 8:
2505       return MOTOROLA ? "lea (%c2,%1),%0" : "lea %1@(%c2),%0";
2506
2507     default:
2508       gcc_unreachable ();
2509       return "";
2510     }
2511 }
2512   "&& reload_completed && (extract_constrain_insn_cached (insn), which_alternative == 5) && !operands_match_p (operands[0], operands[1])"
2513   [(set (match_dup 0)
2514         (match_dup 2))
2515    (set (match_dup 0)
2516         (plus:SI (match_dup 0)
2517                  (match_dup 1)))]
2518   ""
2519   [(set_attr "type"     "aluq_l,aluq_l,lea, alu_l,alu_l,*,lea, lea, lea")
2520    (set_attr "opy"      "2,     2,     *,   2,    2,    *,*,   *,   *")
2521    (set_attr "opy_type" "*,     *,     mem5,*,    *,    *,mem6,mem6,mem5")])
2522
2523 (define_insn ""
2524   [(set (match_operand:SI 0 "nonimmediate_operand" "=a")
2525         (plus:SI (match_operand:SI 1 "general_operand" "0")
2526                  (sign_extend:SI
2527                   (match_operand:HI 2 "nonimmediate_src_operand" "rmS"))))]
2528   "!TARGET_COLDFIRE"
2529   "add%.w %2,%0")
2530
2531 (define_insn "addhi3"
2532   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,r")
2533         (plus:HI (match_operand:HI 1 "general_operand" "%0,0")
2534                  (match_operand:HI 2 "general_src_operand" "dn,rmSn")))]
2535   "!TARGET_COLDFIRE"
2536 {
2537   if (GET_CODE (operands[2]) == CONST_INT)
2538     {
2539       /* If the constant would be a negative number when interpreted as
2540          HImode, make it negative.  This is usually, but not always, done
2541          elsewhere in the compiler.  First check for constants out of range,
2542          which could confuse us.  */
2543
2544       if (INTVAL (operands[2]) >= 32768)
2545         operands[2] = GEN_INT (INTVAL (operands[2]) - 65536);
2546
2547       if (INTVAL (operands[2]) > 0
2548           && INTVAL (operands[2]) <= 8)
2549         return "addq%.w %2,%0";
2550       if (INTVAL (operands[2]) < 0
2551           && INTVAL (operands[2]) >= -8)
2552         {
2553           operands[2] = GEN_INT (- INTVAL (operands[2]));
2554           return "subq%.w %2,%0";
2555         }
2556       /* On the CPU32 it is faster to use two addqw instructions to
2557          add a small integer (8 < N <= 16) to a register.
2558          Likewise for subqw.  */
2559       if (TUNE_CPU32 && REG_P (operands[0]))
2560         {
2561           if (INTVAL (operands[2]) > 8
2562               && INTVAL (operands[2]) <= 16)
2563             {
2564               operands[2] = GEN_INT (INTVAL (operands[2]) - 8);
2565               return "addq%.w #8,%0\;addq%.w %2,%0";
2566             }
2567           if (INTVAL (operands[2]) < -8
2568               && INTVAL (operands[2]) >= -16)
2569             {
2570               operands[2] = GEN_INT (- INTVAL (operands[2]) - 8);
2571               return "subq%.w #8,%0\;subq%.w %2,%0";
2572             }
2573         }
2574       if (ADDRESS_REG_P (operands[0]) && !TUNE_68040)
2575         return MOTOROLA ? "lea (%c2,%0),%0" : "lea %0@(%c2),%0";
2576     }
2577   return "add%.w %2,%0";
2578 })
2579
2580 ;; These insns must use MATCH_DUP instead of the more expected
2581 ;; use of a matching constraint because the "output" here is also
2582 ;; an input, so you can't use the matching constraint.  That also means
2583 ;; that you can't use the "%", so you need patterns with the matched
2584 ;; operand in both positions.
2585
2586 (define_insn ""
2587   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2588         (plus:HI (match_dup 0)
2589                  (match_operand:HI 1 "general_src_operand" "dn,rmSn")))]
2590   "!TARGET_COLDFIRE"
2591 {
2592   if (GET_CODE (operands[1]) == CONST_INT)
2593     {
2594       /* If the constant would be a negative number when interpreted as
2595          HImode, make it negative.  This is usually, but not always, done
2596          elsewhere in the compiler.  First check for constants out of range,
2597          which could confuse us.  */
2598
2599       if (INTVAL (operands[1]) >= 32768)
2600         operands[1] = GEN_INT (INTVAL (operands[1]) - 65536);
2601
2602       if (INTVAL (operands[1]) > 0
2603           && INTVAL (operands[1]) <= 8)
2604         return "addq%.w %1,%0";
2605       if (INTVAL (operands[1]) < 0
2606           && INTVAL (operands[1]) >= -8)
2607         {
2608           operands[1] = GEN_INT (- INTVAL (operands[1]));
2609           return "subq%.w %1,%0";
2610         }
2611       /* On the CPU32 it is faster to use two addqw instructions to
2612          add a small integer (8 < N <= 16) to a register.
2613          Likewise for subqw.  */
2614       if (TUNE_CPU32 && REG_P (operands[0]))
2615         {
2616           if (INTVAL (operands[1]) > 8
2617               && INTVAL (operands[1]) <= 16)
2618             {
2619               operands[1] = GEN_INT (INTVAL (operands[1]) - 8);
2620               return "addq%.w #8,%0\;addq%.w %1,%0";
2621             }
2622           if (INTVAL (operands[1]) < -8
2623               && INTVAL (operands[1]) >= -16)
2624             {
2625               operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
2626               return "subq%.w #8,%0\;subq%.w %1,%0";
2627             }
2628         }
2629       if (ADDRESS_REG_P (operands[0]) && !TUNE_68040)
2630         return MOTOROLA ? "lea (%c1,%0),%0" : "lea %0@(%c1),%0";
2631     }
2632   return "add%.w %1,%0";
2633 })
2634
2635 (define_insn ""
2636   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2637         (plus:HI (match_operand:HI 1 "general_src_operand" "dn,rmSn")
2638                  (match_dup 0)))]
2639   "!TARGET_COLDFIRE"
2640 {
2641   if (GET_CODE (operands[1]) == CONST_INT)
2642     {
2643       /* If the constant would be a negative number when interpreted as
2644          HImode, make it negative.  This is usually, but not always, done
2645          elsewhere in the compiler.  First check for constants out of range,
2646          which could confuse us.  */
2647
2648       if (INTVAL (operands[1]) >= 32768)
2649         operands[1] = GEN_INT (INTVAL (operands[1]) - 65536);
2650
2651       if (INTVAL (operands[1]) > 0
2652           && INTVAL (operands[1]) <= 8)
2653         return "addq%.w %1,%0";
2654       if (INTVAL (operands[1]) < 0
2655           && INTVAL (operands[1]) >= -8)
2656         {
2657           operands[1] = GEN_INT (- INTVAL (operands[1]));
2658           return "subq%.w %1,%0";
2659         }
2660       /* On the CPU32 it is faster to use two addqw instructions to
2661          add a small integer (8 < N <= 16) to a register.
2662          Likewise for subqw.  */
2663       if (TUNE_CPU32 && REG_P (operands[0]))
2664         {
2665           if (INTVAL (operands[1]) > 8
2666               && INTVAL (operands[1]) <= 16)
2667             {
2668               operands[1] = GEN_INT (INTVAL (operands[1]) - 8);
2669               return "addq%.w #8,%0\;addq%.w %1,%0";
2670             }
2671           if (INTVAL (operands[1]) < -8
2672               && INTVAL (operands[1]) >= -16)
2673             {
2674               operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
2675               return "subq%.w #8,%0\;subq%.w %1,%0";
2676             }
2677         }
2678       if (ADDRESS_REG_P (operands[0]) && !TUNE_68040)
2679         return MOTOROLA ? "lea (%c1,%0),%0" : "lea %0@(%c1),%0";
2680     }
2681   return "add%.w %1,%0";
2682 })
2683
2684 (define_insn "addqi3"
2685   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
2686         (plus:QI (match_operand:QI 1 "general_operand" "%0,0")
2687                  (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
2688   "!TARGET_COLDFIRE"
2689 {
2690   if (GET_CODE (operands[2]) == CONST_INT)
2691     {
2692       if (INTVAL (operands[2]) >= 128)
2693         operands[2] = GEN_INT (INTVAL (operands[2]) - 256);
2694
2695       if (INTVAL (operands[2]) > 0
2696           && INTVAL (operands[2]) <= 8)
2697         return "addq%.b %2,%0";
2698       if (INTVAL (operands[2]) < 0 && INTVAL (operands[2]) >= -8)
2699        {
2700          operands[2] = GEN_INT (- INTVAL (operands[2]));
2701          return "subq%.b %2,%0";
2702        }
2703     }
2704   return "add%.b %2,%0";
2705 })
2706
2707 (define_insn ""
2708   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2709         (plus:QI (match_dup 0)
2710                  (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
2711   "!TARGET_COLDFIRE"
2712 {
2713   if (GET_CODE (operands[1]) == CONST_INT)
2714     {
2715       if (INTVAL (operands[1]) >= 128)
2716         operands[1] = GEN_INT (INTVAL (operands[1]) - 256);
2717
2718       if (INTVAL (operands[1]) > 0
2719           && INTVAL (operands[1]) <= 8)
2720         return "addq%.b %1,%0";
2721       if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
2722        {
2723          operands[1] = GEN_INT (- INTVAL (operands[1]));
2724          return "subq%.b %1,%0";
2725        }
2726     }
2727   return "add%.b %1,%0";
2728 })
2729
2730 (define_insn ""
2731   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2732         (plus:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
2733                  (match_dup 0)))]
2734   "!TARGET_COLDFIRE"
2735 {
2736   if (GET_CODE (operands[1]) == CONST_INT)
2737     {
2738       if (INTVAL (operands[1]) >= 128)
2739         operands[1] = GEN_INT (INTVAL (operands[1]) - 256);
2740
2741       if (INTVAL (operands[1]) > 0
2742           && INTVAL (operands[1]) <= 8)
2743         return "addq%.b %1,%0";
2744       if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
2745        {
2746          operands[1] = GEN_INT (- INTVAL (operands[1]));
2747          return "subq%.b %1,%0";
2748        }
2749     }
2750   return "add%.b %1,%0";
2751 })
2752
2753 (define_expand "add<mode>3"
2754   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2755         (plus:FP (match_operand:FP 1 "general_operand" "")
2756                  (match_operand:FP 2 "general_operand" "")))]
2757   "TARGET_HARD_FLOAT"
2758   "")
2759
2760 (define_insn "add<mode>3_floatsi_68881"
2761   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2762         (plus:FP (float:FP (match_operand:SI 2 "general_operand" "dmi"))
2763                  (match_operand:FP 1 "general_operand" "0")))]
2764   "TARGET_68881"
2765   "f<FP:round>add%.l %2,%0"
2766   [(set_attr "type" "falu")
2767    (set_attr "opy" "2")])
2768
2769 (define_insn "add<mode>3_floathi_68881"
2770   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2771         (plus:FP (float:FP (match_operand:HI 2 "general_operand" "dmn"))
2772                  (match_operand:FP 1 "general_operand" "0")))]
2773   "TARGET_68881"
2774   "f<FP:round>add%.w %2,%0"
2775   [(set_attr "type" "falu")
2776    (set_attr "opy" "2")])
2777
2778 (define_insn "add<mode>3_floatqi_68881"
2779   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2780         (plus:FP (float:FP (match_operand:QI 2 "general_operand" "dmn"))
2781                  (match_operand:FP 1 "general_operand" "0")))]
2782   "TARGET_68881"
2783   "f<FP:round>add%.b %2,%0"
2784   [(set_attr "type" "falu")
2785    (set_attr "opy" "2")])
2786
2787 (define_insn "add<mode>3_68881"
2788   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2789         (plus:FP (match_operand:FP 1 "general_operand" "%0")
2790                  (match_operand:FP 2 "general_operand" "f<FP:dreg>m<FP:const>")))]
2791   "TARGET_68881"
2792 {
2793   if (FP_REG_P (operands[2]))
2794     return "f<FP:round>add%.x %2,%0";
2795   return "f<FP:round>add%.<FP:prec> %f2,%0";
2796 }
2797   [(set_attr "type" "falu")
2798    (set_attr "opy" "2")])
2799
2800 (define_insn "add<mode>3_cf"
2801   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2802         (plus:FP (match_operand:FP 1 "general_operand" "%0")
2803                  (match_operand:FP 2 "general_operand" "f<FP:dreg><Q>U")))]
2804   "TARGET_COLDFIRE_FPU"
2805 {
2806   if (FP_REG_P (operands[2]))
2807     return "f<FP:prec>add%.d %2,%0";
2808   return "f<FP:prec>add%.<FP:prec> %2,%0";
2809 }
2810   [(set_attr "type" "falu")
2811    (set_attr "opy" "2")])
2812 \f
2813 ;; subtract instructions
2814
2815 (define_insn "subdi_sexthishl32"
2816   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,a,*d,*d")
2817     (minus:DI (match_operand:DI 1 "general_operand" "0,0,0,0")
2818         (ashift:DI (sign_extend:DI (match_operand:HI 2 "general_operand" "rm,rm,rm,rm"))
2819             (const_int 32))))
2820    (clobber (match_scratch:SI 3 "=&d,X,a,?d"))]
2821   "!TARGET_COLDFIRE"
2822 {
2823   CC_STATUS_INIT;
2824   if (ADDRESS_REG_P (operands[0]))
2825     return "sub%.w %2,%0";
2826   else if (ADDRESS_REG_P (operands[3]))
2827     return "move%.w %2,%3\;sub%.l %3,%0";
2828   else
2829     return "move%.w %2,%3\;ext%.l %3\;sub%.l %3,%0";
2830 })
2831
2832 (define_insn "subdi_dishl32"
2833   [(set (match_operand:DI 0 "nonimmediate_operand" "+ro")
2834     (minus:DI (match_dup 0)
2835         (ashift:DI (match_operand:DI 1 "general_operand" "ro")
2836             (const_int 32))))]
2837   ""
2838 {
2839   CC_STATUS_INIT;
2840   if (GET_CODE (operands[1]) == REG)
2841     operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2842   else
2843     operands[1] = adjust_address (operands[1], SImode, 4);
2844   return "sub%.l %1,%0";
2845 }
2846   [(set_attr "type" "alu_l")])
2847
2848 (define_insn "subdi3"
2849   [(set (match_operand:DI 0 "nonimmediate_operand" "=o<>,d,d,d")
2850         (minus:DI (match_operand:DI 1 "general_operand" "0,0,0,0")
2851                  (match_operand:DI 2 "general_operand" "d,no>,d,a")))
2852    (clobber (match_scratch:SI 3 "=&d,&d,X,&d"))]
2853   ""
2854 {
2855   if (DATA_REG_P (operands[0]))
2856     {
2857       if (DATA_REG_P (operands[2]))
2858         return "sub%.l %R2,%R0\;subx%.l %2,%0";
2859       else if (GET_CODE (operands[2]) == MEM
2860           && GET_CODE (XEXP (operands[2], 0)) == POST_INC)
2861         {
2862           return "move%.l %2,%3\;sub%.l %2,%R0\;subx%.l %3,%0";
2863         }
2864       else
2865         {
2866           rtx high, low;
2867           rtx xoperands[2];
2868
2869           if (GET_CODE (operands[2]) == REG)
2870             {
2871               low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
2872               high = operands[2];
2873             }
2874           else if (CONSTANT_P (operands[2]))
2875             split_double (operands[2], &high, &low);
2876           else
2877             {
2878               low = adjust_address (operands[2], SImode, 4);
2879               high = operands[2];
2880             }
2881
2882           operands[1] = low, operands[2] = high;
2883           xoperands[0] = operands[3];
2884           if (GET_CODE (operands[1]) == CONST_INT
2885               && INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2886             xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
2887           else
2888             xoperands[1] = operands[2];
2889
2890           output_asm_insn (output_move_simode (xoperands), xoperands);
2891           if (GET_CODE (operands[1]) == CONST_INT)
2892             {
2893               if (INTVAL (operands[1]) > 0 && INTVAL (operands[1]) <= 8)
2894                 return "subq%.l %1,%R0\;subx%.l %3,%0";
2895               else if (INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
2896                 {
2897                   operands[1] = GEN_INT (-INTVAL (operands[1]));
2898                   return "addq%.l %1,%R0\;addx%.l %3,%0";
2899                 }
2900             }
2901           return "sub%.l %1,%R0\;subx%.l %3,%0";
2902         }
2903     }
2904   else
2905     {
2906       gcc_assert (GET_CODE (operands[0]) == MEM);
2907       CC_STATUS_INIT;
2908       if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2909         {
2910           operands[1]
2911             = gen_rtx_MEM (SImode, plus_constant (Pmode,
2912                                                   XEXP (operands[0], 0), -8));
2913           return "move%.l %0,%3\;sub%.l %R2,%0\;subx%.l %2,%3\;move%.l %3,%1";
2914         }
2915       else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2916         {
2917           operands[1] = XEXP(operands[0], 0);
2918           return "sub%.l %R2,%0\;move%.l %0,%3\;subx%.l %2,%3\;move%.l %3,%1";
2919         }
2920       else
2921         {
2922           operands[1] = adjust_address (operands[0], SImode, 4);
2923           return "sub%.l %R2,%1\;move%.l %0,%3\;subx%.l %2,%3\;move%.l %3,%0";
2924         }
2925     }
2926 })
2927
2928 (define_insn "subsi3"
2929   [(set (match_operand:SI 0 "nonimmediate_operand" "=mda,m,d,a")
2930         (minus:SI (match_operand:SI 1 "general_operand" "0,0,0,0")
2931                   (match_operand:SI 2 "general_src_operand" "I,dT,mSrT,mSrs")))]
2932   ""
2933   "@
2934    subq%.l %2, %0
2935    sub%.l %2,%0
2936    sub%.l %2,%0
2937    sub%.l %2,%0"
2938   [(set_attr "type" "aluq_l,alu_l,alu_l,alu_l")
2939    (set_attr "opy" "2")])
2940
2941 (define_insn ""
2942   [(set (match_operand:SI 0 "nonimmediate_operand" "=a")
2943         (minus:SI (match_operand:SI 1 "general_operand" "0")
2944                   (sign_extend:SI
2945                    (match_operand:HI 2 "nonimmediate_src_operand" "rmS"))))]
2946   "!TARGET_COLDFIRE"
2947   "sub%.w %2,%0")
2948
2949 (define_insn "subhi3"
2950   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,r")
2951         (minus:HI (match_operand:HI 1 "general_operand" "0,0")
2952                   (match_operand:HI 2 "general_src_operand" "dn,rmSn")))]
2953   "!TARGET_COLDFIRE"
2954   "sub%.w %2,%0")
2955
2956 (define_insn ""
2957   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
2958         (minus:HI (match_dup 0)
2959                   (match_operand:HI 1 "general_src_operand" "dn,rmSn")))]
2960   "!TARGET_COLDFIRE"
2961   "sub%.w %1,%0")
2962
2963 (define_insn "subqi3"
2964   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
2965         (minus:QI (match_operand:QI 1 "general_operand" "0,0")
2966                   (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
2967   "!TARGET_COLDFIRE"
2968   "sub%.b %2,%0")
2969
2970 (define_insn ""
2971   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
2972         (minus:QI (match_dup 0)
2973                   (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
2974   "!TARGET_COLDFIRE"
2975   "sub%.b %1,%0")
2976
2977 (define_expand "sub<mode>3"
2978   [(set (match_operand:FP 0 "nonimmediate_operand" "")
2979         (minus:FP (match_operand:FP 1 "general_operand" "")
2980                   (match_operand:FP 2 "general_operand" "")))]
2981   "TARGET_HARD_FLOAT"
2982   "")
2983
2984 (define_insn "sub<mode>3_floatsi_68881"
2985   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2986         (minus:FP (match_operand:FP 1 "general_operand" "0")
2987                   (float:FP (match_operand:SI 2 "general_operand" "dmi"))))]
2988   "TARGET_68881"
2989   "f<FP:round>sub%.l %2,%0"
2990   [(set_attr "type" "falu")
2991    (set_attr "opy" "2")])
2992
2993 (define_insn "sub<mode>3_floathi_68881"
2994   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
2995         (minus:FP (match_operand:FP 1 "general_operand" "0")
2996                   (float:FP (match_operand:HI 2 "general_operand" "dmn"))))]
2997   "TARGET_68881"
2998   "f<FP:round>sub%.w %2,%0"
2999   [(set_attr "type" "falu")
3000    (set_attr "opy" "2")])
3001
3002 (define_insn "sub<mode>3_floatqi_68881"
3003   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3004         (minus:FP (match_operand:FP 1 "general_operand" "0")
3005                   (float:FP (match_operand:QI 2 "general_operand" "dmn"))))]
3006   "TARGET_68881"
3007   "f<FP:round>sub%.b %2,%0"
3008   [(set_attr "type" "falu")
3009    (set_attr "opy" "2")])
3010
3011 (define_insn "sub<mode>3_68881"
3012   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3013         (minus:FP (match_operand:FP 1 "general_operand" "0")
3014                   (match_operand:FP 2 "general_operand" "f<FP:dreg>m<FP:const>")))]
3015   "TARGET_68881"
3016 {
3017   if (FP_REG_P (operands[2]))
3018     return "f<FP:round>sub%.x %2,%0";
3019   return "f<FP:round>sub%.<FP:prec> %f2,%0";
3020 }
3021   [(set_attr "type" "falu")
3022    (set_attr "opy" "2")])
3023
3024 (define_insn "sub<mode>3_cf"
3025   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3026         (minus:FP (match_operand:FP 1 "general_operand" "0")
3027                   (match_operand:FP 2 "general_operand" "f<FP:dreg><Q>U")))]
3028   "TARGET_COLDFIRE_FPU"
3029 {
3030   if (FP_REG_P (operands[2]))
3031     return "f<FP:prec>sub%.d %2,%0";
3032   return "f<FP:prec>sub%.<FP:prec> %2,%0";
3033 }
3034   [(set_attr "type" "falu")
3035    (set_attr "opy" "2")])
3036 \f
3037 ;; multiply instructions
3038
3039 (define_insn "mulhi3"
3040   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
3041         (mult:HI (match_operand:HI 1 "general_operand" "%0")
3042                  (match_operand:HI 2 "general_src_operand" "dmSn")))]
3043   ""
3044 {
3045   return MOTOROLA ? "muls%.w %2,%0" : "muls %2,%0";
3046 }
3047   [(set_attr "type" "mul_w")
3048    (set_attr "opy" "2")])
3049
3050 (define_insn "mulhisi3"
3051   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3052         (mult:SI (sign_extend:SI
3053                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
3054                  (sign_extend:SI
3055                   (match_operand:HI 2 "nonimmediate_src_operand" "dmS"))))]
3056   ""
3057 {
3058   return MOTOROLA ? "muls%.w %2,%0" : "muls %2,%0";
3059 }
3060   [(set_attr "type" "mul_w")
3061    (set_attr "opy" "2")])
3062
3063 (define_insn "*mulhisisi3_s"
3064   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3065         (mult:SI (sign_extend:SI
3066                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
3067                  (match_operand:SI 2 "const_int_operand" "n")))]
3068   "INTVAL (operands[2]) >= -0x8000 && INTVAL (operands[2]) <= 0x7fff"
3069 {
3070   return MOTOROLA ? "muls%.w %2,%0" : "muls %2,%0";
3071 }
3072   [(set_attr "type" "mul_w")
3073    (set_attr "opy" "2")])
3074
3075 (define_expand "mulsi3"
3076   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3077         (mult:SI (match_operand:SI 1 "general_operand" "")
3078                  (match_operand:SI 2 "general_operand" "")))]
3079   "TARGET_68020 || TARGET_COLDFIRE"
3080   "")
3081
3082 (define_insn "*mulsi3_68020"
3083   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3084         (mult:SI (match_operand:SI 1 "general_operand" "%0")
3085                  (match_operand:SI 2 "general_src_operand" "dmSTK")))]
3086
3087   "TARGET_68020"
3088   "muls%.l %2,%0"
3089   [(set_attr "type" "mul_l")
3090    (set_attr "opy" "2")])
3091
3092 (define_insn "*mulsi3_cf"
3093   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3094         (mult:SI (match_operand:SI 1 "general_operand" "%0")
3095                  (match_operand:SI 2 "general_operand" "d<Q>")))]
3096   "TARGET_COLDFIRE"
3097   "muls%.l %2,%0"
3098   [(set_attr "type" "mul_l")
3099    (set_attr "opy" "2")])
3100
3101 (define_insn "umulhisi3"
3102   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3103         (mult:SI (zero_extend:SI
3104                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
3105                  (zero_extend:SI
3106                   (match_operand:HI 2 "nonimmediate_src_operand" "dmS"))))]
3107   ""
3108 {
3109   return MOTOROLA ? "mulu%.w %2,%0" : "mulu %2,%0";
3110 }
3111   [(set_attr "type" "mul_w")
3112    (set_attr "opy" "2")])
3113
3114 (define_insn "*mulhisisi3_z"
3115   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3116         (mult:SI (zero_extend:SI
3117                   (match_operand:HI 1 "nonimmediate_operand" "%0"))
3118                  (match_operand:SI 2 "const_int_operand" "n")))]
3119   "INTVAL (operands[2]) >= 0 && INTVAL (operands[2]) <= 0xffff"
3120 {
3121   return MOTOROLA ? "mulu%.w %2,%0" : "mulu %2,%0";
3122 }
3123   [(set_attr "type" "mul_w")
3124    (set_attr "opy" "2")])
3125
3126 ;; We need a separate DEFINE_EXPAND for u?mulsidi3 to be able to use the
3127 ;; proper matching constraint.  This is because the matching is between
3128 ;; the high-numbered word of the DImode operand[0] and operand[1].
3129 (define_expand "umulsidi3"
3130   [(parallel
3131     [(set (subreg:SI (match_operand:DI 0 "register_operand" "") 4)
3132           (mult:SI (match_operand:SI 1 "register_operand" "")
3133                    (match_operand:SI 2 "register_operand" "")))
3134      (set (subreg:SI (match_dup 0) 0)
3135           (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
3136                                              (zero_extend:DI (match_dup 2)))
3137                                     (const_int 32))))])]
3138   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3139   "")
3140
3141 (define_insn ""
3142   [(set (match_operand:SI 0 "register_operand" "=d")
3143         (mult:SI (match_operand:SI 1 "register_operand" "%0")
3144                   (match_operand:SI 2 "nonimmediate_operand" "dm")))
3145    (set (match_operand:SI 3 "register_operand" "=d")
3146         (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
3147                                            (zero_extend:DI (match_dup 2)))
3148                                   (const_int 32))))]
3149   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3150   "mulu%.l %2,%3:%0")
3151
3152 ; Match immediate case.  For 2.4 only match things < 2^31.
3153 ; It's tricky with larger values in these patterns since we need to match
3154 ; values between the two parallel multiplies, between a CONST_DOUBLE and
3155 ; a CONST_INT.
3156 (define_insn ""
3157   [(set (match_operand:SI 0 "register_operand" "=d")
3158         (mult:SI (match_operand:SI 1 "register_operand" "%0")
3159                  (match_operand:SI 2 "const_int_operand" "n")))
3160    (set (match_operand:SI 3 "register_operand" "=d")
3161         (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
3162                                            (match_dup 2))
3163                                   (const_int 32))))]
3164   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE
3165    && (unsigned) INTVAL (operands[2]) <= 0x7fffffff"
3166   "mulu%.l %2,%3:%0")
3167
3168 (define_expand "mulsidi3"
3169   [(parallel
3170     [(set (subreg:SI (match_operand:DI 0 "register_operand" "") 4)
3171           (mult:SI (match_operand:SI 1 "register_operand" "")
3172                    (match_operand:SI 2 "register_operand" "")))
3173      (set (subreg:SI (match_dup 0) 0)
3174           (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
3175                                              (sign_extend:DI (match_dup 2)))
3176                                     (const_int 32))))])]
3177   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3178   "")
3179
3180 (define_insn ""
3181   [(set (match_operand:SI 0 "register_operand" "=d")
3182         (mult:SI (match_operand:SI 1 "register_operand" "%0")
3183                  (match_operand:SI 2 "nonimmediate_operand" "dm")))
3184    (set (match_operand:SI 3 "register_operand" "=d")
3185         (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
3186                                            (sign_extend:DI (match_dup 2)))
3187                                   (const_int 32))))]
3188   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3189   "muls%.l %2,%3:%0")
3190
3191 (define_insn ""
3192   [(set (match_operand:SI 0 "register_operand" "=d")
3193         (mult:SI (match_operand:SI 1 "register_operand" "%0")
3194                  (match_operand:SI 2 "const_int_operand" "n")))
3195    (set (match_operand:SI 3 "register_operand" "=d")
3196         (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
3197                                            (match_dup 2))
3198                                   (const_int 32))))]
3199   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3200   "muls%.l %2,%3:%0")
3201
3202 (define_expand "umulsi3_highpart"
3203   [(parallel
3204     [(set (match_operand:SI 0 "register_operand" "")
3205           (truncate:SI
3206            (lshiftrt:DI
3207             (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" ""))
3208                      (zero_extend:DI (match_operand:SI 2 "general_operand" "")))
3209             (const_int 32))))
3210      (clobber (match_dup 3))])]
3211   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3212 {
3213   operands[3] = gen_reg_rtx (SImode);
3214
3215   if (GET_CODE (operands[2]) == CONST_INT)
3216     {
3217       operands[2] = immed_double_const (INTVAL (operands[2]) & 0xffffffff,
3218                                         0, DImode);
3219
3220       /* We have to adjust the operand order for the matching constraints.  */
3221       emit_insn (gen_const_umulsi3_highpart (operands[0], operands[3],
3222                                              operands[1], operands[2]));
3223       DONE;
3224     }
3225 })
3226
3227 (define_insn ""
3228   [(set (match_operand:SI 0 "register_operand" "=d")
3229         (truncate:SI
3230          (lshiftrt:DI
3231           (mult:DI (zero_extend:DI (match_operand:SI 2 "register_operand" "%1"))
3232                    (zero_extend:DI (match_operand:SI 3 "nonimmediate_operand" "dm")))
3233           (const_int 32))))
3234    (clobber (match_operand:SI 1 "register_operand" "=d"))]
3235   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3236   "mulu%.l %3,%0:%1")
3237
3238 (define_insn "const_umulsi3_highpart"
3239   [(set (match_operand:SI 0 "register_operand" "=d")
3240         (truncate:SI
3241          (lshiftrt:DI
3242           (mult:DI (zero_extend:DI (match_operand:SI 2 "register_operand" "1"))
3243                    (match_operand:DI 3 "const_uint32_operand" "n"))
3244           (const_int 32))))
3245    (clobber (match_operand:SI 1 "register_operand" "=d"))]
3246   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3247   "mulu%.l %3,%0:%1")
3248
3249 (define_expand "smulsi3_highpart"
3250   [(parallel
3251     [(set (match_operand:SI 0 "register_operand" "")
3252           (truncate:SI
3253            (lshiftrt:DI
3254             (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" ""))
3255                      (sign_extend:DI (match_operand:SI 2 "general_operand" "")))
3256             (const_int 32))))
3257      (clobber (match_dup 3))])]
3258   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3259 {
3260   operands[3] = gen_reg_rtx (SImode);
3261   if (GET_CODE (operands[2]) == CONST_INT)
3262     {
3263       /* We have to adjust the operand order for the matching constraints.  */
3264       emit_insn (gen_const_smulsi3_highpart (operands[0], operands[3],
3265                                              operands[1], operands[2]));
3266       DONE;
3267     }
3268 })
3269
3270 (define_insn ""
3271   [(set (match_operand:SI 0 "register_operand" "=d")
3272         (truncate:SI
3273          (lshiftrt:DI
3274           (mult:DI (sign_extend:DI (match_operand:SI 2 "register_operand" "%1"))
3275                    (sign_extend:DI (match_operand:SI 3 "nonimmediate_operand" "dm")))
3276           (const_int 32))))
3277    (clobber (match_operand:SI 1 "register_operand" "=d"))]
3278   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3279   "muls%.l %3,%0:%1")
3280
3281 (define_insn "const_smulsi3_highpart"
3282   [(set (match_operand:SI 0 "register_operand" "=d")
3283         (truncate:SI
3284          (lshiftrt:DI
3285           (mult:DI (sign_extend:DI (match_operand:SI 2 "register_operand" "1"))
3286                    (match_operand:DI 3 "const_sint32_operand" "n"))
3287           (const_int 32))))
3288    (clobber (match_operand:SI 1 "register_operand" "=d"))]
3289   "TARGET_68020 && !TUNE_68060 && !TARGET_COLDFIRE"
3290   "muls%.l %3,%0:%1")
3291
3292 (define_expand "mul<mode>3"
3293   [(set (match_operand:FP 0 "nonimmediate_operand" "")
3294         (mult:FP (match_operand:FP 1 "general_operand" "")
3295                  (match_operand:FP 2 "general_operand" "")))]
3296   "TARGET_HARD_FLOAT"
3297   "")
3298
3299 (define_insn "mul<mode>3_floatsi_68881"
3300   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3301         (mult:FP (float:FP (match_operand:SI 2 "general_operand" "dmi"))
3302                  (match_operand:FP 1 "general_operand" "0")))]
3303   "TARGET_68881"
3304 {
3305   return TARGET_68040
3306          ? "f<FP:round>mul%.l %2,%0"
3307          : "f<FP:round_mul>mul%.l %2,%0";
3308 }
3309   [(set_attr "type" "fmul")
3310    (set_attr "opy" "2")])
3311
3312 (define_insn "mul<mode>3_floathi_68881"
3313   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3314         (mult:FP (float:FP (match_operand:HI 2 "general_operand" "dmn"))
3315                  (match_operand:FP 1 "general_operand" "0")))]
3316   "TARGET_68881"
3317 {
3318   return TARGET_68040
3319          ? "f<FP:round>mul%.w %2,%0"
3320          : "f<FP:round_mul>mul%.w %2,%0";
3321 }
3322   [(set_attr "type" "fmul")
3323    (set_attr "opy" "2")])
3324
3325 (define_insn "mul<mode>3_floatqi_68881"
3326   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3327         (mult:FP (float:FP (match_operand:QI 2 "general_operand" "dmn"))
3328                  (match_operand:FP 1 "general_operand" "0")))]
3329   "TARGET_68881"
3330 {
3331   return TARGET_68040
3332          ? "f<FP:round>mul%.b %2,%0"
3333          : "f<FP:round_mul>mul%.b %2,%0";
3334 }
3335   [(set_attr "type" "fmul")
3336    (set_attr "opy" "2")])
3337
3338 (define_insn "muldf_68881"
3339   [(set (match_operand:DF 0 "nonimmediate_operand" "=f")
3340         (mult:DF (match_operand:DF 1 "general_operand" "%0")
3341                  (match_operand:DF 2 "general_operand" "fmG")))]
3342   "TARGET_68881"
3343 {
3344   if (GET_CODE (operands[2]) == CONST_DOUBLE
3345       && floating_exact_log2 (operands[2]) && !TUNE_68040_60)
3346     {
3347       int i = floating_exact_log2 (operands[2]);
3348       operands[2] = GEN_INT (i);
3349       return "fscale%.l %2,%0";
3350     }
3351   if (REG_P (operands[2]))
3352     return "f%&mul%.x %2,%0";
3353   return "f%&mul%.d %f2,%0";
3354 })
3355
3356 (define_insn "mulsf_68881"
3357   [(set (match_operand:SF 0 "nonimmediate_operand" "=f")
3358         (mult:SF (match_operand:SF 1 "general_operand" "%0")
3359                  (match_operand:SF 2 "general_operand" "fdmF")))]
3360   "TARGET_68881"
3361 {
3362   if (FP_REG_P (operands[2]))
3363     return (TARGET_68040
3364             ? "fsmul%.x %2,%0"
3365             : "fsglmul%.x %2,%0");
3366   return (TARGET_68040
3367           ? "fsmul%.s %f2,%0"
3368           : "fsglmul%.s %f2,%0");
3369 })
3370
3371 (define_insn "mulxf3_68881"
3372   [(set (match_operand:XF 0 "nonimmediate_operand" "=f")
3373         (mult:XF (match_operand:XF 1 "nonimmediate_operand" "%0")
3374                  (match_operand:XF 2 "nonimmediate_operand" "fm")))]
3375   "TARGET_68881"
3376 {
3377   return "fmul%.x %f2,%0";
3378 })
3379
3380 (define_insn "fmul<mode>3_cf"
3381   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3382         (mult:FP (match_operand:FP 1 "general_operand" "%0")
3383                  (match_operand:FP 2 "general_operand" "f<Q>U<FP:dreg>")))]
3384   "TARGET_COLDFIRE_FPU"
3385 {
3386   if (FP_REG_P (operands[2]))
3387     return "f<FP:prec>mul%.d %2,%0";
3388   return "f<FP:prec>mul%.<FP:prec> %2,%0";
3389 }
3390   [(set_attr "type" "fmul")
3391    (set_attr "opy" "2")])
3392 \f
3393 ;; divide instructions
3394
3395 (define_expand "div<mode>3"
3396   [(set (match_operand:FP 0 "nonimmediate_operand" "")
3397         (div:FP (match_operand:FP 1 "general_operand" "")
3398                 (match_operand:FP 2 "general_operand" "")))]
3399   "TARGET_HARD_FLOAT"
3400   "")
3401
3402 (define_insn "div<mode>3_floatsi_68881"
3403   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3404         (div:FP (match_operand:FP 1 "general_operand" "0")
3405                 (float:FP (match_operand:SI 2 "general_operand" "dmi"))))]
3406   "TARGET_68881"
3407 {
3408   return TARGET_68040
3409          ? "f<FP:round>div%.l %2,%0"
3410          : "f<FP:round_mul>div%.l %2,%0";
3411 })
3412
3413 (define_insn "div<mode>3_floathi_68881"
3414   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3415         (div:FP (match_operand:FP 1 "general_operand" "0")
3416                 (float:FP (match_operand:HI 2 "general_operand" "dmn"))))]
3417   "TARGET_68881"
3418 {
3419   return TARGET_68040
3420          ? "f<FP:round>div%.w %2,%0"
3421          : "f<FP:round_mul>div%.w %2,%0";
3422 })
3423
3424 (define_insn "div<mode>3_floatqi_68881"
3425   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3426         (div:FP (match_operand:FP 1 "general_operand" "0")
3427                 (float:FP (match_operand:QI 2 "general_operand" "dmn"))))]
3428   "TARGET_68881"
3429 {
3430   return TARGET_68040
3431          ? "f<FP:round>div%.b %2,%0"
3432          : "f<FP:round_mul>div%.b %2,%0";
3433 })
3434
3435 (define_insn "div<mode>3_68881"
3436   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3437         (div:FP (match_operand:FP 1 "general_operand" "0")
3438                 (match_operand:FP 2 "general_operand" "f<FP:dreg>m<FP:const>")))]
3439   "TARGET_68881"
3440 {
3441   if (FP_REG_P (operands[2]))
3442     return (TARGET_68040
3443             ? "f<FP:round>div%.x %2,%0"
3444             : "f<FP:round_mul>div%.x %2,%0");
3445   return (TARGET_68040
3446           ? "f<FP:round>div%.<FP:prec> %f2,%0"
3447           : "f<FP:round_mul>div%.<FP:prec> %f2,%0");
3448 })
3449
3450 (define_insn "div<mode>3_cf"
3451   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
3452         (div:FP (match_operand:FP 1 "general_operand" "0")
3453                 (match_operand:FP 2 "general_operand" "f<Q>U<FP:dreg>")))]
3454   "TARGET_COLDFIRE_FPU"
3455 {
3456   if (FP_REG_P (operands[2]))
3457     return "f<FP:prec>div%.d %2,%0";
3458   return "f<FP:prec>div%.<FP:prec> %2,%0";
3459 }
3460   [(set_attr "type" "fdiv")
3461    (set_attr "opy" "2")])
3462 \f
3463 ;; Remainder instructions.
3464
3465 (define_expand "divmodsi4"
3466   [(parallel
3467     [(set (match_operand:SI 0 "nonimmediate_operand" "")
3468           (div:SI (match_operand:SI 1 "general_operand" "")
3469                   (match_operand:SI 2 "general_src_operand" "")))
3470      (set (match_operand:SI 3 "nonimmediate_operand" "")
3471           (mod:SI (match_dup 1) (match_dup 2)))])]
3472   "TARGET_68020 || TARGET_CF_HWDIV"
3473   "")
3474
3475 (define_insn ""
3476   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3477         (div:SI (match_operand:SI 1 "general_operand" "0")
3478                 (match_operand:SI 2 "general_src_operand" "d<Q>U")))
3479    (set (match_operand:SI 3 "nonimmediate_operand" "=&d")
3480         (mod:SI (match_dup 1) (match_dup 2)))]
3481   "TARGET_CF_HWDIV"
3482 {
3483   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3484     return "divs%.l %2,%0";
3485   else if (find_reg_note (insn, REG_UNUSED, operands[0]))
3486     return "rems%.l %2,%3:%0";
3487   else
3488     return "rems%.l %2,%3:%0\;divs%.l %2,%0";
3489 }
3490   [(set_attr "type" "div_l")
3491    (set_attr "opy" "2")])
3492
3493 (define_insn ""
3494   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3495         (div:SI (match_operand:SI 1 "general_operand" "0")
3496                 (match_operand:SI 2 "general_src_operand" "dmSTK")))
3497    (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3498         (mod:SI (match_dup 1) (match_dup 2)))]
3499   "TARGET_68020"
3500 {
3501   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3502     return "divs%.l %2,%0";
3503   else
3504     return "divsl%.l %2,%3:%0";
3505 })
3506
3507 (define_expand "udivmodsi4"
3508   [(parallel
3509     [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3510           (udiv:SI (match_operand:SI 1 "general_operand" "0")
3511                    (match_operand:SI 2 "general_src_operand" "dmSTK")))
3512      (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3513           (umod:SI (match_dup 1) (match_dup 2)))])]
3514   "TARGET_68020 || TARGET_CF_HWDIV"
3515   "")
3516
3517 (define_insn ""
3518   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3519         (udiv:SI (match_operand:SI 1 "general_operand" "0")
3520                  (match_operand:SI 2 "general_src_operand" "d<Q>U")))
3521    (set (match_operand:SI 3 "nonimmediate_operand" "=&d")
3522         (umod:SI (match_dup 1) (match_dup 2)))]
3523   "TARGET_CF_HWDIV"
3524 {
3525   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3526     return "divu%.l %2,%0";
3527   else if (find_reg_note (insn, REG_UNUSED, operands[0]))
3528     return "remu%.l %2,%3:%0";
3529   else
3530     return "remu%.l %2,%3:%0\;divu%.l %2,%0";
3531 }
3532   [(set_attr "type" "div_l")
3533    (set_attr "opy" "2")])
3534
3535 (define_insn ""
3536   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3537         (udiv:SI (match_operand:SI 1 "general_operand" "0")
3538                  (match_operand:SI 2 "general_src_operand" "dmSTK")))
3539    (set (match_operand:SI 3 "nonimmediate_operand" "=d")
3540         (umod:SI (match_dup 1) (match_dup 2)))]
3541   "TARGET_68020 && !TARGET_COLDFIRE"
3542 {
3543   if (find_reg_note (insn, REG_UNUSED, operands[3]))
3544     return "divu%.l %2,%0";
3545   else
3546     return "divul%.l %2,%3:%0";
3547 })
3548
3549 (define_insn "divmodhi4"
3550   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
3551         (div:HI (match_operand:HI 1 "general_operand" "0")
3552                 (match_operand:HI 2 "general_src_operand" "dmSKT")))
3553    (set (match_operand:HI 3 "nonimmediate_operand" "=d")
3554         (mod:HI (match_dup 1) (match_dup 2)))]
3555   "!TARGET_COLDFIRE || TARGET_CF_HWDIV"
3556 {
3557   output_asm_insn (MOTOROLA ?
3558     "ext%.l %0\;divs%.w %2,%0" :
3559     "extl %0\;divs %2,%0",
3560     operands);
3561   if (!find_reg_note(insn, REG_UNUSED, operands[3]))
3562     {
3563       CC_STATUS_INIT;
3564       return "move%.l %0,%3\;swap %3";
3565     }
3566   else
3567     return "";
3568 })
3569
3570 (define_insn "udivmodhi4"
3571   [(set (match_operand:HI 0 "nonimmediate_operand" "=d")
3572         (udiv:HI (match_operand:HI 1 "general_operand" "0")
3573                  (match_operand:HI 2 "general_src_operand" "dmSKT")))
3574    (set (match_operand:HI 3 "nonimmediate_operand" "=d")
3575         (umod:HI (match_dup 1) (match_dup 2)))]
3576   "!TARGET_COLDFIRE || TARGET_CF_HWDIV"
3577 {
3578   if (ISA_HAS_MVS_MVZ)
3579     output_asm_insn (MOTOROLA ?
3580       "mvz%.w %0,%0\;divu%.w %2,%0" :
3581       "mvz%.w %0,%0\;divu %2,%0",
3582       operands);
3583   else
3584     output_asm_insn (MOTOROLA ?
3585       "and%.l #0xFFFF,%0\;divu%.w %2,%0" :
3586       "and%.l #0xFFFF,%0\;divu %2,%0",
3587       operands);
3588
3589   if (!find_reg_note(insn, REG_UNUSED, operands[3]))
3590     {
3591       CC_STATUS_INIT;
3592       return "move%.l %0,%3\;swap %3";
3593     }
3594   else
3595     return "";
3596 })
3597 \f
3598 ;; logical-and instructions
3599
3600 ;; Prevent AND from being made with sp.  This doesn't exist in the machine
3601 ;; and reload will cause inefficient code.  Since sp is a FIXED_REG, we
3602 ;; can't allocate pseudos into it.
3603
3604 (define_expand "andsi3"
3605   [(set (match_operand:SI 0 "not_sp_operand" "")
3606         (and:SI (match_operand:SI 1 "general_operand" "")
3607                 (match_operand:SI 2 "general_src_operand" "")))]
3608   ""
3609   "")
3610
3611 ;; produced by split operations after reload finished
3612 (define_insn "*andsi3_split"
3613   [(set (match_operand:SI 0 "register_operand" "=d")
3614         (and:SI (match_operand:SI 1 "register_operand" "0")
3615                 (match_operand:SI 2 "const_int_operand" "i")))]
3616   "reload_completed && !TARGET_COLDFIRE"
3617 {
3618   return output_andsi3 (operands);
3619 })
3620
3621 (define_insn "andsi3_internal"
3622   [(set (match_operand:SI 0 "not_sp_operand" "=m,d")
3623         (and:SI (match_operand:SI 1 "general_operand" "%0,0")
3624                 (match_operand:SI 2 "general_src_operand" "dKT,dmSM")))]
3625   "!TARGET_COLDFIRE"
3626 {
3627   return output_andsi3 (operands);
3628 })
3629
3630 (define_insn "andsi3_5200"
3631   [(set (match_operand:SI 0 "not_sp_operand" "=m,d")
3632         (and:SI (match_operand:SI 1 "general_operand" "%0,0")
3633                 (match_operand:SI 2 "general_src_operand" "d,dmsK")))]
3634   "TARGET_COLDFIRE"
3635 {
3636   if (ISA_HAS_MVS_MVZ
3637       && DATA_REG_P (operands[0])
3638       && GET_CODE (operands[2]) == CONST_INT)
3639     {
3640       if (INTVAL (operands[2]) == 0x000000ff)
3641         return "mvz%.b %0,%0";
3642       else if (INTVAL (operands[2]) == 0x0000ffff)
3643         return "mvz%.w %0,%0";
3644     }
3645   return output_andsi3 (operands);
3646 })
3647
3648 (define_insn "andhi3"
3649   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,d")
3650         (and:HI (match_operand:HI 1 "general_operand" "%0,0")
3651                 (match_operand:HI 2 "general_src_operand" "dn,dmSn")))]
3652   "!TARGET_COLDFIRE"
3653   "and%.w %2,%0")
3654
3655 (define_insn ""
3656   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3657         (and:HI (match_dup 0)
3658                 (match_operand:HI 1 "general_src_operand" "dn,dmSn")))]
3659   "!TARGET_COLDFIRE"
3660   "and%.w %1,%0")
3661
3662 (define_insn ""
3663   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3664         (and:HI (match_operand:HI 1 "general_src_operand" "dn,dmSn")
3665                 (match_dup 0)))]
3666   "!TARGET_COLDFIRE"
3667   "and%.w %1,%0")
3668
3669 (define_insn "andqi3"
3670   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
3671         (and:QI (match_operand:QI 1 "general_operand" "%0,0")
3672                 (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
3673   "!TARGET_COLDFIRE"
3674   "and%.b %2,%0")
3675
3676 (define_insn ""
3677   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3678         (and:QI (match_dup 0)
3679                 (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
3680   "!TARGET_COLDFIRE"
3681   "and%.b %1,%0")
3682
3683 (define_insn ""
3684   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3685         (and:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
3686                 (match_dup 0)))]
3687   "!TARGET_COLDFIRE"
3688   "and%.b %1,%0")
3689 \f
3690 ;; inclusive-or instructions
3691
3692 (define_insn "iordi_zext"
3693   [(set (match_operand:DI 0 "nonimmediate_operand" "=o,d")
3694     (ior:DI (zero_extend:DI (match_operand 1 "general_operand" "dn,dmn"))
3695         (match_operand:DI 2 "general_operand" "0,0")))]
3696   "!TARGET_COLDFIRE"
3697 {
3698   int byte_mode;
3699
3700   CC_STATUS_INIT;
3701   if (GET_CODE (operands[0]) == REG)
3702     operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3703   else
3704     operands[0] = adjust_address (operands[0], SImode, 4);
3705   if (GET_MODE (operands[1]) == SImode)
3706     return "or%.l %1,%0";
3707   byte_mode = (GET_MODE (operands[1]) == QImode);
3708   if (GET_CODE (operands[0]) == MEM)
3709     operands[0] = adjust_address (operands[0], byte_mode ? QImode : HImode,
3710                                   byte_mode ? 3 : 2);
3711   if (byte_mode)
3712     return "or%.b %1,%0";
3713   else
3714     return "or%.w %1,%0";
3715 })
3716
3717 (define_expand "iorsi3"
3718   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3719         (ior:SI (match_operand:SI 1 "general_operand" "")
3720                 (match_operand:SI 2 "general_src_operand" "")))]
3721   ""
3722   "")
3723
3724 (define_insn "iorsi3_internal"
3725   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d")
3726         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
3727                 (match_operand:SI 2 "general_src_operand" "dKT,dmSMT")))]
3728   "! TARGET_COLDFIRE"
3729 {
3730   return output_iorsi3 (operands);
3731 })
3732
3733 (define_insn "iorsi3_5200"
3734   [(set (match_operand:SI 0 "nonimmediate_operand" "=m,d")
3735         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
3736                 (match_operand:SI 2 "general_src_operand" "d,dmsK")))]
3737   "TARGET_COLDFIRE"
3738 {
3739   return output_iorsi3 (operands);
3740 })
3741
3742 (define_insn "iorhi3"
3743   [(set (match_operand:HI 0 "nonimmediate_operand" "=m,d")
3744         (ior:HI (match_operand:HI 1 "general_operand" "%0,0")
3745                 (match_operand:HI 2 "general_src_operand" "dn,dmSn")))]
3746   "!TARGET_COLDFIRE"
3747   "or%.w %2,%0")
3748
3749 (define_insn ""
3750   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3751         (ior:HI (match_dup 0)
3752                 (match_operand:HI 1 "general_src_operand" "dn,dmSn")))]
3753   "!TARGET_COLDFIRE"
3754   "or%.w %1,%0")
3755
3756 (define_insn ""
3757   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+m,d"))
3758         (ior:HI (match_operand:HI 1 "general_src_operand" "dn,dmSn")
3759                 (match_dup 0)))]
3760   "!TARGET_COLDFIRE"
3761   "or%.w %1,%0")
3762
3763 (define_insn "iorqi3"
3764   [(set (match_operand:QI 0 "nonimmediate_operand" "=m,d")
3765         (ior:QI (match_operand:QI 1 "general_operand" "%0,0")
3766                 (match_operand:QI 2 "general_src_operand" "dn,dmSn")))]
3767   "!TARGET_COLDFIRE"
3768   "or%.b %2,%0")
3769
3770 (define_insn ""
3771   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3772         (ior:QI (match_dup 0)
3773                 (match_operand:QI 1 "general_src_operand" "dn,dmSn")))]
3774   "!TARGET_COLDFIRE"
3775   "or%.b %1,%0")
3776
3777 (define_insn ""
3778   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+m,d"))
3779         (ior:QI (match_operand:QI 1 "general_src_operand" "dn,dmSn")
3780                 (match_dup 0)))]
3781   "!TARGET_COLDFIRE"
3782   "or%.b %1,%0")
3783
3784 ;; On all 68k models, this makes faster code in a special case.
3785 ;; See also ashlsi_16, ashrsi_16 and lshrsi_16.
3786
3787 (define_insn "iorsi_zexthi_ashl16"
3788   [(set (match_operand:SI 0 "nonimmediate_operand" "=&d")
3789     (ior:SI (zero_extend:SI (match_operand:HI 1 "general_operand" "rmn"))
3790         (ashift:SI (match_operand:SI 2 "general_operand" "or")
3791             (const_int 16))))]
3792   ""
3793 {
3794   CC_STATUS_INIT;
3795   if (GET_CODE (operands[2]) != REG)
3796       operands[2] = adjust_address (operands[2], HImode, 2);
3797   if (GET_CODE (operands[2]) != REG
3798   || REGNO (operands[2]) != REGNO (operands[0]))
3799     output_asm_insn ("move%.w %2,%0", operands);
3800   return "swap %0\;mov%.w %1,%0";
3801 })
3802
3803 (define_insn "iorsi_zext"
3804   [(set (match_operand:SI 0 "nonimmediate_operand" "=o,d")
3805     (ior:SI (zero_extend:SI (match_operand 1 "general_operand" "dn,dmn"))
3806         (match_operand:SI 2 "general_operand" "0,0")))]
3807   "!TARGET_COLDFIRE"
3808 {
3809   int byte_mode;
3810
3811   CC_STATUS_INIT;
3812   byte_mode = (GET_MODE (operands[1]) == QImode);
3813   if (GET_CODE (operands[0]) == MEM)
3814     operands[0] = adjust_address (operands[0], byte_mode ? QImode : HImode,
3815                                   byte_mode ? 3 : 2);
3816   if (byte_mode)
3817     return "or%.b %1,%0";
3818   else
3819     return "or%.w %1,%0";
3820 })
3821 \f
3822 ;; xor instructions
3823
3824 (define_expand "xorsi3"
3825   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3826         (xor:SI (match_operand:SI 1 "general_operand" "")
3827                 (match_operand:SI 2 "general_operand" "")))]
3828   ""
3829   "")
3830
3831 (define_insn "xorsi3_internal"
3832   [(set (match_operand:SI 0 "nonimmediate_operand" "=do,m")
3833         (xor:SI (match_operand:SI 1 "general_operand" "%0,0")
3834                 (match_operand:SI 2 "general_operand" "di,dKT")))]
3835
3836   "!TARGET_COLDFIRE"
3837 {
3838   return output_xorsi3 (operands);
3839 })
3840
3841 (define_insn "xorsi3_5200"
3842   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm,d")
3843         (xor:SI (match_operand:SI 1 "general_operand" "%0,0")
3844                 (match_operand:SI 2 "general_operand" "d,Ks")))]
3845   "TARGET_COLDFIRE"
3846 {
3847   return output_xorsi3 (operands);
3848 })
3849
3850 (define_insn "xorhi3"
3851   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
3852         (xor:HI (match_operand:HI 1 "general_operand" "%0")
3853                 (match_operand:HI 2 "general_operand" "dn")))]
3854   "!TARGET_COLDFIRE"
3855   "eor%.w %2,%0")
3856
3857 (define_insn ""
3858   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3859         (xor:HI (match_dup 0)
3860                 (match_operand:HI 1 "general_operand" "dn")))]
3861   "!TARGET_COLDFIRE"
3862   "eor%.w %1,%0")
3863
3864 (define_insn ""
3865   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3866         (xor:HI (match_operand:HI 1 "general_operand" "dn")
3867                 (match_dup 0)))]
3868   "!TARGET_COLDFIRE"
3869   "eor%.w %1,%0")
3870
3871 (define_insn "xorqi3"
3872   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
3873         (xor:QI (match_operand:QI 1 "general_operand" "%0")
3874                 (match_operand:QI 2 "general_operand" "dn")))]
3875   "!TARGET_COLDFIRE"
3876   "eor%.b %2,%0")
3877
3878 (define_insn ""
3879   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3880         (xor:QI (match_dup 0)
3881                 (match_operand:QI 1 "general_operand" "dn")))]
3882   "!TARGET_COLDFIRE"
3883   "eor%.b %1,%0")
3884
3885 (define_insn ""
3886   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3887         (xor:QI (match_operand:QI 1 "general_operand" "dn")
3888                 (match_dup 0)))]
3889   "!TARGET_COLDFIRE"
3890   "eor%.b %1,%0")
3891 \f
3892 ;; negation instructions
3893
3894 (define_expand "negdi2"
3895   [(set (match_operand:DI 0 "nonimmediate_operand" "")
3896         (neg:DI (match_operand:DI 1 "general_operand" "")))]
3897   ""
3898 {
3899   if (TARGET_COLDFIRE)
3900     emit_insn (gen_negdi2_5200 (operands[0], operands[1]));
3901   else
3902     emit_insn (gen_negdi2_internal (operands[0], operands[1]));
3903   DONE;
3904 })
3905
3906 (define_insn "negdi2_internal"
3907   [(set (match_operand:DI 0 "nonimmediate_operand" "=<,do,!*a")
3908         (neg:DI (match_operand:DI 1 "general_operand" "0,0,0")))]
3909   "!TARGET_COLDFIRE"
3910 {
3911   if (which_alternative == 0)
3912     return "neg%.l %0\;negx%.l %0";
3913   if (GET_CODE (operands[0]) == REG)
3914     operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3915   else
3916     operands[1] = adjust_address (operands[0], SImode, 4);
3917   if (ADDRESS_REG_P (operands[0]))
3918     return "exg %/d0,%1\;neg%.l %/d0\;exg %/d0,%1\;exg %/d0,%0\;negx%.l %/d0\;exg %/d0,%0";
3919   else
3920     return "neg%.l %1\;negx%.l %0";
3921 })
3922
3923 (define_insn "negdi2_5200"
3924   [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
3925         (neg:DI (match_operand:DI 1 "general_operand" "0")))]
3926   "TARGET_COLDFIRE"
3927 {
3928   operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
3929   return "neg%.l %1\;negx%.l %0";
3930 })
3931
3932 (define_expand "negsi2"
3933   [(set (match_operand:SI 0 "nonimmediate_operand" "")
3934         (neg:SI (match_operand:SI 1 "general_operand" "")))]
3935   ""
3936 {
3937   if (TARGET_COLDFIRE)
3938     emit_insn (gen_negsi2_5200 (operands[0], operands[1]));
3939   else
3940     emit_insn (gen_negsi2_internal (operands[0], operands[1]));
3941   DONE;
3942 })
3943
3944 (define_insn "negsi2_internal"
3945   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
3946         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
3947   "!TARGET_COLDFIRE"
3948   "neg%.l %0"
3949   [(set_attr "type" "neg_l")])
3950
3951 (define_insn "negsi2_5200"
3952   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
3953         (neg:SI (match_operand:SI 1 "general_operand" "0")))]
3954   "TARGET_COLDFIRE"
3955   "neg%.l %0"
3956   [(set_attr "type" "neg_l")])
3957
3958 (define_insn "neghi2"
3959   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
3960         (neg:HI (match_operand:HI 1 "general_operand" "0")))]
3961   "!TARGET_COLDFIRE"
3962   "neg%.w %0")
3963
3964 (define_insn ""
3965   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
3966         (neg:HI (match_dup 0)))]
3967   "!TARGET_COLDFIRE"
3968   "neg%.w %0")
3969
3970 (define_insn "negqi2"
3971   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
3972         (neg:QI (match_operand:QI 1 "general_operand" "0")))]
3973   "!TARGET_COLDFIRE"
3974   "neg%.b %0")
3975
3976 (define_insn ""
3977   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
3978         (neg:QI (match_dup 0)))]
3979   "!TARGET_COLDFIRE"
3980   "neg%.b %0")
3981
3982 ;; If using software floating point, just flip the sign bit.
3983
3984 (define_expand "negsf2"
3985   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3986         (neg:SF (match_operand:SF 1 "general_operand" "")))]
3987   ""
3988 {
3989   if (!TARGET_HARD_FLOAT)
3990     {
3991       rtx result;
3992       rtx target;
3993
3994       target = operand_subword_force (operands[0], 0, SFmode);
3995       result = expand_binop (SImode, xor_optab,
3996                              operand_subword_force (operands[1], 0, SFmode),
3997                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
3998       gcc_assert (result);
3999
4000       if (result != target)
4001         emit_move_insn (result, target);
4002
4003       /* Make a place for REG_EQUAL.  */
4004       emit_move_insn (operands[0], operands[0]);
4005       DONE;
4006     }
4007 })
4008
4009 (define_expand "negdf2"
4010   [(set (match_operand:DF 0 "nonimmediate_operand" "")
4011         (neg:DF (match_operand:DF 1 "general_operand" "")))]
4012   ""
4013 {
4014   if (!TARGET_HARD_FLOAT)
4015     {
4016       rtx result;
4017       rtx target;
4018       rtx insns;
4019
4020       start_sequence ();
4021       target = operand_subword (operands[0], 0, 1, DFmode);
4022       result = expand_binop (SImode, xor_optab,
4023                              operand_subword_force (operands[1], 0, DFmode),
4024                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
4025       gcc_assert (result);
4026
4027       if (result != target)
4028         emit_move_insn (result, target);
4029
4030       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
4031                       operand_subword_force (operands[1], 1, DFmode));
4032
4033       insns = get_insns ();
4034       end_sequence ();
4035
4036       emit_insn (insns);
4037       DONE;
4038     }
4039 })
4040
4041 (define_expand "negxf2"
4042   [(set (match_operand:XF 0 "nonimmediate_operand" "")
4043         (neg:XF (match_operand:XF 1 "nonimmediate_operand" "")))]
4044   ""
4045 {
4046   if (!TARGET_68881)
4047     {
4048       rtx result;
4049       rtx target;
4050       rtx insns;
4051
4052       start_sequence ();
4053       target = operand_subword (operands[0], 0, 1, XFmode);
4054       result = expand_binop (SImode, xor_optab,
4055                              operand_subword_force (operands[1], 0, XFmode),
4056                              GEN_INT (-2147483647 - 1), target, 0, OPTAB_WIDEN);
4057       gcc_assert (result);
4058
4059       if (result != target)
4060         emit_move_insn (result, target);
4061
4062       emit_move_insn (operand_subword (operands[0], 1, 1, XFmode),
4063                       operand_subword_force (operands[1], 1, XFmode));
4064       emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
4065                       operand_subword_force (operands[1], 2, XFmode));
4066
4067       insns = get_insns ();
4068       end_sequence ();
4069
4070       emit_insn (insns);
4071       DONE;
4072     }
4073 })
4074
4075 (define_insn "neg<mode>2_68881"
4076   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
4077         (neg:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m<FP:const>,0")))]
4078   "TARGET_68881"
4079 {
4080   if (DATA_REG_P (operands[0]))
4081     {
4082       operands[1] = GEN_INT (31);
4083       return "bchg %1,%0";
4084     }
4085   if (FP_REG_P (operands[1]))
4086     return "f<FP:round>neg%.x %1,%0";
4087   return "f<FP:round>neg%.<FP:prec> %f1,%0";
4088 })
4089
4090 (define_insn "neg<mode>2_cf"
4091   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
4092         (neg:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U,0")))]
4093   "TARGET_COLDFIRE_FPU"
4094 {
4095   if (DATA_REG_P (operands[0]))
4096     {
4097       operands[1] = GEN_INT (31);
4098       return "bchg %1,%0";
4099     }
4100   if (FP_REG_P (operands[1]))
4101     return "f<FP:prec>neg%.d %1,%0";
4102   return "f<FP:prec>neg%.<FP:prec> %1,%0";
4103 })
4104 \f
4105 ;; Sqrt instruction for the 68881
4106
4107 (define_expand "sqrt<mode>2"
4108   [(set (match_operand:FP 0 "nonimmediate_operand" "")
4109         (sqrt:FP (match_operand:FP 1 "general_operand" "")))]
4110   "TARGET_HARD_FLOAT"
4111   "")
4112
4113 (define_insn "sqrt<mode>2_68881"
4114   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
4115         (sqrt:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m")))]
4116   "TARGET_68881"
4117 {
4118   if (FP_REG_P (operands[1]))
4119     return "f<FP:round>sqrt%.x %1,%0";
4120   return "f<FP:round>sqrt%.<FP:prec> %1,%0";
4121 }
4122   [(set_attr "type" "fsqrt")])
4123
4124 (define_insn "sqrt<mode>2_cf"
4125   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
4126         (sqrt:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U")))]
4127   "TARGET_COLDFIRE_FPU"
4128 {
4129   if (FP_REG_P (operands[1]))
4130     return "f<FP:prec>sqrt%.d %1,%0";
4131   return "f<FP:prec>sqrt%.<FP:prec> %1,%0";
4132 }
4133   [(set_attr "type" "fsqrt")])
4134 ;; Absolute value instructions
4135 ;; If using software floating point, just zero the sign bit.
4136
4137 (define_expand "abssf2"
4138   [(set (match_operand:SF 0 "nonimmediate_operand" "")
4139         (abs:SF (match_operand:SF 1 "general_operand" "")))]
4140   ""
4141 {
4142   if (!TARGET_HARD_FLOAT)
4143     {
4144       rtx result;
4145       rtx target;
4146
4147       target = operand_subword_force (operands[0], 0, SFmode);
4148       result = expand_binop (SImode, and_optab,
4149                              operand_subword_force (operands[1], 0, SFmode),
4150                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
4151       gcc_assert (result);
4152
4153       if (result != target)
4154         emit_move_insn (result, target);
4155
4156       /* Make a place for REG_EQUAL.  */
4157       emit_move_insn (operands[0], operands[0]);
4158       DONE;
4159     }
4160 })
4161
4162 (define_expand "absdf2"
4163   [(set (match_operand:DF 0 "nonimmediate_operand" "")
4164         (abs:DF (match_operand:DF 1 "general_operand" "")))]
4165   ""
4166 {
4167   if (!TARGET_HARD_FLOAT)
4168     {
4169       rtx result;
4170       rtx target;
4171       rtx insns;
4172
4173       start_sequence ();
4174       target = operand_subword (operands[0], 0, 1, DFmode);
4175       result = expand_binop (SImode, and_optab,
4176                              operand_subword_force (operands[1], 0, DFmode),
4177                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
4178       gcc_assert (result);
4179
4180       if (result != target)
4181         emit_move_insn (result, target);
4182
4183       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
4184                       operand_subword_force (operands[1], 1, DFmode));
4185
4186       insns = get_insns ();
4187       end_sequence ();
4188
4189       emit_insn (insns);
4190       DONE;
4191     }
4192 })
4193
4194 (define_expand "absxf2"
4195   [(set (match_operand:XF 0 "nonimmediate_operand" "")
4196         (abs:XF (match_operand:XF 1 "nonimmediate_operand" "")))]
4197   ""
4198 {
4199   if (!TARGET_68881)
4200     {
4201       rtx result;
4202       rtx target;
4203       rtx insns;
4204
4205       start_sequence ();
4206       target = operand_subword (operands[0], 0, 1, XFmode);
4207       result = expand_binop (SImode, and_optab,
4208                              operand_subword_force (operands[1], 0, XFmode),
4209                              GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
4210       gcc_assert (result);
4211
4212       if (result != target)
4213         emit_move_insn (result, target);
4214
4215       emit_move_insn (operand_subword (operands[0], 1, 1, XFmode),
4216                       operand_subword_force (operands[1], 1, XFmode));
4217       emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
4218                       operand_subword_force (operands[1], 2, XFmode));
4219
4220       insns = get_insns ();
4221       end_sequence ();
4222
4223       emit_insn (insns);
4224       DONE;
4225     }
4226 })
4227
4228 (define_insn "abs<mode>2_68881"
4229   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
4230         (abs:FP (match_operand:FP 1 "general_operand" "f<FP:dreg>m<FP:const>,0")))]
4231   "TARGET_68881"
4232 {
4233   if (DATA_REG_P (operands[0]))
4234     {
4235       operands[1] = GEN_INT (31);
4236       return "bclr %1,%0";
4237     }
4238   if (FP_REG_P (operands[1]))
4239     return "f<FP:round>abs%.x %1,%0";
4240   return "f<FP:round>abs%.<FP:prec> %f1,%0";
4241 })
4242
4243 (define_insn "abs<mode>2_cf"
4244   [(set (match_operand:FP 0 "nonimmediate_operand" "=f,d")
4245         (abs:FP (match_operand:FP 1 "general_operand" "f<FP:dreg><Q>U,0")))]
4246   "TARGET_COLDFIRE_FPU"
4247 {
4248   if (DATA_REG_P (operands[0]))
4249     {
4250       operands[1] = GEN_INT (31);
4251       return "bclr %1,%0";
4252     }
4253   if (FP_REG_P (operands[1]))
4254     return "f<FP:prec>abs%.d %1,%0";
4255   return "f<FP:prec>abs%.<FP:prec> %1,%0";
4256 }
4257   [(set_attr "type" "bitrw,fneg")])
4258 \f
4259 ;; bit indexing instructions
4260
4261 (define_expand "clzsi2"
4262   [(set (match_operand:SI 0 "register_operand" "")
4263         (clz:SI (match_operand:SI 1 "general_operand" "")))]
4264   "ISA_HAS_FF1 || (TARGET_68020 && TARGET_BITFIELD)"
4265 {
4266   if (ISA_HAS_FF1)
4267     operands[1] = force_reg (SImode, operands[1]);
4268 })
4269
4270 (define_insn "*clzsi2_68k"
4271   [(set (match_operand:SI 0 "register_operand" "=d")
4272         (clz:SI (match_operand:SI 1 "general_operand" "do")))]
4273   "TARGET_68020 && TARGET_BITFIELD"
4274 {
4275   CC_STATUS_INIT;
4276   return "bfffo %1{#0:#0},%0";
4277 })
4278
4279 ;; ColdFire ff1 instruction implements clz.
4280 (define_insn "*clzsi2_cf"
4281   [(set (match_operand:SI 0 "register_operand" "=d")
4282         (clz:SI (match_operand:SI 1 "register_operand" "0")))]
4283   "ISA_HAS_FF1"
4284 {
4285   CC_STATUS_INIT;
4286   return "ff1 %0";
4287 }
4288   [(set_attr "type" "ext")])
4289 \f
4290 ;; one complement instructions
4291
4292 (define_expand "one_cmplsi2"
4293   [(set (match_operand:SI 0 "nonimmediate_operand" "")
4294         (not:SI (match_operand:SI 1 "general_operand" "")))]
4295   ""
4296 {
4297   if (TARGET_COLDFIRE)
4298     emit_insn (gen_one_cmplsi2_5200 (operands[0], operands[1]));
4299   else
4300     emit_insn (gen_one_cmplsi2_internal (operands[0], operands[1]));
4301   DONE;
4302 })
4303
4304 (define_insn "one_cmplsi2_internal"
4305   [(set (match_operand:SI 0 "nonimmediate_operand" "=dm")
4306         (not:SI (match_operand:SI 1 "general_operand" "0")))]
4307   "!TARGET_COLDFIRE"
4308   "not%.l %0")
4309
4310 (define_insn "one_cmplsi2_5200"
4311   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
4312         (not:SI (match_operand:SI 1 "general_operand" "0")))]
4313   "TARGET_COLDFIRE"
4314   "not%.l %0"
4315   [(set_attr "type" "neg_l")])
4316
4317 (define_insn "one_cmplhi2"
4318   [(set (match_operand:HI 0 "nonimmediate_operand" "=dm")
4319         (not:HI (match_operand:HI 1 "general_operand" "0")))]
4320   "!TARGET_COLDFIRE"
4321   "not%.w %0")
4322
4323 (define_insn ""
4324   [(set (strict_low_part (match_operand:HI 0 "nonimmediate_operand" "+dm"))
4325         (not:HI (match_dup 0)))]
4326   "!TARGET_COLDFIRE"
4327   "not%.w %0")
4328
4329 (define_insn "one_cmplqi2"
4330   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
4331         (not:QI (match_operand:QI 1 "general_operand" "0")))]
4332   "!TARGET_COLDFIRE"
4333   "not%.b %0")
4334
4335 (define_insn ""
4336   [(set (strict_low_part (match_operand:QI 0 "nonimmediate_operand" "+dm"))
4337         (not:QI (match_dup 0)))]
4338   "!TARGET_COLDFIRE"
4339   "not%.b %0")
4340 \f
4341 ;; arithmetic shift instructions
4342 ;; We don't need the shift memory by 1 bit instruction
4343
4344 (define_insn "ashldi_extsi"
4345   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro")
4346     (ashift:DI
4347       (match_operator:DI 2 "extend_operator"
4348         [(match_operand:SI 1 "general_operand" "rm")])
4349       (const_int 32)))]
4350   ""
4351 {
4352   CC_STATUS_INIT;
4353   if (GET_CODE (operands[0]) == REG)
4354     operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
4355   else
4356     operands[2] = adjust_address (operands[0], SImode, 4);
4357   if (ADDRESS_REG_P (operands[0]))
4358     return "move%.l %1,%0\;sub%.l %2,%2";
4359   else
4360     return "move%.l %1,%0\;clr%.l %2";
4361 })
4362
4363 (define_insn "ashldi_sexthi"
4364   [(set (match_operand:DI 0 "nonimmediate_operand" "=m,a*d")
4365     (ashift:DI (sign_extend:DI (match_operand:HI 1 "general_operand" "rm,rm"))
4366         (const_int 32)))
4367     (clobber (match_scratch:SI 2 "=a,X"))]
4368   ""
4369 {
4370   CC_STATUS_INIT;
4371   if (GET_CODE (operands[0]) == MEM)
4372     {
4373     if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
4374       return "clr%.l %0\;move%.w %1,%2\;move%.l %2,%0";
4375     else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
4376       return "move%.w %1,%2\;move%.l %2,%0\;clr%.l %0";
4377     else
4378       {
4379         operands[3] = adjust_address (operands[0], SImode, 4);
4380         return "move%.w %1,%2\;move%.l %2,%0\;clr%.l %3";
4381       }
4382     }
4383   else if (DATA_REG_P (operands[0]))
4384     return "move%.w %1,%0\;ext%.l %0\;clr%.l %R0";
4385   else
4386     return "move%.w %1,%0\;sub%.l %R0,%R0";
4387 })
4388
4389 (define_insn "*ashldi3_const1"
4390   [(set (match_operand:DI 0 "register_operand" "=d")
4391         (ashift:DI (match_operand:DI 1 "register_operand" "0")
4392                    (const_int 1)))]
4393   "!TARGET_COLDFIRE"
4394   "add%.l %R0,%R0\;addx%.l %0,%0")
4395
4396 (define_split
4397   [(set (match_operand:DI 0 "register_operand" "")
4398         (ashift:DI (match_operand:DI 1 "register_operand" "")
4399                    (const_int 2)))]
4400   "reload_completed && !TARGET_COLDFIRE"
4401   [(set (match_dup 0)
4402         (ashift:DI (match_dup 1) (const_int 1)))
4403    (set (match_dup 0)
4404         (ashift:DI (match_dup 0) (const_int 1)))]
4405   "")
4406
4407 (define_split
4408   [(set (match_operand:DI 0 "register_operand" "")
4409         (ashift:DI (match_operand:DI 1 "register_operand" "")
4410                    (const_int 3)))]
4411   "reload_completed && !TARGET_COLDFIRE"
4412   [(set (match_dup 0)
4413         (ashift:DI (match_dup 1) (const_int 2)))
4414    (set (match_dup 0)
4415         (ashift:DI (match_dup 0) (const_int 1)))]
4416   "")
4417
4418 (define_split
4419   [(set (match_operand:DI 0 "register_operand" "")
4420         (ashift:DI (match_operand:DI 1 "register_operand" "")
4421                    (const_int 8)))]
4422   "reload_completed && !TARGET_COLDFIRE"
4423   [(set (match_dup 2)
4424         (rotate:SI (match_dup 2) (const_int 8)))
4425    (set (match_dup 3)
4426         (rotate:SI (match_dup 3) (const_int 8)))
4427    (set (strict_low_part (subreg:QI (match_dup 0) 3))
4428         (subreg:QI (match_dup 0) 7))
4429    (set (strict_low_part (subreg:QI (match_dup 0) 7))
4430         (const_int 0))]
4431 {
4432   operands[2] = gen_highpart (SImode, operands[0]);
4433   operands[3] = gen_lowpart (SImode, operands[0]);
4434 })
4435
4436 (define_split
4437   [(set (match_operand:DI 0 "register_operand" "")
4438         (ashift:DI (match_operand:DI 1 "register_operand" "")
4439                    (const_int 16)))]
4440   "reload_completed && !TARGET_COLDFIRE"
4441   [(set (match_dup 2)
4442         (rotate:SI (match_dup 2) (const_int 16)))
4443    (set (match_dup 3)
4444         (rotate:SI (match_dup 3) (const_int 16)))
4445    (set (strict_low_part (subreg:HI (match_dup 0) 2))
4446         (subreg:HI (match_dup 0) 6))
4447    (set (strict_low_part (subreg:HI (match_dup 0) 6))
4448         (const_int 0))]
4449 {
4450   operands[2] = gen_highpart (SImode, operands[0]);
4451   operands[3] = gen_lowpart (SImode, operands[0]);
4452 })
4453
4454 (define_split
4455   [(set (match_operand:DI 0 "pre_dec_operand" "")
4456         (ashift:DI (match_operand:DI 1 "nonimmediate_operand" "")
4457                    (const_int 32)))]
4458   "reload_completed"
4459   [(set (match_dup 0) (const_int 0))
4460    (set (match_dup 0) (match_dup 1))]
4461 {
4462   operands[0] = adjust_address(operands[0], SImode, 0);
4463   operands[1] = gen_lowpart(SImode, operands[1]);
4464 })
4465
4466 (define_split
4467   [(set (match_operand:DI 0 "post_inc_operand" "")
4468         (ashift:DI (match_operand:DI 1 "nonimmediate_operand" "")
4469                    (const_int 32)))]
4470   "reload_completed"
4471   [(set (match_dup 0) (match_dup 1))
4472    (set (match_dup 0) (const_int 0))]
4473 {
4474   operands[0] = adjust_address(operands[0], SImode, 0);
4475   operands[1] = gen_lowpart(SImode, operands[1]);
4476 })
4477
4478 (define_insn_and_split "*ashldi3_const32"
4479   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro<>")
4480         (ashift:DI (match_operand:DI 1 "nonimmediate_operand" "ro")
4481                    (const_int 32)))]
4482   ""
4483   "#"
4484   "&& reload_completed"
4485   [(set (match_dup 4) (match_dup 3))
4486    (set (match_dup 2) (const_int 0))]
4487   "split_di(operands, 2, operands + 2, operands + 4);")
4488
4489 (define_split
4490   [(set (match_operand:DI 0 "register_operand" "")
4491         (ashift:DI (match_operand:DI 1 "register_operand" "")
4492                    (match_operand 2 "const_int_operand" "")))]
4493   "reload_completed && !TARGET_COLDFIRE
4494    && INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 40"
4495   [(set (match_dup 4) (ashift:SI (match_dup 4) (match_dup 2)))
4496    (set (match_dup 3) (match_dup 4))
4497    (set (match_dup 4) (const_int 0))]
4498 {
4499   operands[2] = GEN_INT (INTVAL (operands[2]) - 32);
4500   operands[3] = gen_highpart (SImode, operands[0]);
4501   operands[4] = gen_lowpart (SImode, operands[0]);
4502 })
4503
4504 (define_split
4505   [(set (match_operand:DI 0 "register_operand" "")
4506         (ashift:DI (match_operand:DI 1 "register_operand" "")
4507                    (const_int 48)))]
4508   "reload_completed && !TARGET_COLDFIRE"
4509   [(set (match_dup 2) (match_dup 3))
4510    (set (match_dup 2)
4511         (rotate:SI (match_dup 2) (const_int 16)))
4512    (set (match_dup 3) (const_int 0))
4513    (set (strict_low_part (subreg:HI (match_dup 0) 2))
4514         (const_int 0))]
4515 {
4516   operands[2] = gen_highpart (SImode, operands[0]);
4517   operands[3] = gen_lowpart (SImode, operands[0]);
4518 })
4519
4520 (define_split
4521   [(set (match_operand:DI 0 "register_operand" "")
4522         (ashift:DI (match_operand:DI 1 "register_operand" "")
4523                    (match_operand 2 "const_int_operand" "")))]
4524   "reload_completed && !TARGET_COLDFIRE
4525    && INTVAL (operands[2]) > 40 && INTVAL (operands[2]) <= 63"
4526   [(set (match_dup 3) (match_dup 2))
4527    (set (match_dup 4) (ashift:SI (match_dup 4) (match_dup 3)))
4528    (set (match_dup 3) (match_dup 4))
4529    (set (match_dup 4) (const_int 0))]
4530 {
4531   operands[2] = GEN_INT (INTVAL (operands[2]) - 32);
4532   operands[3] = gen_highpart (SImode, operands[0]);
4533   operands[4] = gen_lowpart (SImode, operands[0]);
4534 })
4535
4536 (define_insn "*ashldi3"
4537   [(set (match_operand:DI 0 "register_operand" "=d")
4538         (ashift:DI (match_operand:DI 1 "register_operand" "0")
4539                    (match_operand 2 "const_int_operand" "n")))]
4540   "!TARGET_COLDFIRE
4541     && ((INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 3)
4542         || INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16
4543         || (INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 63))"
4544   "#")
4545
4546 (define_expand "ashldi3"
4547   [(set (match_operand:DI 0 "register_operand" "")
4548         (ashift:DI (match_operand:DI 1 "register_operand" "")
4549                    (match_operand 2 "const_int_operand" "")))]
4550   "!TARGET_COLDFIRE"
4551 {
4552   /* ???  This is a named pattern like this is not allowed to FAIL based
4553      on its operands.  */
4554   if (GET_CODE (operands[2]) != CONST_INT
4555       || ((INTVAL (operands[2]) < 1 || INTVAL (operands[2]) > 3)
4556           && INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16
4557           && (INTVAL (operands[2]) < 32 || INTVAL (operands[2]) > 63)))
4558     FAIL;
4559 })
4560
4561 ;; On most 68k models, this makes faster code in a special case.
4562
4563 (define_insn "ashlsi_16"
4564   [(set (match_operand:SI 0 "register_operand" "=d")
4565         (ashift:SI (match_operand:SI 1 "register_operand" "0")
4566                    (const_int 16)))]
4567   "!TUNE_68060"
4568 {
4569   CC_STATUS_INIT;
4570   return "swap %0\;clr%.w %0";
4571 })
4572
4573 ;; ashift patterns : use lsl instead of asl, because lsl always clears the
4574 ;; overflow bit, so we must not set CC_NO_OVERFLOW.
4575
4576 ;; On the 68000, this makes faster code in a special case.
4577
4578 (define_insn "ashlsi_17_24"
4579   [(set (match_operand:SI 0 "register_operand" "=d")
4580         (ashift:SI (match_operand:SI 1 "register_operand" "0")
4581                    (match_operand:SI 2 "const_int_operand" "n")))]
4582   "TUNE_68000_10
4583    && INTVAL (operands[2]) > 16
4584    && INTVAL (operands[2]) <= 24"
4585 {
4586   CC_STATUS_INIT;
4587
4588   operands[2] = GEN_INT (INTVAL (operands[2]) - 16);
4589   return "lsl%.w %2,%0\;swap %0\;clr%.w %0";
4590 })
4591
4592 (define_insn "ashlsi3"
4593   [(set (match_operand:SI 0 "register_operand" "=d")
4594         (ashift:SI (match_operand:SI 1 "register_operand" "0")
4595                    (match_operand:SI 2 "general_operand" "dI")))]
4596   ""
4597 {
4598   if (operands[2] == const1_rtx)
4599     {
4600       cc_status.flags = CC_NO_OVERFLOW;
4601       return "add%.l %0,%0";
4602     }
4603   return "lsl%.l %2,%0";
4604 })
4605
4606 (define_insn "ashlhi3"
4607   [(set (match_operand:HI 0 "register_operand" "=d")
4608         (ashift:HI (match_operand:HI 1 "register_operand" "0")
4609                    (match_operand:HI 2 "general_operand" "dI")))]
4610   "!TARGET_COLDFIRE"
4611   "lsl%.w %2,%0")
4612
4613 (define_insn ""
4614   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d"))
4615         (ashift:HI (match_dup 0)
4616                    (match_operand:HI 1 "general_operand" "dI")))]
4617   "!TARGET_COLDFIRE"
4618   "lsl%.w %1,%0")
4619
4620 (define_insn "ashlqi3"
4621   [(set (match_operand:QI 0 "register_operand" "=d")
4622         (ashift:QI (match_operand:QI 1 "register_operand" "0")
4623                    (match_operand:QI 2 "general_operand" "dI")))]
4624   "!TARGET_COLDFIRE"
4625   "lsl%.b %2,%0")
4626
4627 (define_insn ""
4628   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d"))
4629         (ashift:QI (match_dup 0)
4630                    (match_operand:QI 1 "general_operand" "dI")))]
4631   "!TARGET_COLDFIRE"
4632   "lsl%.b %1,%0")
4633
4634 ;; On most 68k models, this makes faster code in a special case.
4635
4636 (define_insn "ashrsi_16"
4637   [(set (match_operand:SI 0 "register_operand" "=d")
4638         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
4639                      (const_int 16)))]
4640   "!TUNE_68060"
4641   "swap %0\;ext%.l %0")
4642
4643 ;; On the 68000, this makes faster code in a special case.
4644
4645 (define_insn ""
4646   [(set (match_operand:SI 0 "register_operand" "=d")
4647         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
4648                      (match_operand:SI 2 "const_int_operand" "n")))]
4649   "TUNE_68000_10
4650    && INTVAL (operands[2]) > 16
4651    && INTVAL (operands[2]) <= 24"
4652 {
4653   operands[2] = GEN_INT (INTVAL (operands[2]) - 16);
4654   return "swap %0\;asr%.w %2,%0\;ext%.l %0";
4655 })
4656
4657 (define_insn "subreghi1ashrdi_const32"
4658   [(set (match_operand:HI 0 "nonimmediate_operand" "=rm")
4659     (subreg:HI (ashiftrt:DI (match_operand:DI 1 "general_operand" "ro")
4660             (const_int 32)) 6))]
4661   ""
4662 {
4663   if (GET_CODE (operands[1]) != REG)
4664     operands[1] = adjust_address (operands[1], HImode, 2);
4665   return "move%.w %1,%0";
4666 }
4667   [(set_attr "type" "move")])
4668
4669 (define_insn "subregsi1ashrdi_const32"
4670   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
4671     (subreg:SI (ashiftrt:DI (match_operand:DI 1 "general_operand" "ro")
4672             (const_int 32)) 4))]
4673   ""
4674 {
4675   return "move%.l %1,%0";
4676 }
4677   [(set_attr "type" "move_l")])
4678
4679 (define_insn "*ashrdi3_const1"
4680   [(set (match_operand:DI 0 "register_operand" "=d")
4681         (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
4682                      (const_int 1)))]
4683   "!TARGET_COLDFIRE"
4684 {
4685   operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
4686   return "asr%.l #1,%0\;roxr%.l #1,%1";
4687 })
4688
4689 (define_split
4690   [(set (match_operand:DI 0 "register_operand" "")
4691         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4692                      (const_int 2)))]
4693   "reload_completed && !TARGET_COLDFIRE"
4694   [(set (match_dup 0)
4695         (ashiftrt:DI (match_dup 1) (const_int 1)))
4696    (set (match_dup 0)
4697         (ashiftrt:DI (match_dup 0) (const_int 1)))]
4698   "")
4699
4700 (define_split
4701   [(set (match_operand:DI 0 "register_operand" "")
4702         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4703                      (const_int 3)))]
4704   "reload_completed && !TARGET_COLDFIRE"
4705   [(set (match_dup 0)
4706         (ashiftrt:DI (match_dup 1) (const_int 2)))
4707    (set (match_dup 0)
4708         (ashiftrt:DI (match_dup 0) (const_int 1)))]
4709   "")
4710
4711 (define_split
4712   [(set (match_operand:DI 0 "register_operand" "")
4713         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4714                      (const_int 8)))]
4715   "reload_completed && !TARGET_COLDFIRE"
4716   [(set (strict_low_part (subreg:QI (match_dup 0) 7))
4717         (subreg:QI (match_dup 0) 3))
4718    (set (match_dup 2)
4719         (ashiftrt:SI (match_dup 2) (const_int 8)))
4720    (set (match_dup 3)
4721         (rotatert:SI (match_dup 3) (const_int 8)))]
4722 {
4723   operands[2] = gen_highpart (SImode, operands[0]);
4724   operands[3] = gen_lowpart (SImode, operands[0]);
4725 })
4726
4727 (define_split
4728   [(set (match_operand:DI 0 "register_operand" "")
4729         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4730                      (const_int 16)))]
4731   "reload_completed && !TARGET_COLDFIRE"
4732   [(set (strict_low_part (subreg:HI (match_dup 0) 6))
4733         (subreg:HI (match_dup 0) 2))
4734    (set (match_dup 2)
4735         (rotate:SI (match_dup 2) (const_int 16)))
4736    (set (match_dup 3)
4737         (rotate:SI (match_dup 3) (const_int 16)))
4738    (set (match_dup 2)
4739         (sign_extend:SI (subreg:HI (match_dup 2) 2)))]
4740 {
4741   operands[2] = gen_highpart (SImode, operands[0]);
4742   operands[3] = gen_lowpart (SImode, operands[0]);
4743 })
4744
4745 (define_insn "*ashrdi_const32"
4746   [(set (match_operand:DI 0 "register_operand" "=d")
4747         (ashiftrt:DI (match_operand:DI 1 "nonimmediate_src_operand" "ro")
4748                      (const_int 32)))]
4749   ""
4750 {
4751   CC_STATUS_INIT;
4752   if (TARGET_68020)
4753     return "move%.l %1,%R0\;smi %0\;extb%.l %0";
4754   else
4755     return "move%.l %1,%R0\;smi %0\;ext%.w %0\;ext%.l %0";
4756 })
4757
4758 (define_insn "*ashrdi_const32_mem"
4759   [(set (match_operand:DI 0 "memory_operand" "=o,<")
4760         (ashiftrt:DI (match_operand:DI 1 "nonimmediate_src_operand" "ro,ro")
4761                      (const_int 32)))
4762    (clobber (match_scratch:SI 2 "=d,d"))]
4763   ""
4764 {
4765   CC_STATUS_INIT;
4766   operands[3] = adjust_address (operands[0], SImode,
4767                                 which_alternative == 0 ? 4 : 0);
4768   operands[0] = adjust_address (operands[0], SImode, 0);
4769   if (TARGET_68020 || TARGET_COLDFIRE)
4770     return "move%.l %1,%3\;smi %2\;extb%.l %2\;move%.l %2,%0";
4771   else
4772     return "move%.l %1,%3\;smi %2\;ext%.w %2\;ext%.l %2\;move%.l %2,%0";
4773 })
4774
4775 (define_split
4776   [(set (match_operand:DI 0 "register_operand" "")
4777         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4778                      (const_int 63)))]
4779   "reload_completed && !TARGET_COLDFIRE"
4780   [(set (match_dup 3)
4781         (ashiftrt:SI (match_dup 3) (const_int 31)))
4782    (set (match_dup 2)
4783         (match_dup 3))]
4784   "split_di(operands, 1, operands + 2, operands + 3);")
4785
4786 ;; The predicate below must be general_operand, because ashrdi3 allows that
4787 (define_insn "ashrdi_const"
4788   [(set (match_operand:DI 0 "register_operand" "=d")
4789         (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
4790                      (match_operand 2 "const_int_operand" "n")))]
4791   "!TARGET_COLDFIRE
4792     && ((INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 3)
4793         || INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16
4794         || INTVAL (operands[2]) == 31
4795         || (INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 63))"
4796 {
4797   operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
4798   CC_STATUS_INIT;
4799   if (INTVAL (operands[2]) == 48)
4800     return "swap %0\;ext%.l %0\;move%.l %0,%1\;smi %0\;ext%.w %0";
4801   if (INTVAL (operands[2]) == 31)
4802     return "add%.l %1,%1\;addx%.l %0,%0\;move%.l %0,%1\;subx%.l %0,%0";
4803   if (INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 63)
4804     {
4805       operands[2] = GEN_INT (INTVAL (operands[2]) - 32);
4806       output_asm_insn (INTVAL (operands[2]) <= 8 ? "asr%.l %2,%0" :
4807                         "moveq %2,%1\;asr%.l %1,%0", operands);
4808       output_asm_insn ("mov%.l %0,%1\;smi %0", operands);
4809       return INTVAL (operands[2]) >= 15 ? "ext%.w %d0" :
4810              TARGET_68020 ? "extb%.l %0" : "ext%.w %0\;ext%.l %0";
4811     }
4812   return "#";
4813 })
4814
4815 (define_expand "ashrdi3"
4816   [(set (match_operand:DI 0 "register_operand" "")
4817         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
4818                      (match_operand 2 "const_int_operand" "")))]
4819   "!TARGET_COLDFIRE"
4820 {
4821   /* ???  This is a named pattern like this is not allowed to FAIL based
4822      on its operands.  */
4823   if (GET_CODE (operands[2]) != CONST_INT
4824       || ((INTVAL (operands[2]) < 1 || INTVAL (operands[2]) > 3)
4825           && INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16
4826           && (INTVAL (operands[2]) < 31 || INTVAL (operands[2]) > 63)))
4827     FAIL;
4828 })
4829
4830 ;; On all 68k models, this makes faster code in a special case.
4831
4832 (define_insn "ashrsi_31"
4833   [(set (match_operand:SI 0 "register_operand" "=d")
4834         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
4835                      (const_int 31)))]
4836   ""
4837 {
4838   return "add%.l %0,%0\;subx%.l %0,%0";
4839 })
4840
4841 (define_insn "ashrsi3"
4842   [(set (match_operand:SI 0 "register_operand" "=d")
4843         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
4844                      (match_operand:SI 2 "general_operand" "dI")))]
4845   ""
4846   "asr%.l %2,%0"
4847   [(set_attr "type" "shift")
4848    (set_attr "opy" "2")])
4849
4850 (define_insn "ashrhi3"
4851   [(set (match_operand:HI 0 "register_operand" "=d")
4852         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
4853                      (match_operand:HI 2 "general_operand" "dI")))]
4854   "!TARGET_COLDFIRE"
4855   "asr%.w %2,%0")
4856
4857 (define_insn ""
4858   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d"))
4859         (ashiftrt:HI (match_dup 0)
4860                      (match_operand:HI 1 "general_operand" "dI")))]
4861   "!TARGET_COLDFIRE"
4862   "asr%.w %1,%0")
4863
4864 (define_insn "ashrqi3"
4865   [(set (match_operand:QI 0 "register_operand" "=d")
4866         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
4867                      (match_operand:QI 2 "general_operand" "dI")))]
4868   "!TARGET_COLDFIRE"
4869   "asr%.b %2,%0")
4870
4871 (define_insn ""
4872   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d"))
4873         (ashiftrt:QI (match_dup 0)
4874                      (match_operand:QI 1 "general_operand" "dI")))]
4875   "!TARGET_COLDFIRE"
4876   "asr%.b %1,%0")
4877 \f
4878 ;; logical shift instructions
4879
4880 ;; commented out because of reload problems in 950612-1.c
4881 ;;(define_insn ""
4882 ;;        [(set (cc0)
4883 ;;            (subreg:SI (lshiftrt:DI (match_operand:DI 0 "general_operand" "ro")
4884 ;;                    (const_int 32)) 4))
4885 ;;        (set (match_operand:SI 1 "nonimmediate_operand" "=dm")
4886 ;;            (subreg:SI (lshiftrt:DI (match_dup 0)
4887 ;;                    (const_int 32)) 4))]
4888 ;;  ""
4889 ;;{
4890 ;;  return "move%.l %0,%1";
4891 ;;})
4892 ;;
4893 ;;(define_insn ""
4894 ;;        [(set (cc0)
4895 ;;            (subreg:SI (lshiftrt:DI (match_operand:DI 0 "general_operand" "ro")
4896 ;;                    (const_int 32)) 0))
4897 ;;        (set (match_operand:DI 1 "nonimmediate_operand" "=do")
4898 ;;            (lshiftrt:DI (match_dup 0)
4899 ;;                (const_int 32)))]
4900 ;;  ""
4901 ;;{
4902 ;;  if (GET_CODE (operands[1]) == REG)
4903 ;;    operands[2] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
4904 ;;  else
4905 ;;    operands[2] = adjust_address (operands[1], SImode, 4);
4906 ;;  return "move%.l %0,%2\;clr%.l %1";
4907 ;;})
4908
4909 (define_insn "subreg1lshrdi_const32"
4910   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
4911     (subreg:SI (lshiftrt:DI (match_operand:DI 1 "general_operand" "ro")
4912             (const_int 32)) 4))]
4913   ""
4914   "move%.l %1,%0"
4915   [(set_attr "type" "move_l")])
4916
4917 (define_insn "*lshrdi3_const1"
4918   [(set (match_operand:DI 0 "register_operand" "=d")
4919         (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
4920                      (const_int 1)))]
4921   "!TARGET_COLDFIRE"
4922   "lsr%.l #1,%0\;roxr%.l #1,%R0")
4923
4924 (define_split
4925   [(set (match_operand:DI 0 "register_operand" "")
4926         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
4927                      (const_int 2)))]
4928   "reload_completed && !TARGET_COLDFIRE"
4929   [(set (match_dup 0)
4930         (lshiftrt:DI (match_dup 1) (const_int 1)))
4931    (set (match_dup 0)
4932         (lshiftrt:DI (match_dup 0) (const_int 1)))]
4933   "")
4934
4935 (define_split
4936   [(set (match_operand:DI 0 "register_operand" "")
4937         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
4938                      (const_int 3)))]
4939   "reload_completed && !TARGET_COLDFIRE"
4940   [(set (match_dup 0)
4941         (lshiftrt:DI (match_dup 1) (const_int 2)))
4942    (set (match_dup 0)
4943         (lshiftrt:DI (match_dup 0) (const_int 1)))]
4944   "")
4945
4946 (define_split
4947   [(set (match_operand:DI 0 "register_operand" "")
4948         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
4949                      (const_int 8)))]
4950   "reload_completed && !TARGET_COLDFIRE"
4951   [(set (strict_low_part (subreg:QI (match_dup 0) 7))
4952         (subreg:QI (match_dup 0) 3))
4953    (set (match_dup 2)
4954         (lshiftrt:SI (match_dup 2) (const_int 8)))
4955    (set (match_dup 3)
4956         (rotatert:SI (match_dup 3) (const_int 8)))]
4957 {
4958   operands[2] = gen_highpart (SImode, operands[0]);
4959   operands[3] = gen_lowpart (SImode, operands[0]);
4960 })
4961
4962 (define_split
4963   [(set (match_operand:DI 0 "register_operand" "")
4964         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
4965                      (const_int 16)))]
4966   "reload_completed && !TARGET_COLDFIRE"
4967   [(set (strict_low_part (subreg:HI (match_dup 0) 6))
4968         (subreg:HI (match_dup 0) 2))
4969    (set (strict_low_part (subreg:HI (match_dup 0) 2))
4970         (const_int 0))
4971    (set (match_dup 3)
4972         (rotate:SI (match_dup 3) (const_int 16)))
4973    (set (match_dup 2)
4974         (rotate:SI (match_dup 2) (const_int 16)))]
4975 {
4976   operands[2] = gen_highpart (SImode, operands[0]);
4977   operands[3] = gen_lowpart (SImode, operands[0]);
4978 })
4979
4980 (define_split
4981   [(set (match_operand:DI 0 "pre_dec_operand" "")
4982         (lshiftrt:DI (match_operand:DI 1 "nonimmediate_operand" "")
4983                      (const_int 32)))]
4984   "reload_completed"
4985   [(set (match_dup 0) (match_dup 1))
4986    (set (match_dup 0) (const_int 0))]
4987 {
4988   operands[0] = adjust_address(operands[0], SImode, 0);
4989   operands[1] = gen_highpart(SImode, operands[1]);
4990 })
4991
4992 (define_split
4993   [(set (match_operand:DI 0 "post_inc_operand" "")
4994         (lshiftrt:DI (match_operand:DI 1 "nonimmediate_operand" "")
4995                      (const_int 32)))]
4996   "reload_completed"
4997   [(set (match_dup 0) (const_int 0))
4998    (set (match_dup 0) (match_dup 1))]
4999 {
5000   operands[0] = adjust_address(operands[0], SImode, 0);
5001   operands[1] = gen_highpart(SImode, operands[1]);
5002 })
5003
5004 (define_split
5005   [(set (match_operand:DI 0 "nonimmediate_operand" "")
5006         (lshiftrt:DI (match_operand:DI 1 "nonimmediate_operand" "")
5007                      (const_int 32)))]
5008   "reload_completed"
5009   [(set (match_dup 2) (match_dup 5))
5010    (set (match_dup 4) (const_int 0))]
5011   "split_di(operands, 2, operands + 2, operands + 4);")
5012
5013 (define_insn "*lshrdi_const32"
5014   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro<>")
5015         (lshiftrt:DI (match_operand:DI 1 "general_operand" "ro")
5016                      (const_int 32)))]
5017   ""
5018   "#")
5019
5020 (define_split
5021   [(set (match_operand:DI 0 "register_operand" "")
5022         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
5023                      (match_operand 2 "const_int_operand" "")))]
5024   "reload_completed && !TARGET_COLDFIRE
5025    && INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 40"
5026   [(set (match_dup 3) (lshiftrt:SI (match_dup 3) (match_dup 2)))
5027    (set (match_dup 4) (match_dup 3))
5028    (set (match_dup 3) (const_int 0))]
5029 {
5030   operands[2] = GEN_INT (INTVAL (operands[2]) - 32);
5031   operands[3] = gen_highpart (SImode, operands[0]);
5032   operands[4] = gen_lowpart (SImode, operands[0]);
5033 })
5034
5035 (define_split
5036   [(set (match_operand:DI 0 "register_operand" "")
5037         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
5038                      (const_int 48)))]
5039   "reload_completed"
5040   [(set (match_dup 3) (match_dup 2))
5041    (set (strict_low_part (subreg:HI (match_dup 0) 6))
5042         (const_int 0))
5043    (set (match_dup 2) (const_int 0))
5044    (set (match_dup 3)
5045         (rotate:SI (match_dup 3) (const_int 16)))]
5046 {
5047   operands[2] = gen_highpart (SImode, operands[0]);
5048   operands[3] = gen_lowpart (SImode, operands[0]);
5049 })
5050
5051 (define_split
5052   [(set (match_operand:DI 0 "register_operand" "")
5053         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
5054                      (match_operand 2 "const_int_operand" "")))]
5055   "reload_completed && !TARGET_COLDFIRE
5056    && INTVAL (operands[2]) > 40 && INTVAL (operands[2]) <= 62"
5057   [(set (match_dup 4) (match_dup 2))
5058    (set (match_dup 3) (lshiftrt:SI (match_dup 3) (match_dup 4)))
5059    (set (match_dup 4) (match_dup 3))
5060    (set (match_dup 3) (const_int 0))]
5061 {
5062   operands[2] = GEN_INT (INTVAL (operands[2]) - 32);
5063   operands[3] = gen_highpart (SImode, operands[0]);
5064   operands[4] = gen_lowpart (SImode, operands[0]);
5065 })
5066
5067 (define_insn "*lshrdi_const63"
5068   [(set (match_operand:DI 0 "register_operand" "=d")
5069         (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
5070                      (const_int 63)))]
5071   ""
5072   "add%.l %0,%0\;clr%.l %0\;clr%.l %R1\;addx%.l %R1,%R1")
5073
5074 (define_insn "*lshrdi3_const"
5075   [(set (match_operand:DI 0 "register_operand" "=d")
5076         (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
5077                      (match_operand 2 "const_int_operand" "n")))]
5078   "(!TARGET_COLDFIRE
5079     && ((INTVAL (operands[2]) >= 2 && INTVAL (operands[2]) <= 3)
5080          || INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16
5081          || (INTVAL (operands[2]) > 32 && INTVAL (operands[2]) <= 63)))"
5082   "#")
5083
5084 (define_expand "lshrdi3"
5085   [(set (match_operand:DI 0 "register_operand" "")
5086         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
5087                      (match_operand 2 "const_int_operand" "")))]
5088   "!TARGET_COLDFIRE"
5089 {
5090   /* ???  This is a named pattern like this is not allowed to FAIL based
5091      on its operands.  */
5092   if (GET_CODE (operands[2]) != CONST_INT
5093       || ((INTVAL (operands[2]) < 1 || INTVAL (operands[2]) > 3)
5094           && INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16
5095           && (INTVAL (operands[2]) < 32 || INTVAL (operands[2]) > 63)))
5096     FAIL;
5097 })
5098
5099 ;; On all 68k models, this makes faster code in a special case.
5100
5101 (define_insn "lshrsi_31"
5102   [(set (match_operand:SI 0 "register_operand" "=d")
5103         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
5104                      (const_int 31)))]
5105   ""
5106 {
5107   return "add%.l %0,%0\;subx%.l %0,%0\;neg%.l %0";
5108 })
5109
5110 ;; On most 68k models, this makes faster code in a special case.
5111
5112 (define_insn "lshrsi_16"
5113   [(set (match_operand:SI 0 "register_operand" "=d")
5114         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
5115                      (const_int 16)))]
5116   "!TUNE_68060"
5117 {
5118   CC_STATUS_INIT;
5119   return "clr%.w %0\;swap %0";
5120 })
5121
5122 ;; On the 68000, this makes faster code in a special case.
5123
5124 (define_insn "lshrsi_17_24"
5125   [(set (match_operand:SI 0 "register_operand" "=d")
5126         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
5127                      (match_operand:SI 2 "const_int_operand" "n")))]
5128   "TUNE_68000_10
5129    && INTVAL (operands[2]) > 16
5130    && INTVAL (operands[2]) <= 24"
5131 {
5132   /* I think lsr%.w sets the CC properly.  */
5133   operands[2] = GEN_INT (INTVAL (operands[2]) - 16);
5134   return "clr%.w %0\;swap %0\;lsr%.w %2,%0";
5135 })
5136
5137 (define_insn "lshrsi3"
5138   [(set (match_operand:SI 0 "register_operand" "=d")
5139         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
5140                      (match_operand:SI 2 "general_operand" "dI")))]
5141   ""
5142   "lsr%.l %2,%0"
5143   [(set_attr "type" "shift")
5144    (set_attr "opy" "2")])
5145
5146 (define_insn "lshrhi3"
5147   [(set (match_operand:HI 0 "register_operand" "=d")
5148         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
5149                      (match_operand:HI 2 "general_operand" "dI")))]
5150   "!TARGET_COLDFIRE"
5151   "lsr%.w %2,%0")
5152
5153 (define_insn ""
5154   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d"))
5155         (lshiftrt:HI (match_dup 0)
5156                      (match_operand:HI 1 "general_operand" "dI")))]
5157   "!TARGET_COLDFIRE"
5158   "lsr%.w %1,%0")
5159
5160 (define_insn "lshrqi3"
5161   [(set (match_operand:QI 0 "register_operand" "=d")
5162         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
5163                      (match_operand:QI 2 "general_operand" "dI")))]
5164   "!TARGET_COLDFIRE"
5165   "lsr%.b %2,%0")
5166
5167 (define_insn ""
5168   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d"))
5169         (lshiftrt:QI (match_dup 0)
5170                      (match_operand:QI 1 "general_operand" "dI")))]
5171   "!TARGET_COLDFIRE"
5172   "lsr%.b %1,%0")
5173 \f
5174 ;; rotate instructions
5175
5176 (define_insn "rotlsi_16"
5177   [(set (match_operand:SI 0 "register_operand" "=d")
5178         (rotate:SI (match_operand:SI 1 "register_operand" "0")
5179                    (const_int 16)))]
5180   ""
5181   "swap %0"
5182   [(set_attr "type" "shift")])
5183
5184 (define_insn "rotlsi3"
5185   [(set (match_operand:SI 0 "register_operand" "=d")
5186         (rotate:SI (match_operand:SI 1 "register_operand" "0")
5187                    (match_operand:SI 2 "general_operand" "dINO")))]
5188   "!TARGET_COLDFIRE"
5189 {
5190   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) == 16)
5191     return "swap %0";
5192   else if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 16)
5193     {
5194       operands[2] = GEN_INT (32 - INTVAL (operands[2]));
5195       return "ror%.l %2,%0";
5196     }
5197   else
5198     return "rol%.l %2,%0";
5199 })
5200
5201 (define_insn "rotlhi3"
5202   [(set (match_operand:HI 0 "register_operand" "=d")
5203         (rotate:HI (match_operand:HI 1 "register_operand" "0")
5204                    (match_operand:HI 2 "general_operand" "dIP")))]
5205   "!TARGET_COLDFIRE"
5206 {
5207   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 8)
5208     {
5209       operands[2] = GEN_INT (16 - INTVAL (operands[2]));
5210       return "ror%.w %2,%0";
5211     }
5212   else
5213     return "rol%.w %2,%0";
5214 })
5215
5216 (define_insn ""
5217   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d"))
5218         (rotate:HI (match_dup 0)
5219                    (match_operand:HI 1 "general_operand" "dIP")))]
5220   "!TARGET_COLDFIRE"
5221 {
5222   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 8)
5223     {
5224       operands[2] = GEN_INT (16 - INTVAL (operands[2]));
5225       return "ror%.w %2,%0";
5226     }
5227   else
5228     return "rol%.w %2,%0";
5229 })
5230
5231 (define_insn "rotlqi3"
5232   [(set (match_operand:QI 0 "register_operand" "=d")
5233         (rotate:QI (match_operand:QI 1 "register_operand" "0")
5234                    (match_operand:QI 2 "general_operand" "dI")))]
5235   "!TARGET_COLDFIRE"
5236 {
5237   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 4)
5238     {
5239       operands[2] = GEN_INT (8 - INTVAL (operands[2]));
5240       return "ror%.b %2,%0";
5241     }
5242   else
5243     return "rol%.b %2,%0";
5244 })
5245
5246 (define_insn ""
5247   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d"))
5248         (rotate:QI (match_dup 0)
5249                    (match_operand:QI 1 "general_operand" "dI")))]
5250   "!TARGET_COLDFIRE"
5251 {
5252   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 4)
5253     {
5254       operands[2] = GEN_INT (8 - INTVAL (operands[2]));
5255       return "ror%.b %2,%0";
5256     }
5257   else
5258     return "rol%.b %2,%0";
5259 })
5260
5261 (define_insn "rotrsi3"
5262   [(set (match_operand:SI 0 "register_operand" "=d")
5263         (rotatert:SI (match_operand:SI 1 "register_operand" "0")
5264                      (match_operand:SI 2 "general_operand" "dI")))]
5265   "!TARGET_COLDFIRE"
5266   "ror%.l %2,%0")
5267
5268 (define_insn "rotrhi3"
5269   [(set (match_operand:HI 0 "register_operand" "=d")
5270         (rotatert:HI (match_operand:HI 1 "register_operand" "0")
5271                      (match_operand:HI 2 "general_operand" "dI")))]
5272   "!TARGET_COLDFIRE"
5273   "ror%.w %2,%0")
5274
5275 (define_insn "rotrhi_lowpart"
5276   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d"))
5277         (rotatert:HI (match_dup 0)
5278                      (match_operand:HI 1 "general_operand" "dI")))]
5279   "!TARGET_COLDFIRE"
5280   "ror%.w %1,%0")
5281
5282 (define_insn "rotrqi3"
5283   [(set (match_operand:QI 0 "register_operand" "=d")
5284         (rotatert:QI (match_operand:QI 1 "register_operand" "0")
5285                      (match_operand:QI 2 "general_operand" "dI")))]
5286   "!TARGET_COLDFIRE"
5287   "ror%.b %2,%0")
5288
5289 (define_insn ""
5290   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d"))
5291         (rotatert:QI (match_dup 0)
5292                      (match_operand:QI 1 "general_operand" "dI")))]
5293   "!TARGET_COLDFIRE"
5294   "ror%.b %1,%0")
5295
5296 (define_expand "bswapsi2"
5297   [(set (match_operand:SI 0 "register_operand")
5298         (bswap:SI (match_operand:SI 1 "register_operand")))]
5299   "!TARGET_COLDFIRE"
5300 {
5301   rtx x = operands[0];
5302   emit_move_insn (x, operands[1]);
5303   emit_insn (gen_rotrhi_lowpart (gen_lowpart (HImode, x), GEN_INT (8)));
5304   emit_insn (gen_rotlsi3 (x, x, GEN_INT (16)));
5305   emit_insn (gen_rotrhi_lowpart (gen_lowpart (HImode, x), GEN_INT (8)));
5306   DONE;
5307 })
5308 \f
5309
5310 ;; Bit set/clear in memory byte.
5311
5312 ;; set bit, bit number is int
5313 (define_insn "bsetmemqi"
5314   [(set (match_operand:QI 0 "memory_operand" "+m")
5315         (ior:QI (subreg:QI (ashift:SI (const_int 1)
5316                 (match_operand:SI 1 "general_operand" "d")) 3)
5317         (match_dup 0)))]
5318   ""
5319 {
5320   CC_STATUS_INIT;
5321   return "bset %1,%0";
5322 }
5323   [(set_attr "type" "bitrw")])
5324
5325 ;; set bit, bit number is (sign/zero)_extended from HImode/QImode
5326 (define_insn "*bsetmemqi_ext"
5327   [(set (match_operand:QI 0 "memory_operand" "+m")
5328         (ior:QI (subreg:QI (ashift:SI (const_int 1)
5329             (match_operator:SI 2 "extend_operator"
5330                 [(match_operand 1 "general_operand" "d")])) 3)
5331         (match_dup 0)))]
5332   ""
5333 {
5334   CC_STATUS_INIT;
5335   return "bset %1,%0";
5336 }
5337   [(set_attr "type" "bitrw")])
5338
5339 ;; clear bit, bit number is int
5340 (define_insn "bclrmemqi"
5341   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+m")
5342         (const_int 1)
5343         (minus:SI (const_int 7)
5344             (match_operand:SI 1 "general_operand" "d")))
5345     (const_int 0))]
5346   ""
5347 {
5348   CC_STATUS_INIT;
5349   return "bclr %1,%0";
5350 }
5351   [(set_attr "type" "bitrw")])
5352
5353 ;; clear bit, bit number is (sign/zero)_extended from HImode/QImode
5354 (define_insn "*bclrmemqi_ext"
5355   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+m")
5356         (const_int 1)
5357         (minus:SI (const_int 7)
5358             (match_operator:SI 2 "extend_operator"
5359                 [(match_operand 1 "general_operand" "d")])))
5360     (const_int 0))]
5361   ""
5362 {
5363   CC_STATUS_INIT;
5364   return "bclr %1,%0";
5365 }
5366   [(set_attr "type" "bitrw")])
5367
5368 ;; Special cases of bit-field insns which we should
5369 ;; recognize in preference to the general case.
5370 ;; These handle aligned 8-bit and 16-bit fields,
5371 ;; which can usually be done with move instructions.
5372
5373 ;
5374 ; Special case for 32-bit field in memory.  This only occurs when 32-bit
5375 ; alignment of structure members is specified.
5376 ;
5377 ; The move is allowed to be odd byte aligned, because that's still faster
5378 ; than an odd byte aligned bit-field instruction.
5379 ;
5380 (define_insn "*insv_32_mem"
5381   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+o")
5382                          (const_int 32)
5383                          (match_operand:SI 1 "const_int_operand" "n"))
5384         (match_operand:SI 2 "general_src_operand" "rmSi"))]
5385   "TARGET_68020 && TARGET_BITFIELD
5386    && (INTVAL (operands[1]) % 8) == 0
5387    && ! mode_dependent_address_p (XEXP (operands[0], 0),
5388                                   MEM_ADDR_SPACE (operands[0]))"
5389 {
5390   operands[0]
5391     = adjust_address (operands[0], SImode, INTVAL (operands[1]) / 8);
5392
5393   return "move%.l %2,%0";
5394 })
5395
5396 (define_insn "*insv_8_16_reg"
5397   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+d")
5398                          (match_operand:SI 1 "const_int_operand" "n")
5399                          (match_operand:SI 2 "const_int_operand" "n"))
5400         (match_operand:SI 3 "register_operand" "d"))]
5401   "TARGET_68020 && TARGET_BITFIELD
5402    && (INTVAL (operands[1]) == 8 || INTVAL (operands[1]) == 16)
5403    && INTVAL (operands[2]) % INTVAL (operands[1]) == 0"
5404 {
5405   if (INTVAL (operands[1]) + INTVAL (operands[2]) != 32)
5406     return "bfins %3,%0{%b2:%b1}";
5407
5408   if (INTVAL (operands[1]) == 8)
5409     return "move%.b %3,%0";
5410   return "move%.w %3,%0";
5411 })
5412
5413
5414 ;
5415 ; Special case for 32-bit field in memory.  This only occurs when 32-bit
5416 ; alignment of structure members is specified.
5417 ;
5418 ; The move is allowed to be odd byte aligned, because that's still faster
5419 ; than an odd byte aligned bit-field instruction.
5420 ;
5421 (define_insn "*extzv_32_mem"
5422   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
5423         (zero_extract:SI (match_operand:QI 1 "memory_src_operand" "oS")
5424                          (const_int 32)
5425                          (match_operand:SI 2 "const_int_operand" "n")))]
5426   "TARGET_68020 && TARGET_BITFIELD
5427    && (INTVAL (operands[2]) % 8) == 0
5428    && ! mode_dependent_address_p (XEXP (operands[1], 0),
5429                                   MEM_ADDR_SPACE (operands[1]))"
5430 {
5431   operands[1]
5432     = adjust_address (operands[1], SImode, INTVAL (operands[2]) / 8);
5433
5434   return "move%.l %1,%0";
5435 })
5436
5437 (define_insn "*extzv_8_16_reg"
5438   [(set (match_operand:SI 0 "nonimmediate_operand" "=&d")
5439         (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
5440                          (match_operand:SI 2 "const_int_operand" "n")
5441                          (match_operand:SI 3 "const_int_operand" "n")))]
5442   "TARGET_68020 && TARGET_BITFIELD
5443    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
5444    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0"
5445 {
5446   cc_status.flags |= CC_NOT_NEGATIVE;
5447   if (INTVAL (operands[2]) + INTVAL (operands[3]) != 32)
5448     return "bfextu %1{%b3:%b2},%0";
5449
5450   output_asm_insn ("clr%.l %0", operands);
5451   if (INTVAL (operands[2]) == 8)
5452     return "move%.b %1,%0";
5453   return "move%.w %1,%0";
5454 })
5455
5456 ;
5457 ; Special case for 32-bit field in memory.  This only occurs when 32-bit
5458 ; alignment of structure members is specified.
5459 ;
5460 ; The move is allowed to be odd byte aligned, because that's still faster
5461 ; than an odd byte aligned bit-field instruction.
5462 ;
5463 (define_insn "*extv_32_mem"
5464   [(set (match_operand:SI 0 "nonimmediate_operand" "=rm")
5465         (sign_extract:SI (match_operand:QI 1 "memory_src_operand" "oS")
5466                          (const_int 32)
5467                          (match_operand:SI 2 "const_int_operand" "n")))]
5468   "TARGET_68020 && TARGET_BITFIELD
5469    && (INTVAL (operands[2]) % 8) == 0
5470    && ! mode_dependent_address_p (XEXP (operands[1], 0),
5471                                   MEM_ADDR_SPACE (operands[1]))"
5472 {
5473   operands[1]
5474     = adjust_address (operands[1], SImode, INTVAL (operands[2]) / 8);
5475
5476   return "move%.l %1,%0";
5477 })
5478
5479 (define_insn "*extv_8_16_reg"
5480   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
5481         (sign_extract:SI (match_operand:SI 1 "register_operand" "d")
5482                          (match_operand:SI 2 "const_int_operand" "n")
5483                          (match_operand:SI 3 "const_int_operand" "n")))]
5484   "TARGET_68020 && TARGET_BITFIELD
5485    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
5486    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0"
5487 {
5488   if (INTVAL (operands[2]) + INTVAL (operands[3]) != 32)
5489     return "bfexts %1{%b3:%b2},%0";
5490
5491   if (INTVAL (operands[2]) == 8)
5492     return "move%.b %1,%0\;extb%.l %0";
5493   return "move%.w %1,%0\;ext%.l %0";
5494 })
5495 \f
5496 ;; Bit-field instructions, general cases.
5497 ;; "o,d" constraint causes a nonoffsettable memref to match the "o"
5498 ;; so that its address is reloaded.
5499
5500 (define_expand "extv"
5501   [(set (match_operand:SI 0 "register_operand" "")
5502         (sign_extract:SI (match_operand:SI 1 "general_operand" "")
5503                          (match_operand:SI 2 "const_int_operand" "")
5504                          (match_operand:SI 3 "const_int_operand" "")))]
5505   "TARGET_68020 && TARGET_BITFIELD"
5506   "")
5507
5508 (define_insn "*extv_bfexts_mem"
5509   [(set (match_operand:SI 0 "register_operand" "=d")
5510         (sign_extract:SI (match_operand:QI 1 "memory_operand" "o")
5511                          (match_operand:SI 2 "nonmemory_operand" "dn")
5512                          (match_operand:SI 3 "nonmemory_operand" "dn")))]
5513   "TARGET_68020 && TARGET_BITFIELD"
5514   "bfexts %1{%b3:%b2},%0")
5515
5516 (define_expand "extzv"
5517   [(set (match_operand:SI 0 "register_operand" "")
5518         (zero_extract:SI (match_operand:SI 1 "general_operand" "")
5519                          (match_operand:SI 2 "const_int_operand" "")
5520                          (match_operand:SI 3 "const_int_operand" "")))]
5521   "TARGET_68020 && TARGET_BITFIELD"
5522   "")
5523
5524 (define_insn "*extzv_bfextu_mem"
5525   [(set (match_operand:SI 0 "register_operand" "=d")
5526         (zero_extract:SI (match_operand:QI 1 "memory_operand" "o")
5527                          (match_operand:SI 2 "nonmemory_operand" "dn")
5528                          (match_operand:SI 3 "nonmemory_operand" "dn")))]
5529   "TARGET_68020 && TARGET_BITFIELD"
5530 {
5531   if (GET_CODE (operands[2]) == CONST_INT)
5532     {
5533       if (INTVAL (operands[2]) != 32)
5534         cc_status.flags |= CC_NOT_NEGATIVE;
5535     }
5536   else
5537     {
5538       CC_STATUS_INIT;
5539     }
5540   return "bfextu %1{%b3:%b2},%0";
5541 })
5542
5543 (define_insn "*insv_bfchg_mem"
5544   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+o")
5545                          (match_operand:SI 1 "nonmemory_operand" "dn")
5546                          (match_operand:SI 2 "nonmemory_operand" "dn"))
5547         (xor:SI (zero_extract:SI (match_dup 0) (match_dup 1) (match_dup 2))
5548                 (match_operand 3 "const_int_operand" "n")))]
5549   "TARGET_68020 && TARGET_BITFIELD
5550    && (INTVAL (operands[3]) == -1
5551        || (GET_CODE (operands[1]) == CONST_INT
5552            && (~ INTVAL (operands[3]) & ((1 << INTVAL (operands[1]))- 1)) == 0))"
5553 {
5554   CC_STATUS_INIT;
5555   return "bfchg %0{%b2:%b1}";
5556 })
5557
5558 (define_insn "*insv_bfclr_mem"
5559   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+o")
5560                          (match_operand:SI 1 "nonmemory_operand" "dn")
5561                          (match_operand:SI 2 "nonmemory_operand" "dn"))
5562         (const_int 0))]
5563   "TARGET_68020 && TARGET_BITFIELD"
5564 {
5565   CC_STATUS_INIT;
5566   return "bfclr %0{%b2:%b1}";
5567 })
5568
5569 (define_insn "*insv_bfset_mem"
5570   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+o")
5571                          (match_operand:SI 1 "general_operand" "dn")
5572                          (match_operand:SI 2 "general_operand" "dn"))
5573         (const_int -1))]
5574   "TARGET_68020 && TARGET_BITFIELD"
5575 {
5576   CC_STATUS_INIT;
5577   return "bfset %0{%b2:%b1}";
5578 })
5579
5580 (define_expand "insv"
5581   [(set (zero_extract:SI (match_operand:SI 0 "nonimmediate_operand" "")
5582                          (match_operand:SI 1 "const_int_operand" "")
5583                          (match_operand:SI 2 "const_int_operand" ""))
5584         (match_operand:SI 3 "register_operand" ""))]
5585   "TARGET_68020 && TARGET_BITFIELD"
5586   "")
5587
5588 (define_insn "*insv_bfins_mem"
5589   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+o")
5590                          (match_operand:SI 1 "nonmemory_operand" "dn")
5591                          (match_operand:SI 2 "nonmemory_operand" "dn"))
5592         (match_operand:SI 3 "register_operand" "d"))]
5593   "TARGET_68020 && TARGET_BITFIELD"
5594   "bfins %3,%0{%b2:%b1}")
5595
5596 ;; Now recognize bit-field insns that operate on registers
5597 ;; (or at least were intended to do so).
5598
5599 (define_insn "*extv_bfexts_reg"
5600   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
5601         (sign_extract:SI (match_operand:SI 1 "register_operand" "d")
5602                          (match_operand:SI 2 "const_int_operand" "n")
5603                          (match_operand:SI 3 "const_int_operand" "n")))]
5604   "TARGET_68020 && TARGET_BITFIELD"
5605   "bfexts %1{%b3:%b2},%0")
5606
5607 (define_insn "*extv_bfextu_reg"
5608   [(set (match_operand:SI 0 "nonimmediate_operand" "=d")
5609         (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
5610                          (match_operand:SI 2 "const_int_operand" "n")
5611                          (match_operand:SI 3 "const_int_operand" "n")))]
5612   "TARGET_68020 && TARGET_BITFIELD"
5613 {
5614   if (GET_CODE (operands[2]) == CONST_INT)
5615     {
5616       if (INTVAL (operands[2]) != 32)
5617         cc_status.flags |= CC_NOT_NEGATIVE;
5618     }
5619   else
5620     {
5621       CC_STATUS_INIT;
5622     }
5623   return "bfextu %1{%b3:%b2},%0";
5624 })
5625
5626 (define_insn "*insv_bfclr_reg"
5627   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+d")
5628                          (match_operand:SI 1 "const_int_operand" "n")
5629                          (match_operand:SI 2 "const_int_operand" "n"))
5630         (const_int 0))]
5631   "TARGET_68020 && TARGET_BITFIELD"
5632 {
5633   CC_STATUS_INIT;
5634   return "bfclr %0{%b2:%b1}";
5635 })
5636
5637 (define_insn "*insv_bfset_reg"
5638   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+d")
5639                          (match_operand:SI 1 "const_int_operand" "n")
5640                          (match_operand:SI 2 "const_int_operand" "n"))
5641         (const_int -1))]
5642   "TARGET_68020 && TARGET_BITFIELD"
5643 {
5644   CC_STATUS_INIT;
5645   return "bfset %0{%b2:%b1}";
5646 })
5647
5648 (define_insn "*insv_bfins_reg"
5649   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+d")
5650                          (match_operand:SI 1 "const_int_operand" "n")
5651                          (match_operand:SI 2 "const_int_operand" "n"))
5652         (match_operand:SI 3 "register_operand" "d"))]
5653   "TARGET_68020 && TARGET_BITFIELD"
5654 {
5655 #if 0
5656   /* These special cases are now recognized by a specific pattern.  */
5657   if (GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT
5658       && INTVAL (operands[1]) == 16 && INTVAL (operands[2]) == 16)
5659     return "move%.w %3,%0";
5660   if (GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT
5661       && INTVAL (operands[1]) == 24 && INTVAL (operands[2]) == 8)
5662     return "move%.b %3,%0";
5663 #endif
5664   return "bfins %3,%0{%b2:%b1}";
5665 })
5666 \f
5667 ;; Special patterns for optimizing bit-field instructions.
5668
5669 (define_insn "*tst_bftst_mem"
5670   [(set (cc0)
5671         (compare (zero_extract:SI (match_operand:QI 0 "memory_operand" "o")
5672                                   (match_operand:SI 1 "const_int_operand" "n")
5673                                   (match_operand:SI 2 "general_operand" "dn"))
5674                  (const_int 0)))]
5675   "TARGET_68020 && TARGET_BITFIELD"
5676 {
5677   if (operands[1] == const1_rtx
5678       && GET_CODE (operands[2]) == CONST_INT)
5679     {
5680       int width = GET_CODE (operands[0]) == REG ? 31 : 7;
5681       return output_btst (operands,
5682                           GEN_INT (width - INTVAL (operands[2])),
5683                           operands[0], insn, 1000);
5684       /* Pass 1000 as SIGNPOS argument so that btst will
5685          not think we are testing the sign bit for an `and'
5686          and assume that nonzero implies a negative result.  */
5687     }
5688   if (INTVAL (operands[1]) != 32)
5689     cc_status.flags = CC_NOT_NEGATIVE;
5690   return "bftst %0{%b2:%b1}";
5691 })
5692
5693
5694 ;;; now handle the register cases
5695 (define_insn "*tst_bftst_reg"
5696   [(set (cc0)
5697         (compare (zero_extract:SI (match_operand:SI 0 "register_operand" "d")
5698                                   (match_operand:SI 1 "const_int_operand" "n")
5699                                   (match_operand:SI 2 "general_operand" "dn"))
5700                  (const_int 0)))]
5701   "TARGET_68020 && TARGET_BITFIELD"
5702 {
5703   if (operands[1] == const1_rtx
5704       && GET_CODE (operands[2]) == CONST_INT)
5705     {
5706       int width = GET_CODE (operands[0]) == REG ? 31 : 7;
5707       return output_btst (operands, GEN_INT (width - INTVAL (operands[2])),
5708                           operands[0], insn, 1000);
5709       /* Pass 1000 as SIGNPOS argument so that btst will
5710          not think we are testing the sign bit for an `and'
5711          and assume that nonzero implies a negative result.  */
5712     }
5713   if (INTVAL (operands[1]) != 32)
5714     cc_status.flags = CC_NOT_NEGATIVE;
5715   return "bftst %0{%b2:%b1}";
5716 })
5717 \f
5718 (define_insn "scc0_di"
5719   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm")
5720     (match_operator 1 "ordered_comparison_operator"
5721       [(match_operand:DI 2 "general_operand" "ro") (const_int 0)]))]
5722   "! TARGET_COLDFIRE"
5723 {
5724   return output_scc_di (operands[1], operands[2], const0_rtx, operands[0]);
5725 })
5726
5727 (define_insn "scc0_di_5200"
5728   [(set (match_operand:QI 0 "nonimmediate_operand" "=d")
5729     (match_operator 1 "ordered_comparison_operator"
5730       [(match_operand:DI 2 "general_operand" "ro") (const_int 0)]))]
5731   "TARGET_COLDFIRE"
5732 {
5733   return output_scc_di (operands[1], operands[2], const0_rtx, operands[0]);
5734 })
5735
5736 (define_insn "scc_di"
5737   [(set (match_operand:QI 0 "nonimmediate_operand" "=dm,dm")
5738     (match_operator 1 "ordered_comparison_operator"
5739       [(match_operand:DI 2 "general_operand" "ro,r")
5740        (match_operand:DI 3 "general_operand" "r,ro")]))]
5741   "! TARGET_COLDFIRE"
5742 {
5743   return output_scc_di (operands[1], operands[2], operands[3], operands[0]);
5744 })
5745
5746 (define_insn "scc_di_5200"
5747   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d")
5748     (match_operator 1 "ordered_comparison_operator"
5749       [(match_operand:DI 2 "general_operand" "ro,r")
5750        (match_operand:DI 3 "general_operand" "r,ro")]))]
5751   "TARGET_COLDFIRE"
5752 {
5753   return output_scc_di (operands[1], operands[2], operands[3], operands[0]);
5754 })
5755
5756 ;; Note that operand 0 of an SCC insn is supported in the hardware as
5757 ;; memory, but we cannot allow it to be in memory in case the address
5758 ;; needs to be reloaded.
5759
5760 (define_insn ""
5761   [(set (match_operand:QI 0 "register_operand" "=d")
5762         (eq:QI (cc0) (const_int 0)))]
5763   ""
5764 {
5765   cc_status = cc_prev_status;
5766   OUTPUT_JUMP ("seq %0", "fseq %0", "seq %0");
5767 })
5768
5769 (define_insn ""
5770   [(set (match_operand:QI 0 "register_operand" "=d")
5771         (ne:QI (cc0) (const_int 0)))]
5772   ""
5773 {
5774   cc_status = cc_prev_status;
5775   OUTPUT_JUMP ("sne %0", "fsne %0", "sne %0");
5776 })
5777
5778 (define_insn ""
5779   [(set (match_operand:QI 0 "register_operand" "=d")
5780         (gt:QI (cc0) (const_int 0)))]
5781   ""
5782 {
5783   cc_status = cc_prev_status;
5784   OUTPUT_JUMP ("sgt %0", "fsgt %0", 0);
5785 })
5786
5787 (define_insn ""
5788   [(set (match_operand:QI 0 "register_operand" "=d")
5789         (gtu:QI (cc0) (const_int 0)))]
5790   ""
5791 {
5792   cc_status = cc_prev_status;
5793   return "shi %0";
5794 })
5795
5796 (define_insn ""
5797   [(set (match_operand:QI 0 "register_operand" "=d")
5798         (lt:QI (cc0) (const_int 0)))]
5799   ""
5800 {
5801    cc_status = cc_prev_status;
5802    OUTPUT_JUMP ("slt %0", "fslt %0", "smi %0");
5803 })
5804
5805 (define_insn ""
5806   [(set (match_operand:QI 0 "register_operand" "=d")
5807         (ltu:QI (cc0) (const_int 0)))]
5808   ""
5809 {
5810    cc_status = cc_prev_status;
5811    return "scs %0";
5812 })
5813
5814 (define_insn ""
5815   [(set (match_operand:QI 0 "register_operand" "=d")
5816         (ge:QI (cc0) (const_int 0)))]
5817   ""
5818 {
5819    cc_status = cc_prev_status;
5820    OUTPUT_JUMP ("sge %0", "fsge %0", "spl %0");
5821 })
5822
5823 (define_insn "*scc"
5824   [(set (match_operand:QI 0 "register_operand" "=d")
5825         (geu:QI (cc0) (const_int 0)))]
5826   ""
5827 {
5828    cc_status = cc_prev_status;
5829    return "scc %0";
5830 }
5831   [(set_attr "type" "scc")])
5832
5833 (define_insn ""
5834   [(set (match_operand:QI 0 "register_operand" "=d")
5835         (le:QI (cc0) (const_int 0)))]
5836   ""
5837 {
5838   cc_status = cc_prev_status;
5839   OUTPUT_JUMP ("sle %0", "fsle %0", 0);
5840 })
5841
5842 (define_insn "*sls"
5843   [(set (match_operand:QI 0 "register_operand" "=d")
5844         (leu:QI (cc0) (const_int 0)))]
5845   ""
5846 {
5847    cc_status = cc_prev_status;
5848    return "sls %0";
5849 }
5850   [(set_attr "type" "scc")])
5851
5852 (define_insn "*sordered_1"
5853   [(set (match_operand:QI 0 "register_operand" "=d")
5854         (ordered:QI (cc0) (const_int 0)))]
5855   "TARGET_68881 && !TUNE_68060"
5856 {
5857   cc_status = cc_prev_status;
5858   return "fsor %0";
5859 })
5860
5861 (define_insn "*sunordered_1"
5862   [(set (match_operand:QI 0 "register_operand" "=d")
5863         (unordered:QI (cc0) (const_int 0)))]
5864   "TARGET_68881 && !TUNE_68060"
5865 {
5866   cc_status = cc_prev_status;
5867   return "fsun %0";
5868 })
5869
5870 (define_insn "*suneq_1"
5871   [(set (match_operand:QI 0 "register_operand" "=d")
5872         (uneq:QI (cc0) (const_int 0)))]
5873   "TARGET_68881 && !TUNE_68060"
5874 {
5875   cc_status = cc_prev_status;
5876   return "fsueq %0";
5877 })
5878
5879 (define_insn "*sunge_1"
5880   [(set (match_operand:QI 0 "register_operand" "=d")
5881         (unge:QI (cc0) (const_int 0)))]
5882   "TARGET_68881 && !TUNE_68060"
5883 {
5884   cc_status = cc_prev_status;
5885   return "fsuge %0";
5886 })
5887
5888 (define_insn "*sungt_1"
5889   [(set (match_operand:QI 0 "register_operand" "=d")
5890         (ungt:QI (cc0) (const_int 0)))]
5891   "TARGET_68881 && !TUNE_68060"
5892 {
5893   cc_status = cc_prev_status;
5894   return "fsugt %0";
5895 })
5896
5897 (define_insn "*sunle_1"
5898   [(set (match_operand:QI 0 "register_operand" "=d")
5899         (unle:QI (cc0) (const_int 0)))]
5900   "TARGET_68881 && !TUNE_68060"
5901 {
5902   cc_status = cc_prev_status;
5903   return "fsule %0";
5904 })
5905
5906 (define_insn "*sunlt_1"
5907   [(set (match_operand:QI 0 "register_operand" "=d")
5908         (unlt:QI (cc0) (const_int 0)))]
5909   "TARGET_68881 && !TUNE_68060"
5910 {
5911   cc_status = cc_prev_status;
5912   return "fsult %0";
5913 })
5914
5915 (define_insn "*sltgt_1"
5916   [(set (match_operand:QI 0 "register_operand" "=d")
5917         (ltgt:QI (cc0) (const_int 0)))]
5918   "TARGET_68881 && !TUNE_68060"
5919 {
5920   cc_status = cc_prev_status;
5921   return "fsogl %0";
5922 })
5923
5924 (define_insn "*fsogt_1"
5925   [(set (match_operand:QI 0 "register_operand" "=d")
5926         (not:QI (unle:QI (cc0) (const_int 0))))]
5927   "TARGET_68881 && !TUNE_68060"
5928 {
5929   cc_status = cc_prev_status;
5930   return "fsogt %0";
5931 })
5932
5933 (define_insn "*fsoge_1"
5934   [(set (match_operand:QI 0 "register_operand" "=d")
5935         (not:QI (unlt:QI (cc0) (const_int 0))))]
5936   "TARGET_68881 && !TUNE_68060"
5937 {
5938   cc_status = cc_prev_status;
5939   return "fsoge %0";
5940 })
5941
5942 (define_insn "*fsolt_1"
5943   [(set (match_operand:QI 0 "register_operand" "=d")
5944         (not:QI (unge:QI (cc0) (const_int 0))))]
5945   "TARGET_68881 && !TUNE_68060"
5946 {
5947   cc_status = cc_prev_status;
5948   return "fsolt %0";
5949 })
5950
5951 (define_insn "*fsole_1"
5952   [(set (match_operand:QI 0 "register_operand" "=d")
5953         (not:QI (ungt:QI (cc0) (const_int 0))))]
5954   "TARGET_68881 && !TUNE_68060"
5955 {
5956   cc_status = cc_prev_status;
5957   return "fsole %0";
5958 })
5959 \f
5960 ;; Basic conditional jump instructions.
5961
5962 (define_insn "beq0_di"
5963   [(set (pc)
5964     (if_then_else (eq (match_operand:DI 0 "general_operand" "d*ao,<>")
5965             (const_int 0))
5966         (label_ref (match_operand 1 "" ","))
5967         (pc)))
5968    (clobber (match_scratch:SI 2 "=d,d"))]
5969   ""
5970 {
5971   CC_STATUS_INIT;
5972   if (which_alternative == 1)
5973     return "move%.l %0,%2\;or%.l %0,%2\;jeq %l1";
5974   if ((cc_prev_status.value1
5975       && rtx_equal_p (cc_prev_status.value1, operands[0]))
5976     || (cc_prev_status.value2
5977       && rtx_equal_p (cc_prev_status.value2, operands[0])))
5978     {
5979       cc_status = cc_prev_status;
5980       return "jeq %l1";
5981     }
5982   if (GET_CODE (operands[0]) == REG)
5983     operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
5984   else
5985     operands[3] = adjust_address (operands[0], SImode, 4);
5986   if (! ADDRESS_REG_P (operands[0]))
5987     {
5988       if (reg_overlap_mentioned_p (operands[2], operands[0]))
5989         {
5990           if (reg_overlap_mentioned_p (operands[2], operands[3]))
5991             return "or%.l %0,%2\;jeq %l1";
5992           else
5993             return "or%.l %3,%2\;jeq %l1";
5994         }
5995       return "move%.l %0,%2\;or%.l %3,%2\;jeq %l1";
5996     }
5997   operands[4] = gen_label_rtx();
5998   if (TARGET_68020 || TARGET_COLDFIRE)
5999     output_asm_insn ("tst%.l %0\;jne %l4\;tst%.l %3\;jeq %l1", operands);
6000   else
6001     output_asm_insn ("cmp%.w #0,%0\;jne %l4\;cmp%.w #0,%3\;jeq %l1", operands);
6002   (*targetm.asm_out.internal_label) (asm_out_file, "L",
6003                                 CODE_LABEL_NUMBER (operands[4]));
6004   return "";
6005 })
6006
6007 (define_insn "bne0_di"
6008   [(set (pc)
6009     (if_then_else (ne (match_operand:DI 0 "general_operand" "do,*a")
6010             (const_int 0))
6011         (label_ref (match_operand 1 "" ","))
6012         (pc)))
6013    (clobber (match_scratch:SI 2 "=d,X"))]
6014   ""
6015 {
6016   if ((cc_prev_status.value1
6017       && rtx_equal_p (cc_prev_status.value1, operands[0]))
6018     || (cc_prev_status.value2
6019       && rtx_equal_p (cc_prev_status.value2, operands[0])))
6020     {
6021       cc_status = cc_prev_status;
6022       return "jne %l1";
6023     }
6024   CC_STATUS_INIT;
6025   if (GET_CODE (operands[0]) == REG)
6026     operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
6027   else
6028     operands[3] = adjust_address (operands[0], SImode, 4);
6029   if (!ADDRESS_REG_P (operands[0]))
6030     {
6031       if (reg_overlap_mentioned_p (operands[2], operands[0]))
6032         {
6033           if (reg_overlap_mentioned_p (operands[2], operands[3]))
6034             return "or%.l %0,%2\;jne %l1";
6035           else
6036             return "or%.l %3,%2\;jne %l1";
6037         }
6038       return "move%.l %0,%2\;or%.l %3,%2\;jne %l1";
6039     }
6040   if (TARGET_68020 || TARGET_COLDFIRE)
6041     return "tst%.l %0\;jne %l1\;tst%.l %3\;jne %l1";
6042   else
6043     return "cmp%.w #0,%0\;jne %l1\;cmp%.w #0,%3\;jne %l1";
6044 })
6045
6046 (define_insn "bge0_di"
6047   [(set (pc)
6048     (if_then_else (ge (match_operand:DI 0 "general_operand" "ro")
6049             (const_int 0))
6050         (label_ref (match_operand 1 "" ""))
6051         (pc)))]
6052   ""
6053 {
6054   if ((cc_prev_status.value1
6055       && rtx_equal_p (cc_prev_status.value1, operands[0]))
6056     || (cc_prev_status.value2
6057       && rtx_equal_p (cc_prev_status.value2, operands[0])))
6058     {
6059       cc_status = cc_prev_status;
6060       return cc_status.flags & CC_REVERSED ? "jle %l1" : "jpl %l1";
6061     }
6062   CC_STATUS_INIT;
6063   if (TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P (operands[0]))
6064     output_asm_insn("tst%.l %0", operands);
6065   else
6066     {
6067       /* On an address reg, cmpw may replace cmpl.  */
6068       output_asm_insn("cmp%.w #0,%0", operands);
6069     }
6070   return "jpl %l1";
6071 })
6072
6073 (define_insn "blt0_di"
6074   [(set (pc)
6075     (if_then_else (lt (match_operand:DI 0 "general_operand" "ro")
6076             (const_int 0))
6077         (label_ref (match_operand 1 "" ""))
6078         (pc)))]
6079   ""
6080 {
6081   if ((cc_prev_status.value1
6082       && rtx_equal_p (cc_prev_status.value1, operands[0]))
6083     || (cc_prev_status.value2
6084       && rtx_equal_p (cc_prev_status.value2, operands[0])))
6085     {
6086       cc_status = cc_prev_status;
6087       return cc_status.flags & CC_REVERSED ? "jgt %l1" : "jmi %l1";
6088     }
6089   CC_STATUS_INIT;
6090   if (TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P (operands[0]))
6091     output_asm_insn("tst%.l %0", operands);
6092   else
6093     {
6094       /* On an address reg, cmpw may replace cmpl.  */
6095       output_asm_insn("cmp%.w #0,%0", operands);
6096     }
6097   return "jmi %l1";
6098 })
6099
6100 (define_insn "beq"
6101   [(set (pc)
6102         (if_then_else (eq (cc0)
6103                           (const_int 0))
6104                       (label_ref (match_operand 0 "" ""))
6105                       (pc)))]
6106   ""
6107 {
6108   OUTPUT_JUMP ("jeq %l0", "fjeq %l0", "jeq %l0");
6109 }
6110   [(set_attr "type" "bcc")])
6111
6112 (define_insn "bne"
6113   [(set (pc)
6114         (if_then_else (ne (cc0)
6115                           (const_int 0))
6116                       (label_ref (match_operand 0 "" ""))
6117                       (pc)))]
6118   ""
6119 {
6120   OUTPUT_JUMP ("jne %l0", "fjne %l0", "jne %l0");
6121 }
6122   [(set_attr "type" "bcc")])
6123
6124 (define_insn "bgt"
6125   [(set (pc)
6126         (if_then_else (gt (cc0)
6127                           (const_int 0))
6128                       (label_ref (match_operand 0 "" ""))
6129                       (pc)))]
6130   ""
6131 {
6132   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6133     {
6134       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6135       return 0;
6136     }
6137
6138   OUTPUT_JUMP ("jgt %l0", "fjgt %l0", 0);
6139 }
6140   [(set_attr "type" "bcc")])
6141
6142 (define_insn "bgtu"
6143   [(set (pc)
6144         (if_then_else (gtu (cc0)
6145                            (const_int 0))
6146                       (label_ref (match_operand 0 "" ""))
6147                       (pc)))]
6148   ""
6149 {
6150   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6151     {
6152       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6153       return 0;
6154     }
6155
6156   return "jhi %l0";
6157 }
6158   [(set_attr "type" "bcc")])
6159
6160 (define_insn "blt"
6161   [(set (pc)
6162         (if_then_else (lt (cc0)
6163                           (const_int 0))
6164                       (label_ref (match_operand 0 "" ""))
6165                       (pc)))]
6166   ""
6167 {
6168   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6169     {
6170       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6171       return 0;
6172     }
6173
6174   OUTPUT_JUMP ("jlt %l0", "fjlt %l0", "jmi %l0");
6175 }
6176   [(set_attr "type" "bcc")])
6177
6178 (define_insn "bltu"
6179   [(set (pc)
6180         (if_then_else (ltu (cc0)
6181                            (const_int 0))
6182                       (label_ref (match_operand 0 "" ""))
6183                       (pc)))]
6184   ""
6185 {
6186   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6187     {
6188       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6189       return 0;
6190     }
6191
6192   return "jcs %l0";
6193 }
6194   [(set_attr "type" "bcc")])
6195
6196 (define_insn "bge"
6197   [(set (pc)
6198         (if_then_else (ge (cc0)
6199                           (const_int 0))
6200                       (label_ref (match_operand 0 "" ""))
6201                       (pc)))]
6202   ""
6203 {
6204   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6205     {
6206       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6207       return 0;
6208     }
6209
6210   OUTPUT_JUMP ("jge %l0", "fjge %l0", "jpl %l0");
6211 })
6212
6213 (define_insn "bgeu"
6214   [(set (pc)
6215         (if_then_else (geu (cc0)
6216                            (const_int 0))
6217                       (label_ref (match_operand 0 "" ""))
6218                       (pc)))]
6219   ""
6220 {
6221   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6222     {
6223       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6224       return 0;
6225     }
6226
6227   return "jcc %l0";
6228 }
6229   [(set_attr "type" "bcc")])
6230
6231 (define_insn "ble"
6232   [(set (pc)
6233         (if_then_else (le (cc0)
6234                           (const_int 0))
6235                       (label_ref (match_operand 0 "" ""))
6236                       (pc)))]
6237   ""
6238 {
6239   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6240     {
6241       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6242       return 0;
6243     }
6244
6245   OUTPUT_JUMP ("jle %l0", "fjle %l0", 0);
6246 }
6247   [(set_attr "type" "bcc")])
6248
6249 (define_insn "bleu"
6250   [(set (pc)
6251         (if_then_else (leu (cc0)
6252                            (const_int 0))
6253                       (label_ref (match_operand 0 "" ""))
6254                       (pc)))]
6255   ""
6256 {
6257   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6258     {
6259       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6260       return 0;
6261     }
6262
6263   return "jls %l0";
6264 }
6265   [(set_attr "type" "bcc")])
6266
6267 (define_insn "bordered"
6268   [(set (pc)
6269         (if_then_else (ordered (cc0) (const_int 0))
6270                       (label_ref (match_operand 0 "" ""))
6271                       (pc)))]
6272   "TARGET_HARD_FLOAT"
6273 {
6274   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6275   return "fjor %l0";
6276 }
6277   [(set_attr "type" "fbcc")])
6278
6279 (define_insn "bunordered"
6280   [(set (pc)
6281         (if_then_else (unordered (cc0) (const_int 0))
6282                       (label_ref (match_operand 0 "" ""))
6283                       (pc)))]
6284   "TARGET_HARD_FLOAT"
6285 {
6286   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6287   return "fjun %l0";
6288 }
6289   [(set_attr "type" "fbcc")])
6290
6291 (define_insn "buneq"
6292   [(set (pc)
6293         (if_then_else (uneq (cc0) (const_int 0))
6294                       (label_ref (match_operand 0 "" ""))
6295                       (pc)))]
6296   "TARGET_HARD_FLOAT"
6297 {
6298   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6299   return "fjueq %l0";
6300 }
6301   [(set_attr "type" "fbcc")])
6302
6303 (define_insn "bunge"
6304   [(set (pc)
6305         (if_then_else (unge (cc0) (const_int 0))
6306                       (label_ref (match_operand 0 "" ""))
6307                       (pc)))]
6308   "TARGET_HARD_FLOAT"
6309 {
6310   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6311   return "fjuge %l0";
6312 }
6313   [(set_attr "type" "fbcc")])
6314
6315 (define_insn "bungt"
6316   [(set (pc)
6317         (if_then_else (ungt (cc0) (const_int 0))
6318                       (label_ref (match_operand 0 "" ""))
6319                       (pc)))]
6320   "TARGET_HARD_FLOAT"
6321 {
6322   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6323   return "fjugt %l0";
6324 }
6325   [(set_attr "type" "fbcc")])
6326
6327 (define_insn "bunle"
6328   [(set (pc)
6329         (if_then_else (unle (cc0) (const_int 0))
6330                       (label_ref (match_operand 0 "" ""))
6331                       (pc)))]
6332   "TARGET_HARD_FLOAT"
6333 {
6334   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6335   return "fjule %l0";
6336 }
6337   [(set_attr "type" "fbcc")])
6338
6339 (define_insn "bunlt"
6340   [(set (pc)
6341         (if_then_else (unlt (cc0) (const_int 0))
6342                       (label_ref (match_operand 0 "" ""))
6343                       (pc)))]
6344   "TARGET_HARD_FLOAT"
6345 {
6346   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6347   return "fjult %l0";
6348 }
6349   [(set_attr "type" "fbcc")])
6350
6351 (define_insn "bltgt"
6352   [(set (pc)
6353         (if_then_else (ltgt (cc0) (const_int 0))
6354                       (label_ref (match_operand 0 "" ""))
6355                       (pc)))]
6356   "TARGET_HARD_FLOAT"
6357 {
6358   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6359   return "fjogl %l0";
6360 }
6361   [(set_attr "type" "fbcc")])
6362 \f
6363 ;; Negated conditional jump instructions.
6364
6365 (define_insn "*beq_rev"
6366   [(set (pc)
6367         (if_then_else (eq (cc0)
6368                           (const_int 0))
6369                       (pc)
6370                       (label_ref (match_operand 0 "" ""))))]
6371   ""
6372 {
6373   OUTPUT_JUMP ("jne %l0", "fjne %l0", "jne %l0");
6374 }
6375   [(set_attr "type" "bcc")])
6376
6377 (define_insn "*bne_rev"
6378   [(set (pc)
6379         (if_then_else (ne (cc0)
6380                           (const_int 0))
6381                       (pc)
6382                       (label_ref (match_operand 0 "" ""))))]
6383   ""
6384 {
6385   OUTPUT_JUMP ("jeq %l0", "fjeq %l0", "jeq %l0");
6386 }
6387   [(set_attr "type" "bcc")])
6388
6389 (define_insn "*bgt_rev"
6390   [(set (pc)
6391         (if_then_else (gt (cc0)
6392                           (const_int 0))
6393                       (pc)
6394                       (label_ref (match_operand 0 "" ""))))]
6395   ""
6396 {
6397   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6398     {
6399       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6400       return 0;
6401     }
6402
6403   OUTPUT_JUMP ("jle %l0", "fjngt %l0", 0);
6404 }
6405   [(set_attr "type" "bcc")])
6406
6407 (define_insn "*bgtu_rev"
6408   [(set (pc)
6409         (if_then_else (gtu (cc0)
6410                            (const_int 0))
6411                       (pc)
6412                       (label_ref (match_operand 0 "" ""))))]
6413   ""
6414 {
6415   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6416     {
6417       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6418       return 0;
6419     }
6420
6421   return "jls %l0";
6422 }
6423   [(set_attr "type" "bcc")])
6424
6425 (define_insn "*blt_rev"
6426   [(set (pc)
6427         (if_then_else (lt (cc0)
6428                           (const_int 0))
6429                       (pc)
6430                       (label_ref (match_operand 0 "" ""))))]
6431   ""
6432 {
6433   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6434     {
6435       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6436       return 0;
6437     }
6438
6439   OUTPUT_JUMP ("jge %l0", "fjnlt %l0", "jpl %l0");
6440 }
6441   [(set_attr "type" "bcc")])
6442
6443 (define_insn "*bltu_rev"
6444   [(set (pc)
6445         (if_then_else (ltu (cc0)
6446                            (const_int 0))
6447                       (pc)
6448                       (label_ref (match_operand 0 "" ""))))]
6449   ""
6450 {
6451   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6452     {
6453       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6454       return 0;
6455     }
6456
6457   return "jcc %l0";
6458 }
6459   [(set_attr "type" "bcc")])
6460
6461 (define_insn "*bge_rev"
6462   [(set (pc)
6463         (if_then_else (ge (cc0)
6464                           (const_int 0))
6465                       (pc)
6466                       (label_ref (match_operand 0 "" ""))))]
6467   ""
6468 {
6469   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6470     {
6471       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6472       return 0;
6473     }
6474
6475   OUTPUT_JUMP ("jlt %l0", "fjnge %l0", "jmi %l0");
6476 }
6477   [(set_attr "type" "bcc")])
6478
6479 (define_insn "*bgeu_rev"
6480   [(set (pc)
6481         (if_then_else (geu (cc0)
6482                            (const_int 0))
6483                       (pc)
6484                       (label_ref (match_operand 0 "" ""))))]
6485   ""
6486 {
6487   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6488     {
6489       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6490       return 0;
6491     }
6492
6493   return "jcs %l0";
6494 }
6495   [(set_attr "type" "bcc")])
6496
6497 (define_insn "*ble_rev"
6498   [(set (pc)
6499         (if_then_else (le (cc0)
6500                           (const_int 0))
6501                       (pc)
6502                       (label_ref (match_operand 0 "" ""))))]
6503   ""
6504 {
6505   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6506     {
6507       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6508       return 0;
6509     }
6510
6511   OUTPUT_JUMP ("jgt %l0", "fjnle %l0", 0);
6512 }
6513   [(set_attr "type" "bcc")])
6514
6515 (define_insn "*bleu_rev"
6516   [(set (pc)
6517         (if_then_else (leu (cc0)
6518                            (const_int 0))
6519                       (pc)
6520                       (label_ref (match_operand 0 "" ""))))]
6521   ""
6522 {
6523   if ((cc_status.flags & CC_OVERFLOW_UNUSABLE) != 0)
6524     {
6525       cc_status.flags &= ~CC_OVERFLOW_UNUSABLE;
6526       return 0;
6527     }
6528
6529   return "jhi %l0";
6530 }
6531   [(set_attr "type" "bcc")])
6532
6533 (define_insn "*bordered_rev"
6534   [(set (pc)
6535         (if_then_else (ordered (cc0) (const_int 0))
6536                       (pc)
6537                       (label_ref (match_operand 0 "" ""))))]
6538   "TARGET_HARD_FLOAT"
6539 {
6540   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6541   return "fjun %l0";
6542 }
6543   [(set_attr "type" "fbcc")])
6544
6545 (define_insn "*bunordered_rev"
6546   [(set (pc)
6547         (if_then_else (unordered (cc0) (const_int 0))
6548                       (pc)
6549                       (label_ref (match_operand 0 "" ""))))]
6550   "TARGET_HARD_FLOAT"
6551 {
6552   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6553   return "fjor %l0";
6554 }
6555   [(set_attr "type" "fbcc")])
6556
6557 (define_insn "*buneq_rev"
6558   [(set (pc)
6559         (if_then_else (uneq (cc0) (const_int 0))
6560                       (pc)
6561                       (label_ref (match_operand 0 "" ""))))]
6562   "TARGET_HARD_FLOAT"
6563 {
6564   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6565   return "fjogl %l0";
6566 }
6567   [(set_attr "type" "fbcc")])
6568
6569 (define_insn "*bunge_rev"
6570   [(set (pc)
6571         (if_then_else (unge (cc0) (const_int 0))
6572                       (pc)
6573                       (label_ref (match_operand 0 "" ""))))]
6574   "TARGET_HARD_FLOAT"
6575 {
6576   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6577   return "fjolt %l0";
6578 }
6579   [(set_attr "type" "fbcc")])
6580
6581 (define_insn "*bungt_rev"
6582   [(set (pc)
6583         (if_then_else (ungt (cc0) (const_int 0))
6584                       (pc)
6585                       (label_ref (match_operand 0 "" ""))))]
6586   "TARGET_HARD_FLOAT"
6587 {
6588   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6589   return "fjole %l0";
6590 }
6591   [(set_attr "type" "fbcc")])
6592
6593 (define_insn "*bunle_rev"
6594   [(set (pc)
6595         (if_then_else (unle (cc0) (const_int 0))
6596                       (pc)
6597                       (label_ref (match_operand 0 "" ""))))]
6598   "TARGET_HARD_FLOAT"
6599 {
6600   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6601   return "fjogt %l0";
6602 }
6603   [(set_attr "type" "fbcc")])
6604
6605 (define_insn "*bunlt_rev"
6606   [(set (pc)
6607         (if_then_else (unlt (cc0) (const_int 0))
6608                       (pc)
6609                       (label_ref (match_operand 0 "" ""))))]
6610   "TARGET_HARD_FLOAT"
6611 {
6612   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6613   return "fjoge %l0";
6614 }
6615   [(set_attr "type" "fbcc")])
6616
6617 (define_insn "*bltgt_rev"
6618   [(set (pc)
6619         (if_then_else (ltgt (cc0) (const_int 0))
6620                       (pc)
6621                       (label_ref (match_operand 0 "" ""))))]
6622   "TARGET_HARD_FLOAT"
6623 {
6624   gcc_assert (cc_prev_status.flags & CC_IN_68881);
6625   return "fjueq %l0";
6626 }
6627   [(set_attr "type" "fbcc")])
6628 \f
6629 ;; Unconditional and other jump instructions
6630 (define_insn "jump"
6631   [(set (pc)
6632         (label_ref (match_operand 0 "" "")))]
6633   ""
6634   "jra %l0"
6635   [(set_attr "type" "bra")])
6636
6637 (define_expand "tablejump"
6638   [(parallel [(set (pc) (match_operand 0 "" ""))
6639               (use (label_ref (match_operand 1 "" "")))])]
6640   ""
6641 {
6642 #if CASE_VECTOR_PC_RELATIVE
6643     operands[0] = gen_rtx_PLUS (SImode, pc_rtx,
6644                                 gen_rtx_SIGN_EXTEND (SImode, operands[0]));
6645 #endif
6646 })
6647
6648 ;; Jump to variable address from dispatch table of absolute addresses.
6649 (define_insn "*tablejump_internal"
6650   [(set (pc) (match_operand:SI 0 "register_operand" "a"))
6651    (use (label_ref (match_operand 1 "" "")))]
6652   ""
6653 {
6654   return MOTOROLA ? "jmp (%0)" : "jmp %0@";
6655 }
6656   [(set_attr "type" "jmp")])
6657
6658 ;; Jump to variable address from dispatch table of relative addresses.
6659 (define_insn ""
6660   [(set (pc)
6661         (plus:SI (pc)
6662                  (sign_extend:SI (match_operand:HI 0 "register_operand" "r"))))
6663    (use (label_ref (match_operand 1 "" "")))]
6664   ""
6665 {
6666 #ifdef ASM_RETURN_CASE_JUMP
6667   ASM_RETURN_CASE_JUMP;
6668 #else
6669   if (TARGET_COLDFIRE)
6670     {
6671       if (ADDRESS_REG_P (operands[0]))
6672         return MOTOROLA ? "jmp (2,pc,%0.l)" : "jmp pc@(2,%0:l)";
6673       else if (MOTOROLA)
6674         return "ext%.l %0\;jmp (2,pc,%0.l)";
6675       else
6676         return "extl %0\;jmp pc@(2,%0:l)";
6677     }
6678   else
6679     return MOTOROLA ? "jmp (2,pc,%0.w)" : "jmp pc@(2,%0:w)";
6680 #endif
6681 })
6682
6683 ;; Decrement-and-branch insns.
6684 (define_insn "*dbne_hi"
6685   [(set (pc)
6686         (if_then_else
6687          (ne (match_operand:HI 0 "nonimmediate_operand" "+d*g")
6688              (const_int 0))
6689          (label_ref (match_operand 1 "" ""))
6690          (pc)))
6691    (set (match_dup 0)
6692         (plus:HI (match_dup 0)
6693                  (const_int -1)))]
6694   "!TARGET_COLDFIRE"
6695 {
6696   CC_STATUS_INIT;
6697   if (DATA_REG_P (operands[0]))
6698     return "dbra %0,%l1";
6699   if (GET_CODE (operands[0]) == MEM)
6700     return "subq%.w #1,%0\;jcc %l1";
6701   return "subq%.w #1,%0\;cmp%.w #-1,%0\;jne %l1";
6702 })
6703
6704 (define_insn "*dbne_si"
6705   [(set (pc)
6706         (if_then_else
6707          (ne (match_operand:SI 0 "nonimmediate_operand" "+d*g")
6708              (const_int 0))
6709          (label_ref (match_operand 1 "" ""))
6710          (pc)))
6711    (set (match_dup 0)
6712         (plus:SI (match_dup 0)
6713                  (const_int -1)))]
6714   "!TARGET_COLDFIRE"
6715 {
6716   CC_STATUS_INIT;
6717   if (DATA_REG_P (operands[0]))
6718     return "dbra %0,%l1\;clr%.w %0\;subq%.l #1,%0\;jcc %l1";
6719   if (GET_CODE (operands[0]) == MEM)
6720     return "subq%.l #1,%0\;jcc %l1";
6721   return "subq%.l #1,%0\;cmp%.l #-1,%0\;jne %l1";
6722 })
6723
6724 ;; Two dbra patterns that use REG_NOTES info generated by strength_reduce.
6725
6726 (define_insn "*dbge_hi"
6727   [(set (pc)
6728         (if_then_else
6729           (ge (plus:HI (match_operand:HI 0 "nonimmediate_operand" "+d*am")
6730                        (const_int -1))
6731               (const_int 0))
6732           (label_ref (match_operand 1 "" ""))
6733           (pc)))
6734    (set (match_dup 0)
6735         (plus:HI (match_dup 0)
6736                  (const_int -1)))]
6737   "!TARGET_COLDFIRE && find_reg_note (insn, REG_NONNEG, 0)"
6738 {
6739   CC_STATUS_INIT;
6740   if (DATA_REG_P (operands[0]))
6741     return "dbra %0,%l1";
6742   if (GET_CODE (operands[0]) == MEM)
6743     return "subq%.w #1,%0\;jcc %l1";
6744   return "subq%.w #1,%0\;cmp%.w #-1,%0\;jne %l1";
6745 })
6746
6747 (define_expand "decrement_and_branch_until_zero"
6748   [(parallel [(set (pc)
6749                    (if_then_else
6750                     (ge (plus:SI (match_operand:SI 0 "nonimmediate_operand" "")
6751                                  (const_int -1))
6752                         (const_int 0))
6753                     (label_ref (match_operand 1 "" ""))
6754                     (pc)))
6755               (set (match_dup 0)
6756                    (plus:SI (match_dup 0)
6757                             (const_int -1)))])]
6758   ""
6759   "")
6760
6761 (define_insn "*dbge_si"
6762   [(set (pc)
6763         (if_then_else
6764           (ge (plus:SI (match_operand:SI 0 "nonimmediate_operand" "+d*am")
6765                        (const_int -1))
6766               (const_int 0))
6767           (label_ref (match_operand 1 "" ""))
6768           (pc)))
6769    (set (match_dup 0)
6770         (plus:SI (match_dup 0)
6771                  (const_int -1)))]
6772   "!TARGET_COLDFIRE && find_reg_note (insn, REG_NONNEG, 0)"
6773 {
6774   CC_STATUS_INIT;
6775   if (DATA_REG_P (operands[0]))
6776     return "dbra %0,%l1\;clr%.w %0\;subq%.l #1,%0\;jcc %l1";
6777   if (GET_CODE (operands[0]) == MEM)
6778     return "subq%.l #1,%0\;jcc %l1";
6779   return "subq%.l #1,%0\;cmp%.l #-1,%0\;jne %l1";
6780 })
6781
6782 (define_expand "sibcall"
6783   [(call (match_operand:QI 0 "memory_operand" "")
6784          (match_operand:SI 1 "general_operand" ""))]
6785   ""
6786 {
6787   operands[0] = m68k_legitimize_sibcall_address (operands[0]);
6788 })
6789
6790 (define_insn "*sibcall"
6791   [(call (mem:QI (match_operand:SI 0 "sibcall_operand" ""))
6792          (match_operand:SI 1 "general_operand" ""))]
6793   "SIBLING_CALL_P (insn)"
6794 {
6795   return output_sibcall (operands[0]);
6796 })
6797
6798 (define_expand "sibcall_value"
6799   [(set (match_operand 0 "" "")
6800         (call (match_operand:QI 1 "memory_operand" "")
6801               (match_operand:SI 2 "general_operand" "")))]
6802   ""
6803 {
6804   operands[1] = m68k_legitimize_sibcall_address (operands[1]);
6805 })
6806
6807 (define_insn "*sibcall_value"
6808   [(set (match_operand 0 "" "=rf,rf")
6809         (call (mem:QI (match_operand:SI 1 "sibcall_operand" ""))
6810               (match_operand:SI 2 "general_operand" "")))]
6811   "SIBLING_CALL_P (insn)"
6812 {
6813   operands[0] = operands[1];
6814   return output_sibcall (operands[0]);
6815 })
6816
6817 ;; Call subroutine with no return value.
6818 (define_expand "call"
6819   [(call (match_operand:QI 0 "memory_operand" "")
6820          (match_operand:SI 1 "general_operand" ""))]
6821   ;; Operand 1 not really used on the m68000.
6822   ""
6823 {
6824   operands[0] = m68k_legitimize_call_address (operands[0]);
6825 })
6826
6827 (define_insn "*call"
6828   [(call (mem:QI (match_operand:SI 0 "call_operand" "a,W"))
6829          (match_operand:SI 1 "general_operand" "g,g"))]
6830   ;; Operand 1 not really used on the m68000.
6831   "!SIBLING_CALL_P (insn)"
6832 {
6833   return output_call (operands[0]);
6834 }
6835   [(set_attr "type" "jsr")])
6836
6837 ;; Call subroutine, returning value in operand 0
6838 ;; (which must be a hard register).
6839 (define_expand "call_value"
6840   [(set (match_operand 0 "" "")
6841         (call (match_operand:QI 1 "memory_operand" "")
6842               (match_operand:SI 2 "general_operand" "")))]
6843   ;; Operand 2 not really used on the m68000.
6844   ""
6845 {
6846   operands[1] = m68k_legitimize_call_address (operands[1]);
6847 })
6848
6849 (define_insn "*non_symbolic_call_value"
6850   [(set (match_operand 0 "" "=rf,rf")
6851         (call (mem:QI (match_operand:SI 1 "non_symbolic_call_operand" "a,W"))
6852               (match_operand:SI 2 "general_operand" "g,g")))]
6853   ;; Operand 2 not really used on the m68000.
6854   "!SIBLING_CALL_P (insn)"
6855   "jsr %a1"
6856   [(set_attr "type" "jsr")
6857    (set_attr "opx" "1")])
6858
6859 (define_insn "*symbolic_call_value_jsr"
6860   [(set (match_operand 0 "" "=rf,rf")
6861         (call (mem:QI (match_operand:SI 1 "symbolic_operand" "a,W"))
6862               (match_operand:SI 2 "general_operand" "g,g")))]
6863   ;; Operand 2 not really used on the m68000.
6864   "!SIBLING_CALL_P (insn) && m68k_symbolic_call_var == M68K_SYMBOLIC_CALL_JSR"
6865 {
6866   operands[0] = operands[1];
6867   return m68k_symbolic_call;
6868 }
6869   [(set_attr "type" "jsr")
6870    (set_attr "opx" "1")])
6871
6872 (define_insn "*symbolic_call_value_bsr"
6873   [(set (match_operand 0 "" "=rf,rf")
6874         (call (mem:QI (match_operand:SI 1 "symbolic_operand" "a,W"))
6875               (match_operand:SI 2 "general_operand" "g,g")))]
6876   ;; Operand 2 not really used on the m68000.
6877   "!SIBLING_CALL_P (insn)
6878    && (m68k_symbolic_call_var == M68K_SYMBOLIC_CALL_BSR_C
6879        || m68k_symbolic_call_var == M68K_SYMBOLIC_CALL_BSR_P)"
6880 {
6881   operands[0] = operands[1];
6882   return m68k_symbolic_call;
6883 }
6884   [(set_attr "type" "bsr")
6885    (set_attr "opx" "1")])
6886
6887 ;; Call subroutine returning any type.
6888
6889 (define_expand "untyped_call"
6890   [(parallel [(call (match_operand 0 "" "")
6891                     (const_int 0))
6892               (match_operand 1 "" "")
6893               (match_operand 2 "" "")])]
6894   "NEEDS_UNTYPED_CALL"
6895 {
6896   int i;
6897
6898   emit_call_insn (GEN_CALL (operands[0], const0_rtx, NULL, const0_rtx));
6899
6900   for (i = 0; i < XVECLEN (operands[2], 0); i++)
6901     {
6902       rtx set = XVECEXP (operands[2], 0, i);
6903       emit_move_insn (SET_DEST (set), SET_SRC (set));
6904     }
6905
6906   /* The optimizer does not know that the call sets the function value
6907      registers we stored in the result block.  We avoid problems by
6908      claiming that all hard registers are used and clobbered at this
6909      point.  */
6910   emit_insn (gen_blockage ());
6911
6912   DONE;
6913 })
6914
6915 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
6916 ;; all of memory.  This blocks insns from being moved across this point.
6917
6918 (define_insn "blockage"
6919   [(unspec_volatile [(const_int 0)] UNSPECV_BLOCKAGE)]
6920   ""
6921   "")
6922
6923 (define_insn "nop"
6924   [(const_int 0)]
6925   ""
6926   "nop"
6927   [(set_attr "type" "nop")])
6928
6929 (define_expand "prologue"
6930   [(const_int 0)]
6931   ""
6932 {
6933   m68k_expand_prologue ();
6934   DONE;
6935 })
6936
6937 (define_expand "epilogue"
6938   [(return)]
6939   ""
6940 {
6941   m68k_expand_epilogue (false);
6942   DONE;
6943 })
6944
6945 (define_expand "sibcall_epilogue"
6946   [(return)]
6947   ""
6948 {
6949   m68k_expand_epilogue (true);
6950   DONE;
6951 })
6952
6953 ;; Used for frameless functions which save no regs and allocate no locals.
6954 (define_expand "return"
6955   [(return)]
6956   "m68k_use_return_insn ()"
6957   "")
6958
6959 (define_insn "*return"
6960   [(return)]
6961   ""
6962 {
6963   switch (m68k_get_function_kind (current_function_decl))
6964     {
6965     case m68k_fk_interrupt_handler:
6966       return "rte";
6967
6968     case m68k_fk_interrupt_thread:
6969       return "sleep";
6970
6971     default:
6972       if (crtl->args.pops_args)
6973         {
6974           operands[0] = GEN_INT (crtl->args.pops_args);
6975           return "rtd %0";
6976         }
6977       else
6978         return "rts";
6979     }
6980 }
6981   [(set_attr "type" "rts")])
6982
6983 (define_insn "*m68k_store_multiple"
6984   [(match_parallel 0 "" [(match_operand 1 "")])]
6985   "m68k_movem_pattern_p (operands[0], NULL, 0, true)"
6986 {
6987   return m68k_output_movem (operands, operands[0], 0, true);
6988 })
6989
6990 (define_insn "*m68k_store_multiple_automod"
6991   [(match_parallel 0 ""
6992      [(set (match_operand:SI 1 "register_operand" "=a")
6993            (plus:SI (match_operand:SI 2 "register_operand" "1")
6994                     (match_operand:SI 3 "const_int_operand")))])]
6995   "m68k_movem_pattern_p (operands[0], operands[1], INTVAL (operands[3]), true)"
6996 {
6997   return m68k_output_movem (operands, operands[0], INTVAL (operands[3]), true);
6998 })
6999
7000 (define_insn "*m68k_load_multiple"
7001   [(match_parallel 0 "" [(match_operand 1 "")])]
7002   "m68k_movem_pattern_p (operands[0], NULL, 0, false)"
7003 {
7004   return m68k_output_movem (operands, operands[0], 0, false);
7005 })
7006
7007 (define_insn "*m68k_load_multiple_automod"
7008   [(match_parallel 0 ""
7009      [(set (match_operand:SI 1 "register_operand" "=a")
7010            (plus:SI (match_operand:SI 2 "register_operand" "1")
7011                     (match_operand:SI 3 "const_int_operand")))])]
7012   "m68k_movem_pattern_p (operands[0], operands[1],
7013                          INTVAL (operands[3]), false)"
7014 {
7015   return m68k_output_movem (operands, operands[0],
7016                             INTVAL (operands[3]), false);
7017 })
7018
7019 (define_expand "link"
7020   [(parallel
7021        [(set (match_operand:SI 0 "register_operand")
7022              (plus:SI (reg:SI SP_REG) (const_int -4)))
7023         (set (match_dup 2)
7024              (match_dup 0))
7025         (set (reg:SI SP_REG)
7026              (plus:SI (reg:SI SP_REG)
7027                       (match_operand:SI 1 "const_int_operand")))])]
7028   "TARGET_68020 || INTVAL (operands[1]) >= -0x8004"
7029 {
7030   operands[2] = gen_frame_mem (SImode,
7031                                plus_constant (Pmode, stack_pointer_rtx, -4));
7032 })
7033
7034 (define_insn "*link"
7035   [(set (match_operand:SI 0 "register_operand" "+r")
7036         (plus:SI (reg:SI SP_REG) (const_int -4)))
7037    (set (mem:SI (plus:SI (reg:SI SP_REG) (const_int -4)))
7038         (match_dup 0))
7039    (set (reg:SI SP_REG)
7040         (plus:SI (reg:SI SP_REG)
7041                  (match_operand:SI 1 "const_int_operand")))]
7042   "TARGET_68020 || INTVAL (operands[1]) >= -0x8004"
7043 {
7044   operands[1] = GEN_INT (INTVAL (operands[1]) + 4);
7045   if (!MOTOROLA)
7046     return "link %0,%1";
7047   else if (INTVAL (operands[1]) >= -0x8000)
7048     return "link.w %0,%1";
7049   else
7050     return "link.l %0,%1";
7051 }
7052   [(set_attr "type" "link")])
7053
7054 (define_expand "unlink"
7055   [(parallel
7056       [(set (match_operand:SI 0 "register_operand")
7057             (match_dup 1))
7058        (set (reg:SI SP_REG)
7059             (plus:SI (match_dup 0)
7060                      (const_int 4)))])]
7061   ""
7062 {
7063   operands[1] = gen_frame_mem (SImode, copy_rtx (operands[0]));
7064 })
7065
7066 (define_insn "*unlink"
7067   [(set (match_operand:SI 0 "register_operand" "+r")
7068         (mem:SI (match_dup 0)))
7069    (set (reg:SI SP_REG)
7070         (plus:SI (match_dup 0)
7071                  (const_int 4)))]
7072   ""
7073   "unlk %0"
7074   [(set_attr "type" "unlk")])
7075
7076 (define_insn "load_got"
7077   [(set (match_operand:SI 0 "register_operand" "=a")
7078         (unspec:SI [(const_int 0)] UNSPEC_GOT))]
7079   ""
7080 {
7081   if (TARGET_ID_SHARED_LIBRARY)
7082     {
7083       operands[1] = gen_rtx_REG (Pmode, PIC_REG);
7084       return MOTOROLA ? "move.l %?(%1),%0" : "movel %1@(%?), %0";
7085     }
7086   else if (MOTOROLA)
7087     {
7088       if (TARGET_COLDFIRE)
7089         /* Load the full 32-bit PC-relative offset of
7090            _GLOBAL_OFFSET_TABLE_ into the PIC register, then use it to
7091            calculate the absolute value.  The offset and "lea"
7092            operation word together occupy 6 bytes.  */
7093         return ("move.l #_GLOBAL_OFFSET_TABLE_@GOTPC, %0\n\t"
7094                 "lea (-6, %%pc, %0), %0");
7095       else
7096         return "lea (%%pc, _GLOBAL_OFFSET_TABLE_@GOTPC), %0";
7097     }
7098   else
7099     return ("movel #_GLOBAL_OFFSET_TABLE_, %0\n\t"
7100             "lea %%pc@(0,%0:l),%0");
7101 })
7102
7103 (define_insn "indirect_jump"
7104   [(set (pc) (match_operand:SI 0 "address_operand" "p"))]
7105   ""
7106   "jmp %a0"
7107   [(set_attr "type" "jmp")])
7108 \f
7109 ;; This should not be used unless the add/sub insns can't be.
7110
7111 (define_insn "*lea"
7112   [(set (match_operand:SI 0 "nonimmediate_operand" "=a")
7113         (match_operand:QI 1 "address_operand" "p"))]
7114   ""
7115   "lea %a1,%0")
7116 \f
7117 ;; This is the first machine-dependent peephole optimization.
7118 ;; It is useful when a floating value is returned from a function call
7119 ;; and then is moved into an FP register.
7120 ;; But it is mainly intended to test the support for these optimizations.
7121
7122 (define_peephole2
7123   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4)))
7124    (set (match_operand:DF 0 "register_operand" "")
7125         (match_operand:DF 1 "register_operand" ""))]
7126   "FP_REG_P (operands[0]) && !FP_REG_P (operands[1])"
7127   [(set (mem:SI (reg:SI SP_REG)) (match_dup 1))
7128    (set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 2))
7129    (set (match_dup 0) (mem:DF (post_inc:SI (reg:SI SP_REG))))]
7130   "split_di(operands + 1, 1, operands + 1, operands + 2);")
7131
7132 ;; Optimize a stack-adjust followed by a push of an argument.
7133 ;; This is said to happen frequently with -msoft-float
7134 ;; when there are consecutive library calls.
7135
7136 (define_peephole2
7137   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4)))
7138    (set (match_operand:SF 0 "push_operand" "")
7139         (match_operand:SF 1 "general_operand" ""))]
7140   "!reg_mentioned_p (stack_pointer_rtx, operands[0])"
7141   [(set (match_dup 0) (match_dup 1))]
7142   "operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);")
7143
7144 (define_peephole2
7145   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG)
7146                                  (match_operand:SI 0 "const_int_operand" "")))
7147    (set (match_operand:SF 1 "push_operand" "")
7148         (match_operand:SF 2 "general_operand" ""))]
7149   "INTVAL (operands[0]) > 4
7150    && !reg_mentioned_p (stack_pointer_rtx, operands[2])"
7151   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (match_dup 0)))
7152    (set (match_dup 1) (match_dup 2))]
7153 {
7154   operands[0] = GEN_INT (INTVAL (operands[0]) - 4);
7155   operands[1] = replace_equiv_address (operands[1], stack_pointer_rtx);
7156 })
7157
7158 ;; Speed up stack adjust followed by a fullword fixedpoint push.
7159 ;; Constant operands need special care, as replacing a "pea X.w" with
7160 ;; "move.l #X,(%sp)" is often not a win.
7161
7162 ;; Already done by the previous csa pass, left as reference.
7163 (define_peephole2
7164   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4)))
7165    (set (match_operand:SI 0 "push_operand" "")
7166         (match_operand:SI 1 "general_operand" ""))]
7167   "!reg_mentioned_p (stack_pointer_rtx, operands[1])"
7168   [(set (match_dup 0) (match_dup 1))]
7169   "operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);")
7170
7171 ;; Try to use moveq, after stack push has been changed into a simple move.
7172 (define_peephole2
7173   [(match_scratch:SI 2 "d")
7174    (set (match_operand:SI 0 "memory_operand" "")
7175         (match_operand:SI 1 "const_int_operand" ""))]
7176   "GET_CODE (XEXP (operands[0], 0)) != PRE_DEC
7177    && INTVAL (operands[1]) != 0
7178    && IN_RANGE (INTVAL (operands[1]), -0x80, 0x7f)
7179    && !valid_mov3q_const (INTVAL (operands[1]))"
7180   [(set (match_dup 2) (match_dup 1))
7181    (set (match_dup 0) (match_dup 2))])
7182
7183 ;; This sequence adds an instruction, but is two bytes shorter.
7184 (define_peephole2
7185   [(match_scratch:SI 2 "d")
7186    (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 12)))
7187    (set (match_operand:SI 0 "push_operand" "")
7188         (match_operand:SI 1 "const_int_operand" ""))]
7189   "INTVAL (operands[1]) != 0
7190    && IN_RANGE (INTVAL (operands[1]), -0x80, 0x7f)
7191    && !valid_mov3q_const (INTVAL (operands[1]))"
7192   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 8)))
7193    (set (match_dup 2) (match_dup 1))
7194    (set (match_dup 0) (match_dup 2))]
7195   "operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);")
7196
7197 ;; Changing pea X.w into a move.l is no real win here.
7198 (define_peephole2
7199   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG)
7200                                  (match_operand:SI 0 "const_int_operand" "")))
7201    (set (match_operand:SI 1 "push_operand" "")
7202         (match_operand:SI 2 "general_operand" ""))]
7203   "INTVAL (operands[0]) > 4
7204    && !reg_mentioned_p (stack_pointer_rtx, operands[2])
7205    && !(CONST_INT_P (operands[2]) && INTVAL (operands[2]) != 0
7206         && IN_RANGE (INTVAL (operands[2]), -0x8000, 0x7fff)
7207         && !valid_mov3q_const (INTVAL (operands[2])))"
7208   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (match_dup 0)))
7209    (set (match_dup 1) (match_dup 2))]
7210 {
7211   operands[0] = GEN_INT (INTVAL (operands[0]) - 4);
7212   operands[1] = replace_equiv_address (operands[1], stack_pointer_rtx);
7213 })
7214
7215 ;; Speed up pushing a single byte/two bytes but leaving four bytes of space
7216 ;; (which differs slightly between m680x0 and ColdFire).
7217
7218 (define_peephole2
7219   [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4)))
7220    (set (match_operand:QI 0 "memory_operand" "")
7221         (match_operand:QI 1 "register_operand" ""))]
7222   "!reg_mentioned_p (stack_pointer_rtx, operands[1])
7223    && GET_CODE (XEXP (operands[0], 0)) == PLUS
7224    && rtx_equal_p (XEXP (XEXP (operands[0], 0), 0), stack_pointer_rtx)
7225    && CONST_INT_P (XEXP (XEXP (operands[0], 0), 1))
7226    && INTVAL (XEXP (XEXP (operands[0], 0), 1)) == 3"
7227   [(set (match_dup 0) (match_dup 1))]
7228 {
7229   rtx addr = gen_rtx_PRE_DEC (Pmode, stack_pointer_rtx);
7230   operands[0] = adjust_automodify_address (operands[0], SImode, addr, -3);
7231   operands[1] = simplify_gen_subreg (SImode, operands[1], QImode, 0);
7232 })
7233
7234 (define_peephole2
7235   [(set (match_operand:QI 0 "push_operand" "")
7236         (match_operand:QI 1 "register_operand" ""))
7237    (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -3)))]
7238   "!reg_mentioned_p (stack_pointer_rtx, operands[1])"
7239   [(set (match_dup 0) (match_dup 1))]
7240 {
7241   operands[0] = adjust_automodify_address (operands[0], SImode,
7242                                            XEXP (operands[0], 0), -3);
7243   operands[1] = simplify_gen_subreg (SImode, operands[1], QImode, 0);
7244 })
7245
7246 (define_peephole2
7247   [(set (match_operand:HI 0 "push_operand" "")
7248         (match_operand:HI 1 "register_operand" ""))
7249    (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -2)))]
7250   "!reg_mentioned_p (stack_pointer_rtx, operands[1])"
7251   [(set (match_dup 0) (match_dup 1))]
7252 {
7253   operands[0] = adjust_automodify_address (operands[0], SImode,
7254                                            XEXP (operands[0], 0), -2);
7255   operands[1] = simplify_gen_subreg (SImode, operands[1], HImode, 0);
7256 })
7257
7258 ;; Optimize a series of strict_low_part assignments
7259
7260 (define_peephole2
7261   [(set (match_operand:SI 0 "register_operand" "")
7262         (const_int 0))
7263    (set (strict_low_part (match_operand:HI 1 "register_operand" ""))
7264         (match_operand:HI 2 "general_operand" ""))]
7265   "REGNO (operands[0]) == REGNO (operands[1])
7266    && strict_low_part_peephole_ok (HImode, insn, operands[0])"
7267   [(set (strict_low_part (match_dup 1)) (match_dup 2))]
7268   "")
7269
7270 (define_peephole2
7271   [(set (match_operand:SI 0 "register_operand" "")
7272         (const_int 0))
7273    (set (strict_low_part (match_operand:QI 1 "register_operand" ""))
7274         (match_operand:QI 2 "general_operand" ""))]
7275   "REGNO (operands[0]) == REGNO (operands[1])
7276    && strict_low_part_peephole_ok (QImode, insn, operands[0])"
7277   [(set (strict_low_part (match_dup 1)) (match_dup 2))]
7278   "")
7279
7280 ;; dbCC peepholes
7281 ;;
7282 ;; Turns
7283 ;;   loop:
7284 ;;           [ ... ]
7285 ;;           jCC label          ; abnormal loop termination
7286 ;;           dbra dN, loop      ; normal loop termination
7287 ;;
7288 ;; Into
7289 ;;   loop:
7290 ;;           [ ... ]
7291 ;;           dbCC dN, loop
7292 ;;           jCC label
7293 ;;
7294 ;; Which moves the jCC condition outside the inner loop for free.
7295 ;;
7296
7297 (define_peephole
7298   [(set (pc) (if_then_else (match_operator 3 "valid_dbcc_comparison_p"
7299                              [(cc0) (const_int 0)])
7300                            (label_ref (match_operand 2 "" ""))
7301                            (pc)))
7302    (parallel
7303     [(set (pc)
7304           (if_then_else
7305             (ne (match_operand:HI 0 "register_operand" "")
7306                 (const_int 0))
7307             (label_ref (match_operand 1 "" ""))
7308             (pc)))
7309      (set (match_dup 0)
7310           (plus:HI (match_dup 0)
7311                    (const_int -1)))])]
7312   "!TARGET_COLDFIRE && DATA_REG_P (operands[0]) && ! flags_in_68881 ()"
7313 {
7314   CC_STATUS_INIT;
7315   output_dbcc_and_branch (operands);
7316   return "";
7317 })
7318
7319 (define_peephole
7320   [(set (pc) (if_then_else (match_operator 3 "valid_dbcc_comparison_p"
7321                              [(cc0) (const_int 0)])
7322                            (label_ref (match_operand 2 "" ""))
7323                            (pc)))
7324    (parallel
7325     [(set (pc)
7326           (if_then_else
7327             (ne (match_operand:SI 0 "register_operand" "")
7328                 (const_int 0))
7329             (label_ref (match_operand 1 "" ""))
7330             (pc)))
7331      (set (match_dup 0)
7332           (plus:SI (match_dup 0)
7333                    (const_int -1)))])]
7334   "!TARGET_COLDFIRE && DATA_REG_P (operands[0]) && ! flags_in_68881 ()"
7335 {
7336   CC_STATUS_INIT;
7337   output_dbcc_and_branch (operands);
7338   return "";
7339 })
7340
7341 (define_peephole
7342   [(set (pc) (if_then_else (match_operator 3 "valid_dbcc_comparison_p"
7343                              [(cc0) (const_int 0)])
7344                            (label_ref (match_operand 2 "" ""))
7345                            (pc)))
7346    (parallel
7347     [(set (pc)
7348           (if_then_else
7349             (ge (plus:HI (match_operand:HI 0 "register_operand" "")
7350                          (const_int -1))
7351                 (const_int 0))
7352             (label_ref (match_operand 1 "" ""))
7353             (pc)))
7354      (set (match_dup 0)
7355           (plus:HI (match_dup 0)
7356                    (const_int -1)))])]
7357   "!TARGET_COLDFIRE && DATA_REG_P (operands[0]) && ! flags_in_68881 ()"
7358 {
7359   CC_STATUS_INIT;
7360   output_dbcc_and_branch (operands);
7361   return "";
7362 })
7363
7364 (define_peephole
7365   [(set (pc) (if_then_else (match_operator 3 "valid_dbcc_comparison_p"
7366                              [(cc0) (const_int 0)])
7367                            (label_ref (match_operand 2 "" ""))
7368                            (pc)))
7369    (parallel
7370     [(set (pc)
7371           (if_then_else
7372             (ge (plus:SI (match_operand:SI 0 "register_operand" "")
7373                          (const_int -1))
7374                 (const_int 0))
7375             (label_ref (match_operand 1 "" ""))
7376             (pc)))
7377      (set (match_dup 0)
7378           (plus:SI (match_dup 0)
7379                    (const_int -1)))])]
7380   "!TARGET_COLDFIRE && DATA_REG_P (operands[0]) && ! flags_in_68881 ()"
7381 {
7382   CC_STATUS_INIT;
7383   output_dbcc_and_branch (operands);
7384   return "";
7385 })
7386
7387 \f
7388 (define_insn "extendsfxf2"
7389   [(set (match_operand:XF 0 "nonimmediate_operand" "=fm,f")
7390         (float_extend:XF (match_operand:SF 1 "general_operand" "f,rmF")))]
7391   "TARGET_68881"
7392 {
7393   if (FP_REG_P (operands[0]) && FP_REG_P (operands[1]))
7394     {
7395       if (REGNO (operands[0]) == REGNO (operands[1]))
7396         {
7397           /* Extending float to double in an fp-reg is a no-op.
7398              NOTICE_UPDATE_CC has already assumed that the
7399              cc will be set.  So cancel what it did.  */
7400           cc_status = cc_prev_status;
7401           return "";
7402         }
7403       return "f%$move%.x %1,%0";
7404     }
7405   if (FP_REG_P (operands[0]))
7406     {
7407       if (FP_REG_P (operands[1]))
7408         return "f%$move%.x %1,%0";
7409       else if (ADDRESS_REG_P (operands[1]))
7410         return "move%.l %1,%-\;f%$move%.s %+,%0";
7411       else if (GET_CODE (operands[1]) == CONST_DOUBLE)
7412         return output_move_const_single (operands);
7413       return "f%$move%.s %f1,%0";
7414     }
7415   return "fmove%.x %f1,%0";
7416 })
7417
7418
7419 (define_insn "extenddfxf2"
7420   [(set (match_operand:XF 0 "nonimmediate_operand" "=fm,f")
7421         (float_extend:XF
7422           (match_operand:DF 1 "general_operand" "f,rmE")))]
7423   "TARGET_68881"
7424 {
7425   if (FP_REG_P (operands[0]) && FP_REG_P (operands[1]))
7426     {
7427       if (REGNO (operands[0]) == REGNO (operands[1]))
7428         {
7429           /* Extending float to double in an fp-reg is a no-op.
7430              NOTICE_UPDATE_CC has already assumed that the
7431              cc will be set.  So cancel what it did.  */
7432           cc_status = cc_prev_status;
7433           return "";
7434         }
7435       return "fmove%.x %1,%0";
7436     }
7437   if (FP_REG_P (operands[0]))
7438     {
7439       if (REG_P (operands[1]))
7440         {
7441           rtx xoperands[2];
7442           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
7443           output_asm_insn ("move%.l %1,%-", xoperands);
7444           output_asm_insn ("move%.l %1,%-", operands);
7445           return "f%&move%.d %+,%0";
7446         }
7447       if (GET_CODE (operands[1]) == CONST_DOUBLE)
7448         return output_move_const_double (operands);
7449       return "f%&move%.d %f1,%0";
7450     }
7451   return "fmove%.x %f1,%0";
7452 })
7453
7454 (define_insn "truncxfdf2"
7455   [(set (match_operand:DF 0 "nonimmediate_operand" "=m,!r")
7456         (float_truncate:DF
7457           (match_operand:XF 1 "general_operand" "f,f")))]
7458   "TARGET_68881"
7459 {
7460   if (REG_P (operands[0]))
7461     {
7462       output_asm_insn ("fmove%.d %f1,%-\;move%.l %+,%0", operands);
7463       operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
7464       return "move%.l %+,%0";
7465     }
7466   return "fmove%.d %f1,%0";
7467 })
7468
7469 (define_insn "truncxfsf2"
7470   [(set (match_operand:SF 0 "nonimmediate_operand" "=dm")
7471         (float_truncate:SF
7472           (match_operand:XF 1 "general_operand" "f")))]
7473   "TARGET_68881"
7474   "fmove%.s %f1,%0")
7475
7476 (define_insn "sin<mode>2"
7477   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
7478         (unspec:FP
7479           [(match_operand:FP 1 "general_operand" "f<FP:dreg>m")] UNSPEC_SIN))]
7480   "TARGET_68881 && flag_unsafe_math_optimizations"
7481 {
7482   if (FP_REG_P (operands[1]))
7483     return "fsin%.x %1,%0";
7484   else
7485     return "fsin%.<FP:prec> %1,%0";
7486 })
7487
7488 (define_insn "cos<mode>2"
7489   [(set (match_operand:FP 0 "nonimmediate_operand" "=f")
7490         (unspec:FP
7491           [(match_operand:FP 1 "general_operand" "f<FP:dreg>m")] UNSPEC_COS))]
7492   "TARGET_68881 && flag_unsafe_math_optimizations"
7493 {
7494   if (FP_REG_P (operands[1]))
7495     return "fcos%.x %1,%0";
7496   else
7497     return "fcos%.<FP:prec> %1,%0";
7498 })
7499
7500 ;; Unconditional traps are assumed to have (const_int 1) for the condition.
7501 (define_insn "trap"
7502   [(trap_if (const_int 1) (const_int 7))]
7503   ""
7504   "trap #7"
7505   [(set_attr "type" "trap")])
7506
7507 (define_expand "ctrapdi4"
7508   [(trap_if (match_operator 0 "ordered_comparison_operator"
7509                             [(cc0) (const_int 0)])
7510             (match_operand:SI 3 "const1_operand" ""))]
7511   "TARGET_68020"
7512 {
7513   if (operands[2] == const0_rtx)
7514     emit_insn (gen_tstdi (operands[1]));
7515   else
7516     emit_insn (gen_cmpdi (operands[1], operands[2]));
7517   operands[1] = cc0_rtx;
7518   operands[2] = const0_rtx;
7519 })
7520
7521 (define_expand "ctrapsi4"
7522   [(set (cc0)
7523         (compare (match_operand:SI 1 "nonimmediate_operand" "")
7524                  (match_operand:SI 2 "general_operand" "")))
7525    (trap_if (match_operator 0 "ordered_comparison_operator"
7526                             [(cc0) (const_int 0)])
7527             (match_operand:SI 3 "const1_operand" ""))]
7528   "TARGET_68020"
7529   "")
7530
7531 (define_expand "ctraphi4"
7532   [(set (cc0)
7533         (compare (match_operand:HI 1 "nonimmediate_src_operand" "")
7534                  (match_operand:HI 2 "general_src_operand" "")))
7535    (trap_if (match_operator 0 "ordered_comparison_operator"
7536                             [(cc0) (const_int 0)])
7537             (match_operand:SI 3 "const1_operand" ""))]
7538   "TARGET_68020"
7539   "")
7540
7541 (define_expand "ctrapqi4"
7542   [(set (cc0)
7543         (compare (match_operand:QI 1 "nonimmediate_src_operand" "")
7544                  (match_operand:QI 2 "general_src_operand" "")))
7545    (trap_if (match_operator 0 "ordered_comparison_operator"
7546                             [(cc0) (const_int 0)])
7547             (match_operand:SI 3 "const1_operand" ""))]
7548   "TARGET_68020"
7549   "")
7550
7551 (define_insn "*conditional_trap"
7552   [(trap_if (match_operator 0 "ordered_comparison_operator"
7553                             [(cc0) (const_int 0)])
7554             (match_operand:SI 1 "const1_operand" "I"))]
7555   "TARGET_68020 && ! flags_in_68881 ()"
7556 {
7557   switch (GET_CODE (operands[0]))
7558   {
7559   case EQ:  return "trapeq";
7560   case NE:  return "trapne";
7561   case GT:  return "trapgt";
7562   case GTU: return "traphi";
7563   case LT:  return "traplt";
7564   case LTU: return "trapcs";
7565   case GE:  return "trapge";
7566   case GEU: return "trapcc";
7567   case LE:  return "traple";
7568   case LEU: return "trapls";
7569   default: gcc_unreachable ();
7570   }
7571 })
7572
7573 ;; These are to prevent the scheduler from moving stores to the frame
7574 ;; before the stack adjustment.
7575 (define_insn "stack_tie"
7576   [(set (mem:BLK (scratch))
7577         (unspec:BLK [(match_operand:SI 0 "register_operand" "r")
7578                      (match_operand:SI 1 "register_operand" "r")]
7579                     UNSPEC_TIE))]
7580   ""
7581   ""
7582   [(set_attr "type" "ignore")])
7583
7584 ;; Instruction that subscribes one word in ColdFire instruction buffer.
7585 ;; This instruction is used within scheduler only and should not appear
7586 ;; in the instruction stream.
7587 (define_insn "ib"
7588   [(unspec [(const_int 0)] UNSPEC_IB)]
7589   ""
7590   "#"
7591   [(set_attr "type" "ib")])
7592
7593 (include "cf.md")
7594 (include "sync.md")