gcc/config/bfin/bfin.md

   1 ;;- Machine description for Blackfin for GNU compiler
   2 ;;  Copyright 2005, 2006  Free Software Foundation, Inc.
   3 ;;  Contributed by Analog Devices.
   4
   5 ;; This file is part of GCC.
   6
   7 ;; GCC is free software; you can redistribute it and/or modify it
   8 ;; under the terms of the GNU General Public License as published
   9 ;; by the Free Software Foundation; either version 2, or (at your
  10 ;; option) any later version.
  11
  12 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
  13 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15 ;; License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING.  If not, write to
  19 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  20 ;; Boston, MA 02110-1301, USA.
  21
  22 ; operand punctuation marks:
  23 ;
  24 ;     X -- integer value printed as log2
  25 ;     Y -- integer value printed as log2(~value) - for bitclear
  26 ;     h -- print half word register, low part
  27 ;     d -- print half word register, high part
  28 ;     D -- print operand as dregs pairs
  29 ;     w -- print operand as accumulator register word (a0w, a1w)
  30 ;     H -- high part of double mode operand
  31 ;     T -- byte register representation Oct. 02 2001
  32
  33 ; constant operand classes
  34 ;
  35 ;     J   2**N       5bit imm scaled
  36 ;     Ks7 -64 .. 63  signed 7bit imm
  37 ;     Ku5 0..31      unsigned 5bit imm
  38 ;     Ks4 -8 .. 7    signed 4bit imm
  39 ;     Ks3 -4 .. 3    signed 3bit imm
  40 ;     Ku3 0 .. 7     unsigned 3bit imm
  41 ;     Pn  0, 1, 2    constants 0, 1 or 2, corresponding to n
  42 ;
  43 ; register operands
  44 ;     d  (r0..r7)
  45 ;     a  (p0..p5,fp,sp)
  46 ;     e  (a0, a1)
  47 ;     b  (i0..i3)
  48 ;     f  (m0..m3)
  49 ;     B
  50 ;     c (i0..i3,m0..m3) CIRCREGS
  51 ;     C (CC)            CCREGS
  52 ;     t  (lt0,lt1)
  53 ;     k  (lc0,lc1)
  54 ;     l  (lb0,lb1)
  55 ;
  56
  57 ;; Define constants for hard registers.
  58
  59 (define_constants
  60   [(REG_R0 0)
  61    (REG_R1 1)
  62    (REG_R2 2)
  63    (REG_R3 3)
  64    (REG_R4 4)
  65    (REG_R5 5)
  66    (REG_R6 6)
  67    (REG_R7 7)
  68
  69    (REG_P0 8)
  70    (REG_P1 9)
  71    (REG_P2 10)
  72    (REG_P3 11)
  73    (REG_P4 12)
  74    (REG_P5 13)
  75    (REG_P6 14)
  76    (REG_P7 15)
  77
  78    (REG_SP 14)
  79    (REG_FP 15)
  80
  81    (REG_I0 16)
  82    (REG_I1 17)
  83    (REG_I2 18)
  84    (REG_I3 19)
  85
  86    (REG_B0 20)
  87    (REG_B1 21)
  88    (REG_B2 22)
  89    (REG_B3 23)
  90
  91    (REG_L0 24)
  92    (REG_L1 25)
  93    (REG_L2 26)
  94    (REG_L3 27)
  95
  96    (REG_M0 28)
  97    (REG_M1 29)
  98    (REG_M2 30)
  99    (REG_M3 31)
 100
 101    (REG_A0 32)
 102    (REG_A1 33)
 103
 104    (REG_CC 34)
 105    (REG_RETS 35)
 106    (REG_RETI 36)
 107    (REG_RETX 37)
 108    (REG_RETN 38)
 109    (REG_RETE 39)
 110
 111    (REG_ASTAT 40)
 112    (REG_SEQSTAT 41)
 113    (REG_USP 42)
 114
 115    (REG_ARGP 43)
 116
 117    (REG_LT0 44)
 118    (REG_LT1 45)
 119    (REG_LC0 46)
 120    (REG_LC1 47)
 121    (REG_LB0 48)
 122    (REG_LB1 49)])
 123
 124 ;; Constants used in UNSPECs and UNSPEC_VOLATILEs.
 125
 126 (define_constants
 127   [(UNSPEC_CBRANCH_TAKEN 0)
 128    (UNSPEC_CBRANCH_NOPS 1)
 129    (UNSPEC_RETURN 2)
 130    (UNSPEC_MOVE_PIC 3)
 131    (UNSPEC_LIBRARY_OFFSET 4)
 132    (UNSPEC_PUSH_MULTIPLE 5)
 133    ;; Multiply or MAC with extra CONST_INT operand specifying the macflag
 134    (UNSPEC_MUL_WITH_FLAG 6)
 135    (UNSPEC_MAC_WITH_FLAG 7)
 136    (UNSPEC_MOVE_FDPIC 8)
 137    (UNSPEC_FUNCDESC_GOT17M4 9)
 138    (UNSPEC_LSETUP_END 10)])
 139
 140 (define_constants
 141   [(UNSPEC_VOLATILE_EH_RETURN 0)
 142    (UNSPEC_VOLATILE_CSYNC 1)
 143    (UNSPEC_VOLATILE_SSYNC 2)
 144    (UNSPEC_VOLATILE_LOAD_FUNCDESC 3)])
 145
 146 (define_constants
 147   [(MACFLAG_NONE 0)
 148    (MACFLAG_T 1)
 149    (MACFLAG_FU 2)
 150    (MACFLAG_TFU 3)
 151    (MACFLAG_IS 4)
 152    (MACFLAG_IU 5)
 153    (MACFLAG_W32 6)
 154    (MACFLAG_M 7)
 155    (MACFLAG_S2RND 8)
 156    (MACFLAG_ISS2 9)
 157    (MACFLAG_IH 10)])
 158
 159 (define_attr "type"
 160   "move,mvi,mcld,mcst,dsp32,mult,alu0,shft,brcc,br,call,misc,sync,compare,dummy"
 161   (const_string "misc"))
 162
 163 ;; Scheduling definitions
 164
 165 (define_automaton "bfin")
 166
 167 (define_cpu_unit "core" "bfin")
 168
 169 (define_insn_reservation "alu" 1
 170   (eq_attr "type" "move,mvi,mcst,dsp32,alu0,shft,brcc,br,call,misc,sync,compare")
 171   "core")
 172
 173 (define_insn_reservation "imul" 3
 174   (eq_attr "type" "mult")
 175   "core*3")
 176
 177 (define_insn_reservation "load" 1
 178   (eq_attr "type" "mcld")
 179   "core")
 180
 181 ;; Make sure genautomata knows about the maximum latency that can be produced
 182 ;; by the adjust_cost function.
 183 (define_insn_reservation "dummy" 5
 184   (eq_attr "type" "mcld")
 185   "core")
 186 \f
 187 ;; Operand and operator predicates
 188
 189 (include "predicates.md")
 190
 191 \f
 192 ;;; FRIO branches have been optimized for code density
 193 ;;; this comes at a slight cost of complexity when
 194 ;;; a compiler needs to generate branches in the general
 195 ;;; case.  In order to generate the correct branching
 196 ;;; mechanisms the compiler needs keep track of instruction
 197 ;;; lengths.  The follow table describes how to count instructions
 198 ;;; for the FRIO architecture.
 199 ;;;
 200 ;;; unconditional br are 12-bit imm pcrelative branches *2
 201 ;;; conditional   br are 10-bit imm pcrelative branches *2
 202 ;;; brcc 10-bit:
 203 ;;;   1024 10-bit imm *2 is 2048 (-1024..1022)
 204 ;;; br 12-bit  :
 205 ;;;   4096 12-bit imm *2 is 8192 (-4096..4094)
 206 ;;; NOTE : For brcc we generate instructions such as
 207 ;;;   if cc jmp; jump.[sl] offset
 208 ;;;   offset of jump.[sl] is from the jump instruction but
 209 ;;;     gcc calculates length from the if cc jmp instruction
 210 ;;;     furthermore gcc takes the end address of the branch instruction
 211 ;;;     as (pc) for a forward branch
 212 ;;;     hence our range is (-4094, 4092) instead of (-4096, 4094) for a br
 213 ;;;
 214 ;;; The way the (pc) rtx works in these calculations is somewhat odd;
 215 ;;; for backward branches it's the address of the current instruction,
 216 ;;; for forward branches it's the previously known address of the following
 217 ;;; instruction - we have to take this into account by reducing the range
 218 ;;; for a forward branch.
 219
 220 ;; Lengths for type "mvi" insns are always defined by the instructions
 221 ;; themselves.
 222 (define_attr "length" ""
 223   (cond [(eq_attr "type" "mcld")
 224          (if_then_else (match_operand 1 "effective_address_32bit_p" "")
 225                        (const_int 4) (const_int 2))
 226
 227          (eq_attr "type" "mcst")
 228          (if_then_else (match_operand 0 "effective_address_32bit_p" "")
 229                        (const_int 4) (const_int 2))
 230
 231          (eq_attr "type" "move") (const_int 2)
 232
 233          (eq_attr "type" "dsp32") (const_int 4)
 234          (eq_attr "type" "call")  (const_int 4)
 235
 236          (eq_attr "type" "br")
 237          (if_then_else (and
 238                           (le (minus (match_dup 0) (pc)) (const_int 4092))
 239                           (ge (minus (match_dup 0) (pc)) (const_int -4096)))
 240                   (const_int 2)
 241                   (const_int 4))
 242
 243          (eq_attr "type" "brcc")
 244          (cond [(and
 245                     (le (minus (match_dup 3) (pc)) (const_int 1020))
 246                     (ge (minus (match_dup 3) (pc)) (const_int -1024)))
 247                   (const_int 2)
 248                 (and
 249                     (le (minus (match_dup 3) (pc)) (const_int 4092))
 250                     (ge (minus (match_dup 3) (pc)) (const_int -4094)))
 251                   (const_int 4)]
 252                (const_int 6))
 253         ]
 254
 255         (const_int 2)))
 256
 257
 258 ;; Classify the insns into those that are one instruction and those that
 259 ;; are more than one in sequence.
 260 (define_attr "seq_insns" "single,multi"
 261   (const_string "single"))
 262
 263 ;; Conditional moves
 264
 265 (define_expand "movsicc"
 266   [(set (match_operand:SI 0 "register_operand" "")
 267         (if_then_else:SI (match_operand 1 "comparison_operator" "")
 268                          (match_operand:SI 2 "register_operand" "")
 269                          (match_operand:SI 3 "register_operand" "")))]
 270   ""
 271 {
 272   operands[1] = bfin_gen_compare (operands[1], SImode);
 273 })
 274
 275 (define_insn "*movsicc_insn1"
 276   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
 277         (if_then_else:SI
 278             (eq:BI (match_operand:BI 3 "register_operand" "C,C,C")
 279                 (const_int 0))
 280             (match_operand:SI 1 "register_operand" "da,0,da")
 281             (match_operand:SI 2 "register_operand" "0,da,da")))]
 282   ""
 283   "@
 284     if !cc %0 =%1; /* movsicc-1a */
 285     if cc %0 =%2; /* movsicc-1b */
 286     if !cc %0 =%1; if cc %0=%2; /* movsicc-1 */"
 287   [(set_attr "length" "2,2,4")
 288    (set_attr "type" "move")
 289    (set_attr "seq_insns" "*,*,multi")])
 290
 291 (define_insn "*movsicc_insn2"
 292   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
 293         (if_then_else:SI
 294             (ne:BI (match_operand:BI 3 "register_operand" "C,C,C")
 295                 (const_int 0))
 296             (match_operand:SI 1 "register_operand" "0,da,da")
 297             (match_operand:SI 2 "register_operand" "da,0,da")))]
 298   ""
 299   "@
 300    if !cc %0 =%2; /* movsicc-2b */
 301    if cc %0 =%1; /* movsicc-2a */
 302    if cc %0 =%1; if !cc %0=%2; /* movsicc-1 */"
 303   [(set_attr "length" "2,2,4")
 304    (set_attr "type" "move")
 305    (set_attr "seq_insns" "*,*,multi")])
 306
 307 ;; Insns to load HIGH and LO_SUM
 308
 309 (define_insn "movsi_high"
 310   [(set (match_operand:SI 0 "register_operand" "=x")
 311         (high:SI (match_operand:SI 1 "immediate_operand" "i")))]
 312   "reload_completed"
 313   "%d0 = %d1;"
 314   [(set_attr "type" "mvi")
 315    (set_attr "length" "4")])
 316
 317 (define_insn "movstricthi_high"
 318   [(set (match_operand:SI 0 "register_operand" "+x")
 319         (ior:SI (and:SI (match_dup 0) (const_int 65535))
 320                 (match_operand:SI 1 "immediate_operand" "i")))]
 321   "reload_completed"
 322   "%d0 = %d1;"
 323   [(set_attr "type" "mvi")
 324    (set_attr "length" "4")])
 325
 326 (define_insn "movsi_low"
 327   [(set (match_operand:SI 0 "register_operand" "=x")
 328         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
 329                    (match_operand:SI 2 "immediate_operand" "i")))]
 330   "reload_completed"
 331   "%h0 = %h2;"
 332   [(set_attr "type" "mvi")
 333    (set_attr "length" "4")])
 334
 335 (define_insn "movsi_high_pic"
 336   [(set (match_operand:SI 0 "register_operand" "=x")
 337         (high:SI (unspec:SI [(match_operand:SI 1 "" "")]
 338                             UNSPEC_MOVE_PIC)))]
 339   ""
 340   "%d0 = %1@GOT_LOW;"
 341   [(set_attr "type" "mvi")
 342    (set_attr "length" "4")])
 343
 344 (define_insn "movsi_low_pic"
 345   [(set (match_operand:SI 0 "register_operand" "=x")
 346         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
 347                    (unspec:SI [(match_operand:SI 2 "" "")]
 348                               UNSPEC_MOVE_PIC)))]
 349   ""
 350   "%h0 = %h2@GOT_HIGH;"
 351   [(set_attr "type" "mvi")
 352    (set_attr "length" "4")])
 353
 354 ;;; Move instructions
 355
 356 (define_insn_and_split "movdi_insn"
 357   [(set (match_operand:DI 0 "nonimmediate_operand" "=x,mx,r")
 358         (match_operand:DI 1 "general_operand" "iFx,r,mx"))]
 359   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 360   "#"
 361   "reload_completed"
 362   [(set (match_dup 2) (match_dup 3))
 363    (set (match_dup 4) (match_dup 5))]
 364 {
 365   rtx lo_half[2], hi_half[2];
 366   split_di (operands, 2, lo_half, hi_half);
 367
 368   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
 369     {
 370       operands[2] = hi_half[0];
 371       operands[3] = hi_half[1];
 372       operands[4] = lo_half[0];
 373       operands[5] = lo_half[1];
 374     }
 375   else
 376     {
 377       operands[2] = lo_half[0];
 378       operands[3] = lo_half[1];
 379       operands[4] = hi_half[0];
 380       operands[5] = hi_half[1];
 381     }
 382 })
 383
 384 (define_insn "movbi"
 385   [(set (match_operand:BI 0 "nonimmediate_operand" "=x,x,d,md,C,d,C")
 386         (match_operand:BI 1 "general_operand" "x,xKs3,md,d,d,C,P0"))]
 387
 388   ""
 389   "@
 390    %0 = %1;
 391    %0 = %1 (X);
 392    %0 = B %1 (Z);
 393    B %0 = %1;
 394    CC = %1;
 395    %0 = CC;
 396    R0 = R0 | R0; CC = AC0;"
 397   [(set_attr "type" "move,mvi,mcld,mcst,compare,compare,alu0")
 398    (set_attr "length" "2,2,*,*,2,2,4")
 399    (set_attr "seq_insns" "*,*,*,*,*,*,multi")])
 400
 401 (define_insn "movpdi"
 402   [(set (match_operand:PDI 0 "nonimmediate_operand" "=e,<,e")
 403         (match_operand:PDI 1 "general_operand" " e,e,>"))]
 404   ""
 405   "@
 406    %0 = %1;
 407    %0 = %x1; %0 = %w1;
 408    %w0 = %1; %x0 = %1;"
 409   [(set_attr "type" "move,mcst,mcld")
 410    (set_attr "seq_insns" "*,multi,multi")])
 411
 412 (define_insn "load_accumulator"
 413   [(set (match_operand:PDI 0 "register_operand" "=e")
 414         (sign_extend:PDI (match_operand:SI 1 "register_operand" "d")))]
 415   ""
 416   "%0 = %1;"
 417   [(set_attr "type" "move")])
 418
 419 (define_insn_and_split "load_accumulator_pair"
 420   [(set (match_operand:V2PDI 0 "register_operand" "=e")
 421         (sign_extend:V2PDI (vec_concat:V2SI
 422                             (match_operand:SI 1 "register_operand" "d")
 423                             (match_operand:SI 2 "register_operand" "d"))))]
 424   ""
 425   "#"
 426   "reload_completed"
 427   [(set (match_dup 3) (sign_extend:PDI (match_dup 1)))
 428    (set (match_dup 4) (sign_extend:PDI (match_dup 2)))]
 429 {
 430   operands[3] = gen_rtx_REG (PDImode, REGNO (operands[0]));
 431   operands[4] = gen_rtx_REG (PDImode, REGNO (operands[0]) + 1);
 432 })
 433
 434 (define_insn "*pushsi_insn"
 435   [(set (mem:SI (pre_dec:SI (reg:SI REG_SP)))
 436         (match_operand:SI 0 "register_operand" "xy"))]
 437   ""
 438   "[--SP] = %0;"
 439   [(set_attr "type" "mcst")
 440    (set_attr "length" "2")])
 441
 442 (define_insn "*popsi_insn"
 443   [(set (match_operand:SI 0 "register_operand" "=xy")
 444         (mem:SI (post_inc:SI (reg:SI REG_SP))))]
 445   ""
 446   "%0 = [SP++];"
 447   [(set_attr "type" "mcld")
 448    (set_attr "length" "2")])
 449
 450 ;; The first alternative is used to make reload choose a limited register
 451 ;; class when faced with a movsi_insn that had its input operand replaced
 452 ;; with a PLUS.  We generally require fewer secondary reloads this way.
 453
 454 (define_insn "*movsi_insn"
 455   [(set (match_operand:SI 0 "nonimmediate_operand" "=da,x*y,*k,da,da,x,x,x,da,mr")
 456         (match_operand:SI 1 "general_operand" "da,x*y,da,*k,xKs7,xKsh,xKuh,ix,mr,da"))]
 457   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 458  "@
 459    %0 = %1;
 460    %0 = %1;
 461    %0 = %1;
 462    %0 = %1;
 463    %0 = %1 (X);
 464    %0 = %1 (X);
 465    %0 = %1 (Z);
 466    #
 467    %0 = %1;
 468    %0 = %1;"
 469   [(set_attr "type" "move,move,move,move,mvi,mvi,mvi,*,mcld,mcst")
 470    (set_attr "length" "2,2,2,2,2,4,4,*,*,*")])
 471
 472 (define_insn_and_split "*movv2hi_insn"
 473   [(set (match_operand:V2HI 0 "nonimmediate_operand" "=da,da,d,dm")
 474         (match_operand:V2HI 1 "general_operand" "i,di,md,d"))]
 475
 476   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 477   "@
 478    #
 479    %0 = %1;
 480    %0 = %1;
 481    %0 = %1;"
 482   "reload_completed && GET_CODE (operands[1]) == CONST_VECTOR"
 483   [(set (match_dup 0) (high:SI (match_dup 2)))
 484    (set (match_dup 0) (lo_sum:SI (match_dup 0) (match_dup 3)))]
 485 {
 486   HOST_WIDE_INT intval = INTVAL (XVECEXP (operands[1], 0, 1)) << 16;
 487   intval |= INTVAL (XVECEXP (operands[1], 0, 0)) & 0xFFFF;
 488
 489   operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]));
 490   operands[2] = operands[3] = GEN_INT (trunc_int_for_mode (intval, SImode));
 491 }
 492   [(set_attr "type" "move,move,mcld,mcst")
 493    (set_attr "length" "2,2,*,*")])
 494
 495 (define_insn "*movhi_insn"
 496   [(set (match_operand:HI 0 "nonimmediate_operand" "=x,da,x,d,mr")
 497         (match_operand:HI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
 498   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 499 {
 500   static const char *templates[] = {
 501     "%0 = %1;",
 502     "%0 = %1 (X);",
 503     "%0 = %1 (X);",
 504     "%0 = W %1 (X);",
 505     "W %0 = %1;",
 506     "%h0 = W %1;",
 507     "W %0 = %h1;"
 508   };
 509   int alt = which_alternative;
 510   rtx mem = (MEM_P (operands[0]) ? operands[0]
 511              : MEM_P (operands[1]) ? operands[1] : NULL_RTX);
 512   if (mem && bfin_dsp_memref_p (mem))
 513     alt += 2;
 514   return templates[alt];
 515 }
 516   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
 517    (set_attr "length" "2,2,4,*,*")])
 518
 519 (define_insn "*movqi_insn"
 520   [(set (match_operand:QI 0 "nonimmediate_operand" "=x,da,x,d,mr")
 521         (match_operand:QI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
 522   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 523   "@
 524    %0 = %1;
 525    %0 = %1 (X);
 526    %0 = %1 (X);
 527    %0 = B %1 (X);
 528    B %0 = %1;"
 529   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
 530    (set_attr "length" "2,2,4,*,*")])
 531
 532 (define_insn "*movsf_insn"
 533   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,x,da,mr")
 534         (match_operand:SF 1 "general_operand" "x,Fx,mr,da"))]
 535   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 536   "@
 537    %0 = %1;
 538    #
 539    %0 = %1;
 540    %0 = %1;"
 541   [(set_attr "type" "move,*,mcld,mcst")])
 542
 543 (define_insn_and_split "movdf_insn"
 544   [(set (match_operand:DF 0 "nonimmediate_operand" "=x,mx,r")
 545         (match_operand:DF 1 "general_operand" "iFx,r,mx"))]
 546   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 547   "#"
 548   "reload_completed"
 549   [(set (match_dup 2) (match_dup 3))
 550    (set (match_dup 4) (match_dup 5))]
 551 {
 552   rtx lo_half[2], hi_half[2];
 553   split_di (operands, 2, lo_half, hi_half);
 554
 555   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
 556     {
 557       operands[2] = hi_half[0];
 558       operands[3] = hi_half[1];
 559       operands[4] = lo_half[0];
 560       operands[5] = lo_half[1];
 561     }
 562   else
 563     {
 564       operands[2] = lo_half[0];
 565       operands[3] = lo_half[1];
 566       operands[4] = hi_half[0];
 567       operands[5] = hi_half[1];
 568     }
 569 })
 570
 571 ;; Storing halfwords.
 572 (define_insn "*movsi_insv"
 573   [(set (zero_extract:SI (match_operand 0 "register_operand" "+d,x")
 574                          (const_int 16)
 575                          (const_int 16))
 576         (match_operand:SI 1 "nonmemory_operand" "d,n"))]
 577   ""
 578   "@
 579    %d0 = %h1 << 0;
 580    %d0 = %1;"
 581   [(set_attr "type" "dsp32,mvi")])
 582
 583 (define_expand "insv"
 584   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "")
 585                          (match_operand:SI 1 "immediate_operand" "")
 586                          (match_operand:SI 2 "immediate_operand" ""))
 587         (match_operand:SI 3 "nonmemory_operand" ""))]
 588   ""
 589 {
 590   if (INTVAL (operands[1]) != 16 || INTVAL (operands[2]) != 16)
 591     FAIL;
 592
 593   /* From mips.md: insert_bit_field doesn't verify that our source
 594      matches the predicate, so check it again here.  */
 595   if (! register_operand (operands[0], VOIDmode))
 596     FAIL;
 597 })
 598
 599 ;; This is the main "hook" for PIC code.  When generating
 600 ;; PIC, movsi is responsible for determining when the source address
 601 ;; needs PIC relocation and appropriately calling legitimize_pic_address
 602 ;; to perform the actual relocation.
 603
 604 (define_expand "movsi"
 605   [(set (match_operand:SI 0 "nonimmediate_operand" "")
 606         (match_operand:SI 1 "general_operand" ""))]
 607   ""
 608   "expand_move (operands, SImode);")
 609
 610 (define_expand "movv2hi"
 611   [(set (match_operand:V2HI 0 "nonimmediate_operand" "")
 612         (match_operand:V2HI 1 "general_operand" ""))]
 613   ""
 614   "expand_move (operands, V2HImode);")
 615
 616 (define_expand "movdi"
 617   [(set (match_operand:DI 0 "nonimmediate_operand" "")
 618         (match_operand:DI 1 "general_operand" ""))]
 619   ""
 620   "expand_move (operands, DImode);")
 621
 622 (define_expand "movsf"
 623  [(set (match_operand:SF 0 "nonimmediate_operand" "")
 624        (match_operand:SF 1 "general_operand" ""))]
 625   ""
 626   "expand_move (operands, SFmode);")
 627
 628 (define_expand "movdf"
 629  [(set (match_operand:DF 0 "nonimmediate_operand" "")
 630        (match_operand:DF 1 "general_operand" ""))]
 631   ""
 632   "expand_move (operands, DFmode);")
 633
 634 (define_expand "movhi"
 635   [(set (match_operand:HI 0 "nonimmediate_operand" "")
 636         (match_operand:HI 1 "general_operand" ""))]
 637   ""
 638   "expand_move (operands, HImode);")
 639
 640 (define_expand "movqi"
 641   [(set (match_operand:QI 0 "nonimmediate_operand" "")
 642         (match_operand:QI 1 "general_operand" ""))]
 643   ""
 644   " expand_move (operands, QImode); ")
 645
 646 ;; Some define_splits to break up SI/SFmode loads of immediate constants.
 647
 648 (define_split
 649   [(set (match_operand:SI 0 "register_operand" "")
 650         (match_operand:SI 1 "symbolic_or_const_operand" ""))]
 651   "reload_completed
 652    /* Always split symbolic operands; split integer constants that are
 653       too large for a single instruction.  */
 654    && (GET_CODE (operands[1]) != CONST_INT
 655        || (INTVAL (operands[1]) < -32768
 656            || INTVAL (operands[1]) >= 65536
 657            || (INTVAL (operands[1]) >= 32768 && PREG_P (operands[0]))))"
 658   [(set (match_dup 0) (high:SI (match_dup 1)))
 659    (set (match_dup 0) (lo_sum:SI (match_dup 0) (match_dup 1)))]
 660 {
 661   if (GET_CODE (operands[1]) == CONST_INT
 662       && split_load_immediate (operands))
 663     DONE;
 664   /* ??? Do something about TARGET_LOW_64K.  */
 665 })
 666
 667 (define_split
 668   [(set (match_operand:SF 0 "register_operand" "")
 669         (match_operand:SF 1 "immediate_operand" ""))]
 670   "reload_completed"
 671   [(set (match_dup 2) (high:SI (match_dup 3)))
 672    (set (match_dup 2) (lo_sum:SI (match_dup 2) (match_dup 3)))]
 673 {
 674   long values;
 675   REAL_VALUE_TYPE value;
 676
 677   gcc_assert (GET_CODE (operands[1]) == CONST_DOUBLE);
 678
 679   REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
 680   REAL_VALUE_TO_TARGET_SINGLE (value, values);
 681
 682   operands[2] = gen_rtx_REG (SImode, true_regnum (operands[0]));
 683   operands[3] = GEN_INT (trunc_int_for_mode (values, SImode));
 684   if (values >= -32768 && values < 65536)
 685     {
 686       emit_move_insn (operands[2], operands[3]);
 687       DONE;
 688     }
 689   if (split_load_immediate (operands + 2))
 690     DONE;
 691 })
 692
 693 ;; Sadly, this can't be a proper named movstrict pattern, since the compiler
 694 ;; expects to be able to use registers for operand 1.
 695 ;; Note that the asm instruction is defined by the manual to take an unsigned
 696 ;; constant, but it doesn't matter to the assembler, and the compiler only
 697 ;; deals with sign-extended constants.  Hence "Ksh".
 698 (define_insn "movstricthi_1"
 699   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+x"))
 700         (match_operand:HI 1 "immediate_operand" "Ksh"))]
 701   ""
 702   "%h0 = %1;"
 703   [(set_attr "type" "mvi")
 704    (set_attr "length" "4")])
 705
 706 ;; Sign and zero extensions
 707
 708 (define_insn_and_split "extendhisi2"
 709   [(set (match_operand:SI 0 "register_operand" "=d, d")
 710         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
 711   ""
 712   "@
 713    %0 = %h1 (X);
 714    %0 = W %h1 (X);"
 715   "reload_completed && bfin_dsp_memref_p (operands[1])"
 716   [(set (match_dup 2) (match_dup 1))
 717    (set (match_dup 0) (sign_extend:SI (match_dup 2)))]
 718 {
 719   operands[2] = gen_lowpart (HImode, operands[0]);
 720 }
 721   [(set_attr "type" "alu0,mcld")])
 722
 723 (define_insn_and_split "zero_extendhisi2"
 724   [(set (match_operand:SI 0 "register_operand" "=d, d")
 725         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
 726   ""
 727   "@
 728    %0 = %h1 (Z);
 729    %0 = W %h1 (Z);"
 730   "reload_completed && bfin_dsp_memref_p (operands[1])"
 731   [(set (match_dup 2) (match_dup 1))
 732    (set (match_dup 0) (zero_extend:SI (match_dup 2)))]
 733 {
 734   operands[2] = gen_lowpart (HImode, operands[0]);
 735 }
 736   [(set_attr "type" "alu0,mcld")])
 737
 738 (define_insn "zero_extendbisi2"
 739   [(set (match_operand:SI 0 "register_operand" "=d")
 740         (zero_extend:SI (match_operand:BI 1 "nonimmediate_operand" "C")))]
 741   ""
 742   "%0 = %1;"
 743   [(set_attr "type" "compare")])
 744
 745 (define_insn "extendqihi2"
 746   [(set (match_operand:HI 0 "register_operand" "=d, d")
 747         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 748   ""
 749   "@
 750    %0 = B %1 (X);
 751    %0 = %T1 (X);"
 752   [(set_attr "type" "mcld,alu0")])
 753
 754 (define_insn "extendqisi2"
 755   [(set (match_operand:SI 0 "register_operand" "=d, d")
 756         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 757   ""
 758   "@
 759    %0 = B %1 (X);
 760    %0 = %T1 (X);"
 761   [(set_attr "type" "mcld,alu0")])
 762
 763
 764 (define_insn "zero_extendqihi2"
 765   [(set (match_operand:HI 0 "register_operand" "=d, d")
 766         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 767   ""
 768   "@
 769    %0 = B %1 (Z);
 770    %0 = %T1 (Z);"
 771   [(set_attr "type" "mcld,alu0")])
 772
 773
 774 (define_insn "zero_extendqisi2"
 775   [(set (match_operand:SI 0 "register_operand" "=d, d")
 776         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 777   ""
 778   "@
 779    %0 = B %1 (Z);
 780    %0 = %T1 (Z);"
 781   [(set_attr "type" "mcld,alu0")])
 782
 783 ;; DImode logical operations
 784
 785 (define_code_macro any_logical [and ior xor])
 786 (define_code_attr optab [(and "and")
 787                          (ior "ior")
 788                          (xor "xor")])
 789 (define_code_attr op [(and "&")
 790                       (ior "|")
 791                       (xor "^")])
 792 (define_code_attr high_result [(and "0")
 793                                (ior "%H1")
 794                                (xor "%H1")])
 795
 796 (define_insn "<optab>di3"
 797   [(set (match_operand:DI 0 "register_operand" "=d")
 798         (any_logical:DI (match_operand:DI 1 "register_operand" "0")
 799                         (match_operand:DI 2 "register_operand" "d")))]
 800   ""
 801   "%0 = %1 <op> %2;\\n\\t%H0 = %H1 <op> %H2;"
 802   [(set_attr "length" "4")
 803    (set_attr "seq_insns" "multi")])
 804
 805 (define_insn "*<optab>di_zesidi_di"
 806   [(set (match_operand:DI 0 "register_operand" "=d")
 807         (any_logical:DI (zero_extend:DI
 808                          (match_operand:SI 2 "register_operand" "d"))
 809                         (match_operand:DI 1 "register_operand" "d")))]
 810   ""
 811   "%0 = %1 <op>  %2;\\n\\t%H0 = <high_result>;"
 812   [(set_attr "length" "4")
 813    (set_attr "seq_insns" "multi")])
 814
 815 (define_insn "*<optab>di_sesdi_di"
 816   [(set (match_operand:DI 0 "register_operand" "=d")
 817         (any_logical:DI (sign_extend:DI
 818                          (match_operand:SI 2 "register_operand" "d"))
 819                         (match_operand:DI 1 "register_operand" "0")))
 820    (clobber (match_scratch:SI 3 "=&d"))]
 821   ""
 822   "%0 = %1 <op> %2;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %H1 <op> %3;"
 823   [(set_attr "length" "8")
 824    (set_attr "seq_insns" "multi")])
 825
 826 (define_insn "negdi2"
 827   [(set (match_operand:DI 0 "register_operand" "=d")
 828         (neg:DI (match_operand:DI 1 "register_operand" "d")))
 829    (clobber (match_scratch:SI 2 "=&d"))
 830    (clobber (reg:CC REG_CC))]
 831   ""
 832   "%2 = 0; %2 = %2 - %1; cc = ac0; cc = !cc; %2 = cc;\\n\\t%0 = -%1; %H0 = -%H1; %H0 = %H0 - %2;"
 833   [(set_attr "length" "16")
 834    (set_attr "seq_insns" "multi")])
 835
 836 (define_insn "one_cmpldi2"
 837   [(set (match_operand:DI 0 "register_operand" "=d")
 838         (not:DI (match_operand:DI 1 "register_operand" "d")))]
 839   ""
 840   "%0 = ~%1;\\n\\t%H0 = ~%H1;"
 841   [(set_attr "length" "4")
 842    (set_attr "seq_insns" "multi")])
 843
 844 ;; DImode zero and sign extend patterns
 845
 846 (define_insn_and_split "zero_extendsidi2"
 847   [(set (match_operand:DI 0 "register_operand" "=d")
 848         (zero_extend:DI (match_operand:SI 1 "register_operand" "d")))]
 849   ""
 850   "#"
 851   "reload_completed"
 852   [(set (match_dup 3) (const_int 0))]
 853 {
 854   split_di (operands, 1, operands + 2, operands + 3);
 855   if (REGNO (operands[0]) != REGNO (operands[1]))
 856     emit_move_insn (operands[2], operands[1]);
 857 })
 858
 859 (define_insn "zero_extendqidi2"
 860   [(set (match_operand:DI 0 "register_operand" "=d")
 861         (zero_extend:DI (match_operand:QI 1 "register_operand" "d")))]
 862   ""
 863   "%0 = %T1 (Z);\\n\\t%H0 = 0;"
 864   [(set_attr "length" "4")
 865    (set_attr "seq_insns" "multi")])
 866
 867 (define_insn "zero_extendhidi2"
 868   [(set (match_operand:DI 0 "register_operand" "=d")
 869         (zero_extend:DI (match_operand:HI 1 "register_operand" "d")))]
 870   ""
 871   "%0 = %h1 (Z);\\n\\t%H0 = 0;"
 872   [(set_attr "length" "4")
 873    (set_attr "seq_insns" "multi")])
 874
 875 (define_insn_and_split "extendsidi2"
 876   [(set (match_operand:DI 0 "register_operand" "=d")
 877         (sign_extend:DI (match_operand:SI 1 "register_operand" "d")))]
 878   ""
 879   "#"
 880   "reload_completed"
 881   [(set (match_dup 3) (match_dup 1))
 882    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 883 {
 884   split_di (operands, 1, operands + 2, operands + 3);
 885   if (REGNO (operands[0]) != REGNO (operands[1]))
 886     emit_move_insn (operands[2], operands[1]);
 887 })
 888
 889 (define_insn_and_split "extendqidi2"
 890   [(set (match_operand:DI 0 "register_operand" "=d")
 891         (sign_extend:DI (match_operand:QI 1 "register_operand" "d")))]
 892   ""
 893   "#"
 894   "reload_completed"
 895   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
 896    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
 897    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 898 {
 899   split_di (operands, 1, operands + 2, operands + 3);
 900 })
 901
 902 (define_insn_and_split "extendhidi2"
 903   [(set (match_operand:DI 0 "register_operand" "=d")
 904         (sign_extend:DI (match_operand:HI 1 "register_operand" "d")))]
 905   ""
 906   "#"
 907   "reload_completed"
 908   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
 909    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
 910    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 911 {
 912   split_di (operands, 1, operands + 2, operands + 3);
 913 })
 914
 915 ;; DImode arithmetic operations
 916
 917 (define_insn "adddi3"
 918   [(set (match_operand:DI 0 "register_operand" "=&d,&d,&d")
 919         (plus:DI (match_operand:DI 1 "register_operand" "%0,0,0")
 920                  (match_operand:DI 2 "nonmemory_operand" "Kn7,Ks7,d")))
 921    (clobber (match_scratch:SI 3 "=&d,&d,&d"))
 922    (clobber (reg:CC 34))]
 923   ""
 924   "@
 925    %0 += %2; cc = ac0; %3 = cc; %H0 += -1; %H0 = %H0 + %3;
 926    %0 += %2; cc = ac0; %3 = cc; %H0 = %H0 + %3;
 927    %0 = %0 + %2; cc = ac0; %3 = cc; %H0 = %H0 + %H2; %H0 = %H0 + %3;"
 928   [(set_attr "type" "alu0")
 929    (set_attr "length" "10,8,10")
 930    (set_attr "seq_insns" "multi,multi,multi")])
 931
 932 (define_insn "subdi3"
 933   [(set (match_operand:DI 0 "register_operand" "=&d")
 934         (minus:DI (match_operand:DI 1 "register_operand" "0")
 935                   (match_operand:DI 2 "register_operand" "d")))
 936    (clobber (reg:CC 34))]
 937   ""
 938   "%0 = %1-%2;\\n\\tcc = ac0;\\n\\t%H0 = %H1-%H2;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
 939   [(set_attr "length" "10")
 940    (set_attr "seq_insns" "multi")])
 941
 942 (define_insn "*subdi_di_zesidi"
 943   [(set (match_operand:DI 0 "register_operand" "=d")
 944         (minus:DI (match_operand:DI 1 "register_operand" "0")
 945                   (zero_extend:DI
 946                   (match_operand:SI 2 "register_operand" "d"))))
 947    (clobber (match_scratch:SI 3 "=&d"))
 948    (clobber (reg:CC 34))]
 949   ""
 950   "%0 = %1 - %2;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%H0 = %H1 - %3;"
 951   [(set_attr "length" "10")
 952    (set_attr "seq_insns" "multi")])
 953
 954 (define_insn "*subdi_zesidi_di"
 955   [(set (match_operand:DI 0 "register_operand" "=d")
 956         (minus:DI (zero_extend:DI
 957                   (match_operand:SI 2 "register_operand" "d"))
 958                   (match_operand:DI 1 "register_operand" "0")))
 959    (clobber (match_scratch:SI 3 "=&d"))
 960    (clobber (reg:CC 34))]
 961   ""
 962   "%0 = %2 - %1;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%3 = -%3;\\n\\t%H0 = %3 - %H1"
 963   [(set_attr "length" "12")
 964    (set_attr "seq_insns" "multi")])
 965
 966 (define_insn "*subdi_di_sesidi"
 967   [(set (match_operand:DI 0 "register_operand" "=d")
 968         (minus:DI (match_operand:DI 1 "register_operand" "0")
 969                   (sign_extend:DI
 970                   (match_operand:SI 2 "register_operand" "d"))))
 971    (clobber (match_scratch:SI 3 "=&d"))
 972    (clobber (reg:CC 34))]
 973   ""
 974   "%0 = %1 - %2;\\n\\tcc = ac0;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %H1 - %3;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
 975   [(set_attr "length" "14")
 976    (set_attr "seq_insns" "multi")])
 977
 978 (define_insn "*subdi_sesidi_di"
 979   [(set (match_operand:DI 0 "register_operand" "=d")
 980         (minus:DI (sign_extend:DI
 981                   (match_operand:SI 2 "register_operand" "d"))
 982                   (match_operand:DI 1 "register_operand" "0")))
 983    (clobber (match_scratch:SI 3 "=&d"))
 984    (clobber (reg:CC 34))]
 985   ""
 986   "%0 = %2 - %1;\\n\\tcc = ac0;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %3 - %H1;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
 987   [(set_attr "length" "14")
 988    (set_attr "seq_insns" "multi")])
 989
 990 ;; Combined shift/add instructions
 991
 992 (define_insn ""
 993   [(set (match_operand:SI 0 "register_operand" "=a,d")
 994         (ashift:SI (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
 995                             (match_operand:SI 2 "register_operand" "a,d"))
 996                    (match_operand:SI 3 "pos_scale_operand" "P1P2,P1P2")))]
 997   ""
 998   "%0 = (%0 + %2) << %3;" /* "shadd %0,%2,%3;" */
 999   [(set_attr "type" "alu0")])
1000
1001 (define_insn ""
1002   [(set (match_operand:SI 0 "register_operand" "=a")
1003         (plus:SI (match_operand:SI 1 "register_operand" "a")
1004                  (mult:SI (match_operand:SI 2 "register_operand" "a")
1005                           (match_operand:SI 3 "scale_by_operand" "i"))))]
1006   ""
1007   "%0 = %1 + (%2 << %X3);"
1008   [(set_attr "type" "alu0")])
1009
1010 (define_insn ""
1011   [(set (match_operand:SI 0 "register_operand" "=a")
1012         (plus:SI (match_operand:SI 1 "register_operand" "a")
1013                  (ashift:SI (match_operand:SI 2 "register_operand" "a")
1014                             (match_operand:SI 3 "pos_scale_operand" "i"))))]
1015   ""
1016   "%0 = %1 + (%2 << %3);"
1017   [(set_attr "type" "alu0")])
1018
1019 (define_insn ""
1020   [(set (match_operand:SI 0 "register_operand" "=a")
1021         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "a")
1022                           (match_operand:SI 2 "scale_by_operand" "i"))
1023                  (match_operand:SI 3 "register_operand" "a")))]
1024   ""
1025   "%0 = %3 + (%1 << %X2);"
1026   [(set_attr "type" "alu0")])
1027
1028 (define_insn ""
1029   [(set (match_operand:SI 0 "register_operand" "=a")
1030         (plus:SI (ashift:SI (match_operand:SI 1 "register_operand" "a")
1031                             (match_operand:SI 2 "pos_scale_operand" "i"))
1032                  (match_operand:SI 3 "register_operand" "a")))]
1033   ""
1034   "%0 = %3 + (%1 << %2);"
1035   [(set_attr "type" "alu0")])
1036
1037 (define_insn "mulhisi3"
1038   [(set (match_operand:SI 0 "register_operand" "=d")
1039         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%d"))
1040                  (sign_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
1041   ""
1042   "%0 = %h1 * %h2 (IS);"
1043   [(set_attr "type" "dsp32")])
1044
1045 (define_insn "umulhisi3"
1046   [(set (match_operand:SI 0 "register_operand" "=d")
1047         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%d"))
1048                  (zero_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
1049   ""
1050   "%0 = %h1 * %h2 (FU);"
1051   [(set_attr "type" "dsp32")])
1052
1053 (define_insn "usmulhisi3"
1054   [(set (match_operand:SI 0 "register_operand" "=W")
1055         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "W"))
1056                  (sign_extend:SI (match_operand:HI 2 "register_operand" "W"))))]
1057   ""
1058   "%0 = %h2 * %h1 (IS,M);"
1059   [(set_attr "type" "dsp32")])
1060
1061 ;; The processor also supports ireg += mreg or ireg -= mreg, but these
1062 ;; are unusable if we don't ensure that the corresponding lreg is zero.
1063 ;; The same applies to the add/subtract constant versions involving
1064 ;; iregs
1065
1066 (define_insn "addsi3"
1067   [(set (match_operand:SI 0 "register_operand" "=ad,a,d")
1068         (plus:SI (match_operand:SI 1 "register_operand" "%0, a,d")
1069                  (match_operand:SI 2 "reg_or_7bit_operand" "Ks7, a,d")))]
1070   ""
1071   "@
1072    %0 += %2;
1073    %0 = %1 + %2;
1074    %0 = %1 + %2;"
1075   [(set_attr "type" "alu0")
1076    (set_attr "length" "2,2,2")])
1077
1078 (define_insn "ssaddsi3"
1079   [(set (match_operand:SI 0 "register_operand" "=d")
1080         (ss_plus:SI (match_operand:SI 1 "register_operand" "d")
1081                     (match_operand:SI 2 "register_operand" "d")))]
1082   ""
1083   "%0 = %1 + %2 (S);"
1084   [(set_attr "type" "dsp32")])
1085
1086 (define_expand "subsi3"
1087   [(set (match_operand:SI 0 "register_operand" "")
1088         (minus:SI (match_operand:SI 1 "register_operand" "")
1089                   (match_operand:SI 2 "reg_or_7bit_operand" "")))]
1090   ""
1091   "")
1092
1093 (define_insn ""
1094   [(set (match_operand:SI 0 "register_operand" "=da,d,a")
1095         (minus:SI (match_operand:SI 1 "register_operand" "0,d,0")
1096                   (match_operand:SI 2 "reg_or_7bit_operand" "Ks7,d,a")))]
1097   "GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != -64"
1098 {
1099   static const char *const strings_subsi3[] = {
1100     "%0 += -%2;",
1101     "%0 = %1 - %2;",
1102     "%0 -= %2;",
1103   };
1104
1105   if (CONSTANT_P (operands[2]) && INTVAL (operands[2]) < 0) {
1106      rtx tmp_op = operands[2];
1107      operands[2] = GEN_INT (-INTVAL (operands[2]));
1108      output_asm_insn ("%0 += %2;", operands);
1109      operands[2] = tmp_op;
1110      return "";
1111   }
1112
1113   return strings_subsi3[which_alternative];
1114 }
1115   [(set_attr "type" "alu0")])
1116
1117 (define_insn "sssubsi3"
1118   [(set (match_operand:SI 0 "register_operand" "=d")
1119         (ss_minus:SI (match_operand:SI 1 "register_operand" "d")
1120                      (match_operand:SI 2 "register_operand" "d")))]
1121   ""
1122   "%0 = %1 - %2 (S);"
1123   [(set_attr "type" "dsp32")])
1124
1125 ;; Bit test instructions
1126
1127 (define_insn "*not_bittst"
1128  [(set (match_operand:BI 0 "register_operand" "=C")
1129        (eq:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1130                                (const_int 1)
1131                                (match_operand:SI 2 "immediate_operand" "Ku5"))
1132               (const_int 0)))]
1133  ""
1134  "cc = !BITTST (%1,%2);"
1135   [(set_attr "type" "alu0")])
1136
1137 (define_insn "*bittst"
1138  [(set (match_operand:BI 0 "register_operand" "=C")
1139        (ne:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1140                                (const_int 1)
1141                                (match_operand:SI 2 "immediate_operand" "Ku5"))
1142                 (const_int 0)))]
1143  ""
1144  "cc = BITTST (%1,%2);"
1145   [(set_attr "type" "alu0")])
1146
1147 (define_insn_and_split "*bit_extract"
1148   [(set (match_operand:SI 0 "register_operand" "=d")
1149         (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
1150                          (const_int 1)
1151                          (match_operand:SI 2 "immediate_operand" "Ku5")))
1152    (clobber (reg:BI REG_CC))]
1153   ""
1154   "#"
1155   ""
1156   [(set (reg:BI REG_CC)
1157         (ne:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1158                (const_int 0)))
1159    (set (match_dup 0)
1160         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1161
1162 (define_insn_and_split "*not_bit_extract"
1163   [(set (match_operand:SI 0 "register_operand" "=d")
1164         (zero_extract:SI (not:SI (match_operand:SI 1 "register_operand" "d"))
1165                          (const_int 1)
1166                          (match_operand:SI 2 "immediate_operand" "Ku5")))
1167    (clobber (reg:BI REG_CC))]
1168   ""
1169   "#"
1170   ""
1171   [(set (reg:BI REG_CC)
1172         (eq:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1173                (const_int 0)))
1174    (set (match_dup 0)
1175         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1176
1177 (define_insn "*andsi_insn"
1178   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
1179         (and:SI (match_operand:SI 1 "register_operand" "%0,d,d,d")
1180                 (match_operand:SI 2 "rhs_andsi3_operand" "L,M1,M2,d")))]
1181   ""
1182   "@
1183    BITCLR (%0,%Y2);
1184    %0 = %T1 (Z);
1185    %0 = %h1 (Z);
1186    %0 = %1 & %2;"
1187   [(set_attr "type" "alu0")])
1188
1189 (define_expand "andsi3"
1190   [(set (match_operand:SI 0 "register_operand" "")
1191         (and:SI (match_operand:SI 1 "register_operand" "")
1192                 (match_operand:SI 2 "general_operand" "")))]
1193   ""
1194 {
1195   if (highbits_operand (operands[2], SImode))
1196     {
1197       operands[2] = GEN_INT (exact_log2 (-INTVAL (operands[2])));
1198       emit_insn (gen_ashrsi3 (operands[0], operands[1], operands[2]));
1199       emit_insn (gen_ashlsi3 (operands[0], operands[0], operands[2]));
1200       DONE;
1201     }
1202   if (! rhs_andsi3_operand (operands[2], SImode))
1203     operands[2] = force_reg (SImode, operands[2]);
1204 })
1205
1206 (define_insn "iorsi3"
1207   [(set (match_operand:SI 0 "register_operand" "=d,d")
1208         (ior:SI (match_operand:SI 1 "register_operand" "%0,d")
1209                 (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1210   ""
1211   "@
1212    BITSET (%0, %X2);
1213    %0 = %1 | %2;"
1214   [(set_attr "type" "alu0")])
1215
1216 (define_insn "xorsi3"
1217   [(set (match_operand:SI 0 "register_operand" "=d,d")
1218         (xor:SI (match_operand:SI 1 "register_operand" "%0,d")
1219                   (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1220   ""
1221   "@
1222    BITTGL (%0, %X2);
1223    %0 = %1 ^ %2;"
1224   [(set_attr "type" "alu0")])
1225
1226 (define_insn "smaxsi3"
1227   [(set (match_operand:SI 0 "register_operand" "=d")
1228         (smax:SI (match_operand:SI 1 "register_operand" "d")
1229                  (match_operand:SI 2 "register_operand" "d")))]
1230   ""
1231   "%0 = max(%1,%2);"
1232   [(set_attr "type" "dsp32")])
1233
1234 (define_insn "sminsi3"
1235   [(set (match_operand:SI 0 "register_operand" "=d")
1236         (smin:SI (match_operand:SI 1 "register_operand" "d")
1237                  (match_operand:SI 2 "register_operand" "d")))]
1238   ""
1239   "%0 = min(%1,%2);"
1240   [(set_attr "type" "dsp32")])
1241
1242 (define_insn "abssi2"
1243   [(set (match_operand:SI 0 "register_operand" "=d")
1244         (abs:SI (match_operand:SI 1 "register_operand" "d")))]
1245   ""
1246   "%0 = abs %1;"
1247   [(set_attr "type" "dsp32")])
1248
1249 (define_insn "negsi2"
1250   [(set (match_operand:SI 0 "register_operand" "=d")
1251         (neg:SI (match_operand:SI 1 "register_operand" "d")))]
1252   ""
1253   "%0 = -%1;"
1254   [(set_attr "type" "alu0")])
1255
1256 (define_insn "ssnegsi2"
1257   [(set (match_operand:SI 0 "register_operand" "=d")
1258         (ss_neg:SI (match_operand:SI 1 "register_operand" "d")))]
1259   ""
1260   "%0 = -%1 (S);"
1261   [(set_attr "type" "dsp32")])
1262
1263 (define_insn "one_cmplsi2"
1264   [(set (match_operand:SI 0 "register_operand" "=d")
1265         (not:SI (match_operand:SI 1 "register_operand" "d")))]
1266   ""
1267   "%0 = ~%1;"
1268   [(set_attr "type" "alu0")])
1269
1270 (define_insn "signbitssi2"
1271   [(set (match_operand:HI 0 "register_operand" "=d")
1272         (if_then_else:HI
1273          (lt (match_operand:SI 1 "register_operand" "d") (const_int 0))
1274          (clz:HI (not:SI (match_dup 1)))
1275          (clz:HI (match_dup 1))))]
1276   ""
1277   "%h0 = signbits %1;"
1278   [(set_attr "type" "dsp32")])
1279
1280 (define_insn "smaxhi3"
1281   [(set (match_operand:HI 0 "register_operand" "=d")
1282         (smax:HI (match_operand:HI 1 "register_operand" "d")
1283                  (match_operand:HI 2 "register_operand" "d")))]
1284   ""
1285   "%0 = max(%1,%2) (V);"
1286   [(set_attr "type" "dsp32")])
1287
1288 (define_insn "sminhi3"
1289   [(set (match_operand:HI 0 "register_operand" "=d")
1290         (smin:HI (match_operand:HI 1 "register_operand" "d")
1291                  (match_operand:HI 2 "register_operand" "d")))]
1292   ""
1293   "%0 = min(%1,%2) (V);"
1294   [(set_attr "type" "dsp32")])
1295
1296 (define_insn "abshi2"
1297   [(set (match_operand:HI 0 "register_operand" "=d")
1298         (abs:HI (match_operand:HI 1 "register_operand" "d")))]
1299   ""
1300   "%0 = abs %1 (V);"
1301   [(set_attr "type" "dsp32")])
1302
1303 (define_insn "neghi2"
1304   [(set (match_operand:HI 0 "register_operand" "=d")
1305         (neg:HI (match_operand:HI 1 "register_operand" "d")))]
1306   ""
1307   "%0 = -%1;"
1308   [(set_attr "type" "dsp32")])
1309
1310 (define_insn "ssneghi2"
1311   [(set (match_operand:HI 0 "register_operand" "=d")
1312         (ss_neg:HI (match_operand:HI 1 "register_operand" "d")))]
1313   ""
1314   "%0 = -%1 (V);"
1315   [(set_attr "type" "dsp32")])
1316
1317 (define_insn "signbitshi2"
1318   [(set (match_operand:HI 0 "register_operand" "=d")
1319         (if_then_else:HI
1320          (lt (match_operand:HI 1 "register_operand" "d") (const_int 0))
1321          (clz:HI (not:HI (match_dup 1)))
1322          (clz:HI (match_dup 1))))]
1323   ""
1324   "%h0 = signbits %h1;"
1325   [(set_attr "type" "dsp32")])
1326
1327 (define_insn "mulsi3"
1328   [(set (match_operand:SI 0 "register_operand" "=d")
1329         (mult:SI (match_operand:SI 1 "register_operand" "%0")
1330                  (match_operand:SI 2 "register_operand" "d")))]
1331   ""
1332   "%0 *= %2;"
1333   [(set_attr "type" "mult")])
1334
1335 (define_expand "ashlsi3"
1336   [(set (match_operand:SI 0 "register_operand" "")
1337         (ashift:SI (match_operand:SI 1 "register_operand" "")
1338                    (match_operand:SI 2 "nonmemory_operand" "")))]
1339   ""
1340 {
1341  if (GET_CODE (operands[2]) == CONST_INT
1342      && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1343    {
1344      emit_insn (gen_movsi (operands[0], const0_rtx));
1345      DONE;
1346    }
1347 })
1348
1349 (define_insn_and_split "*ashlsi3_insn"
1350   [(set (match_operand:SI 0 "register_operand" "=d,a,a,a")
1351         (ashift:SI (match_operand:SI 1 "register_operand" "0,a,a,a")
1352                    (match_operand:SI 2 "nonmemory_operand" "dKu5,P1,P2,?P3P4")))]
1353   ""
1354   "@
1355    %0 <<= %2;
1356    %0 = %1 + %1;
1357    %0 = %1 << %2;
1358    #"
1359   "PREG_P (operands[0]) && INTVAL (operands[2]) > 2"
1360   [(set (match_dup 0) (ashift:SI (match_dup 1) (const_int 2)))
1361    (set (match_dup 0) (ashift:SI (match_dup 0) (match_dup 3)))]
1362   "operands[3] = GEN_INT (INTVAL (operands[2]) - 2);"
1363   [(set_attr "type" "shft")])
1364
1365 (define_insn "ashrsi3"
1366   [(set (match_operand:SI 0 "register_operand" "=d")
1367         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
1368                      (match_operand:SI 2 "nonmemory_operand" "dKu5")))]
1369   ""
1370   "%0 >>>= %2;"
1371   [(set_attr "type" "shft")])
1372
1373 (define_insn "ror_one"
1374   [(set (match_operand:SI 0 "register_operand" "=d")
1375         (ior:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1376                 (ashift:SI (zero_extend:SI (reg:BI REG_CC)) (const_int 31))))
1377    (set (reg:BI REG_CC)
1378         (zero_extract:BI (match_dup 1) (const_int 1) (const_int 0)))]
1379   ""
1380   "%0 = ROT %1 BY -1;"
1381   [(set_attr "type" "shft")
1382    (set_attr "length" "4")])
1383
1384 (define_insn "rol_one"
1385   [(set (match_operand:SI 0 "register_operand" "+d")
1386         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1387                 (zero_extend:SI (reg:BI REG_CC))))
1388    (set (reg:BI REG_CC)
1389         (zero_extract:BI (match_dup 1) (const_int 31) (const_int 0)))]
1390   ""
1391   "%0 = ROT %1 BY 1;"
1392   [(set_attr "type" "shft")
1393    (set_attr "length" "4")])
1394
1395 (define_expand "lshrdi3"
1396   [(set (match_operand:DI 0 "register_operand" "")
1397         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
1398                      (match_operand:DI 2 "general_operand" "")))]
1399   ""
1400 {
1401   rtx lo_half[2], hi_half[2];
1402
1403   if (operands[2] != const1_rtx)
1404     FAIL;
1405   if (! rtx_equal_p (operands[0], operands[1]))
1406     emit_move_insn (operands[0], operands[1]);
1407
1408   split_di (operands, 2, lo_half, hi_half);
1409
1410   emit_move_insn (bfin_cc_rtx, const0_rtx);
1411   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1412   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1413   DONE;
1414 })
1415
1416 (define_expand "ashrdi3"
1417   [(set (match_operand:DI 0 "register_operand" "")
1418         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
1419                      (match_operand:DI 2 "general_operand" "")))]
1420   ""
1421 {
1422   rtx lo_half[2], hi_half[2];
1423
1424   if (operands[2] != const1_rtx)
1425     FAIL;
1426   if (! rtx_equal_p (operands[0], operands[1]))
1427     emit_move_insn (operands[0], operands[1]);
1428
1429   split_di (operands, 2, lo_half, hi_half);
1430
1431   emit_insn (gen_compare_lt (gen_rtx_REG (BImode, REG_CC),
1432                              hi_half[1], const0_rtx));
1433   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1434   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1435   DONE;
1436 })
1437
1438 (define_expand "ashldi3"
1439   [(set (match_operand:DI 0 "register_operand" "")
1440         (ashift:DI (match_operand:DI 1 "register_operand" "")
1441                    (match_operand:DI 2 "general_operand" "")))]
1442   ""
1443 {
1444   rtx lo_half[2], hi_half[2];
1445
1446   if (operands[2] != const1_rtx)
1447     FAIL;
1448   if (! rtx_equal_p (operands[0], operands[1]))
1449     emit_move_insn (operands[0], operands[1]);
1450
1451   split_di (operands, 2, lo_half, hi_half);
1452
1453   emit_move_insn (bfin_cc_rtx, const0_rtx);
1454   emit_insn (gen_rol_one (lo_half[0], lo_half[0]));
1455   emit_insn (gen_rol_one (hi_half[0], hi_half[0]));
1456   DONE;
1457 })
1458
1459 (define_insn "lshrsi3"
1460   [(set (match_operand:SI 0 "register_operand" "=d,a")
1461         (lshiftrt:SI (match_operand:SI 1 "register_operand" " 0,a")
1462                      (match_operand:SI 2 "nonmemory_operand" "dKu5,P1P2")))]
1463   ""
1464   "@
1465    %0 >>= %2;
1466    %0 = %1 >> %2;"
1467   [(set_attr "type" "shft")])
1468
1469 ;; A pattern to reload the equivalent of
1470 ;;   (set (Dreg) (plus (FP) (large_constant)))
1471 ;; or
1472 ;;   (set (dagreg) (plus (FP) (arbitrary_constant)))
1473 ;; using a scratch register
1474 (define_expand "reload_insi"
1475   [(parallel [(set (match_operand:SI 0 "register_operand" "=w")
1476                    (match_operand:SI 1 "fp_plus_const_operand" ""))
1477               (clobber (match_operand:SI 2 "register_operand" "=&a"))])]
1478   ""
1479 {
1480   rtx fp_op = XEXP (operands[1], 0);
1481   rtx const_op = XEXP (operands[1], 1);
1482   rtx primary = operands[0];
1483   rtx scratch = operands[2];
1484
1485   emit_move_insn (scratch, const_op);
1486   emit_insn (gen_addsi3 (scratch, scratch, fp_op));
1487   emit_move_insn (primary, scratch);
1488   DONE;
1489 })
1490
1491 ;; Jump instructions
1492
1493 (define_insn "jump"
1494   [(set (pc)
1495         (label_ref (match_operand 0 "" "")))]
1496   ""
1497 {
1498   if (get_attr_length (insn) == 2)
1499     return "jump.s %0;";
1500   else
1501     return "jump.l %0;";
1502 }
1503   [(set_attr "type" "br")])
1504
1505 (define_insn "indirect_jump"
1506   [(set (pc)
1507         (match_operand:SI 0 "register_operand" "a"))]
1508   ""
1509   "jump (%0);"
1510   [(set_attr "type" "misc")])
1511
1512 (define_expand "tablejump"
1513   [(parallel [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1514               (use (label_ref (match_operand 1 "" "")))])]
1515   ""
1516 {
1517   /* In PIC mode, the table entries are stored PC relative.
1518      Convert the relative address to an absolute address.  */
1519   if (flag_pic)
1520     {
1521       rtx op1 = gen_rtx_LABEL_REF (Pmode, operands[1]);
1522
1523       operands[0] = expand_simple_binop (Pmode, PLUS, operands[0],
1524                                          op1, NULL_RTX, 0, OPTAB_DIRECT);
1525     }
1526 })
1527
1528 (define_insn "*tablejump_internal"
1529   [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1530    (use (label_ref (match_operand 1 "" "")))]
1531   ""
1532   "jump (%0);"
1533   [(set_attr "type" "misc")])
1534
1535 ;;  Hardware loop
1536
1537 ; operand 0 is the loop count pseudo register
1538 ; operand 1 is the number of loop iterations or 0 if it is unknown
1539 ; operand 2 is the maximum number of loop iterations
1540 ; operand 3 is the number of levels of enclosed loops
1541 ; operand 4 is the label to jump to at the top of the loop
1542 (define_expand "doloop_end"
1543   [(parallel [(set (pc) (if_then_else
1544                           (ne (match_operand:SI 0 "" "")
1545                               (const_int 1))
1546                           (label_ref (match_operand 4 "" ""))
1547                           (pc)))
1548               (set (match_dup 0)
1549                    (plus:SI (match_dup 0)
1550                             (const_int -1)))
1551               (unspec [(const_int 0)] UNSPEC_LSETUP_END)
1552               (clobber (match_scratch:SI 5 ""))])]
1553   ""
1554   {bfin_hardware_loop ();})
1555
1556 (define_insn "loop_end"
1557   [(set (pc)
1558         (if_then_else (ne (match_operand:SI 0 "nonimmediate_operand" "+a*d,*b*h*f,m")
1559                           (const_int 1))
1560                       (label_ref (match_operand 1 "" ""))
1561                       (pc)))
1562    (set (match_dup 0)
1563         (plus (match_dup 0)
1564               (const_int -1)))
1565    (unspec [(const_int 0)] UNSPEC_LSETUP_END)
1566    (clobber (match_scratch:SI 2 "=X,&r,&r"))]
1567   ""
1568   "@
1569    /* loop end %0 %l1 */
1570    #
1571    #"
1572   [(set_attr "length" "6,10,14")])
1573
1574 (define_split
1575   [(set (pc)
1576         (if_then_else (ne (match_operand:SI 0 "nondp_reg_or_memory_operand" "")
1577                           (const_int 1))
1578                       (label_ref (match_operand 1 "" ""))
1579                       (pc)))
1580    (set (match_dup 0)
1581         (plus (match_dup 0)
1582               (const_int -1)))
1583    (unspec [(const_int 0)] UNSPEC_LSETUP_END)
1584    (clobber (match_scratch:SI 2 "=&r"))]
1585   "reload_completed"
1586   [(set (match_dup 2) (match_dup 0))
1587    (set (match_dup 2) (plus:SI (match_dup 2) (const_int -1)))
1588    (set (match_dup 0) (match_dup 2))
1589    (set (reg:BI REG_CC) (eq:BI (match_dup 2) (const_int 0)))
1590    (set (pc)
1591         (if_then_else (eq (reg:BI REG_CC)
1592                           (const_int 0))
1593                       (label_ref (match_dup 1))
1594                       (pc)))]
1595   "")
1596
1597 (define_insn "lsetup_with_autoinit"
1598   [(set (match_operand:SI 0 "lt_register_operand" "=t")
1599         (label_ref (match_operand 1 "" "")))
1600    (set (match_operand:SI 2 "lb_register_operand" "=l")
1601         (label_ref (match_operand 3 "" "")))
1602    (set (match_operand:SI 4 "lc_register_operand" "=k")
1603         (match_operand:SI 5 "register_operand" "a"))]
1604   ""
1605   "LSETUP (%1, %3) %4 = %5;"
1606   [(set_attr "length" "4")])
1607
1608 (define_insn "lsetup_without_autoinit"
1609   [(set (match_operand:SI 0 "lt_register_operand" "=t")
1610         (label_ref (match_operand 1 "" "")))
1611    (set (match_operand:SI 2 "lb_register_operand" "=l")
1612         (label_ref (match_operand 3 "" "")))
1613    (use (match_operand:SI 4 "lc_register_operand" "k"))]
1614   ""
1615   "LSETUP (%1, %3) %4;"
1616   [(set_attr "length" "4")])
1617
1618 ;;  Call instructions..
1619
1620 ;; The explicit MEM inside the UNSPEC prevents the compiler from moving
1621 ;; the load before a branch after a NULL test, or before a store that
1622 ;; initializes a function descriptor.
1623
1624 (define_insn_and_split "load_funcdescsi"
1625   [(set (match_operand:SI 0 "register_operand" "=a")
1626         (unspec_volatile:SI [(mem:SI (match_operand:SI 1 "address_operand" "p"))]
1627                             UNSPEC_VOLATILE_LOAD_FUNCDESC))]
1628   ""
1629   "#"
1630   "reload_completed"
1631   [(set (match_dup 0) (mem:SI (match_dup 1)))])
1632
1633 (define_expand "call"
1634   [(parallel [(call (match_operand:SI 0 "" "")
1635                     (match_operand 1 "" ""))
1636               (use (match_operand 2 "" ""))])]
1637   ""
1638 {
1639   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 0);
1640   DONE;
1641 })
1642
1643 (define_expand "sibcall"
1644   [(parallel [(call (match_operand:SI 0 "" "")
1645                     (match_operand 1 "" ""))
1646               (use (match_operand 2 "" ""))
1647               (return)])]
1648   ""
1649 {
1650   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 1);
1651   DONE;
1652 })
1653
1654 (define_expand "call_value"
1655   [(parallel [(set (match_operand 0 "register_operand" "")
1656                    (call (match_operand:SI 1 "" "")
1657                          (match_operand 2 "" "")))
1658               (use (match_operand 3 "" ""))])]
1659   ""
1660 {
1661   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 0);
1662   DONE;
1663 })
1664
1665 (define_expand "sibcall_value"
1666   [(parallel [(set (match_operand 0 "register_operand" "")
1667                    (call (match_operand:SI 1 "" "")
1668                          (match_operand 2 "" "")))
1669               (use (match_operand 3 "" ""))
1670               (return)])]
1671   ""
1672 {
1673   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 1);
1674   DONE;
1675 })
1676
1677 (define_insn "*call_symbol_fdpic"
1678   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1679          (match_operand 1 "general_operand" "g"))
1680    (use (match_operand:SI 2 "register_operand" "Z"))
1681    (use (match_operand 3 "" ""))]
1682   "! SIBLING_CALL_P (insn)
1683    && GET_CODE (operands[0]) == SYMBOL_REF
1684    && !bfin_longcall_p (operands[0], INTVAL (operands[3]))"
1685   "call %0;"
1686   [(set_attr "type" "call")
1687    (set_attr "length" "4")])
1688
1689 (define_insn "*sibcall_symbol_fdpic"
1690   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1691          (match_operand 1 "general_operand" "g"))
1692    (use (match_operand:SI 2 "register_operand" "Z"))
1693    (use (match_operand 3 "" ""))
1694    (return)]
1695   "SIBLING_CALL_P (insn)
1696    && GET_CODE (operands[0]) == SYMBOL_REF
1697    && !bfin_longcall_p (operands[0], INTVAL (operands[3]))"
1698   "jump.l %0;"
1699   [(set_attr "type" "br")
1700    (set_attr "length" "4")])
1701
1702 (define_insn "*call_value_symbol_fdpic"
1703   [(set (match_operand 0 "register_operand" "=d")
1704         (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1705               (match_operand 2 "general_operand" "g")))
1706    (use (match_operand:SI 3 "register_operand" "Z"))
1707    (use (match_operand 4 "" ""))]
1708   "! SIBLING_CALL_P (insn)
1709    && GET_CODE (operands[1]) == SYMBOL_REF
1710    && !bfin_longcall_p (operands[1], INTVAL (operands[4]))"
1711   "call %1;"
1712   [(set_attr "type" "call")
1713    (set_attr "length" "4")])
1714
1715 (define_insn "*sibcall_value_symbol_fdpic"
1716   [(set (match_operand 0 "register_operand" "=d")
1717          (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1718                (match_operand 2 "general_operand" "g")))
1719    (use (match_operand:SI 3 "register_operand" "Z"))
1720    (use (match_operand 4 "" ""))
1721    (return)]
1722   "SIBLING_CALL_P (insn)
1723    && GET_CODE (operands[1]) == SYMBOL_REF
1724    && !bfin_longcall_p (operands[1], INTVAL (operands[4]))"
1725   "jump.l %1;"
1726   [(set_attr "type" "br")
1727    (set_attr "length" "4")])
1728
1729 (define_insn "*call_insn_fdpic"
1730   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "Y"))
1731          (match_operand 1 "general_operand" "g"))
1732    (use (match_operand:SI 2 "register_operand" "Z"))
1733    (use (match_operand 3 "" ""))]
1734   "! SIBLING_CALL_P (insn)"
1735   "call (%0);"
1736   [(set_attr "type" "call")
1737    (set_attr "length" "2")])
1738
1739 (define_insn "*sibcall_insn_fdpic"
1740   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "Y"))
1741          (match_operand 1 "general_operand" "g"))
1742    (use (match_operand:SI 2 "register_operand" "Z"))
1743    (use (match_operand 3 "" ""))
1744    (return)]
1745   "SIBLING_CALL_P (insn)"
1746   "jump (%0);"
1747   [(set_attr "type" "br")
1748    (set_attr "length" "2")])
1749
1750 (define_insn "*call_value_insn_fdpic"
1751   [(set (match_operand 0 "register_operand" "=d")
1752         (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "Y"))
1753               (match_operand 2 "general_operand" "g")))
1754    (use (match_operand:SI 3 "register_operand" "Z"))
1755    (use (match_operand 4 "" ""))]
1756   "! SIBLING_CALL_P (insn)"
1757   "call (%1);"
1758   [(set_attr "type" "call")
1759    (set_attr "length" "2")])
1760
1761 (define_insn "*sibcall_value_insn_fdpic"
1762   [(set (match_operand 0 "register_operand" "=d")
1763          (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "Y"))
1764                (match_operand 2 "general_operand" "g")))
1765    (use (match_operand:SI 3 "register_operand" "Z"))
1766    (use (match_operand 4 "" ""))
1767    (return)]
1768   "SIBLING_CALL_P (insn)"
1769   "jump (%1);"
1770   [(set_attr "type" "br")
1771    (set_attr "length" "2")])
1772
1773 (define_insn "*call_symbol"
1774   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1775          (match_operand 1 "general_operand" "g"))
1776    (use (match_operand 2 "" ""))]
1777   "! SIBLING_CALL_P (insn)
1778    && !TARGET_ID_SHARED_LIBRARY
1779    && GET_CODE (operands[0]) == SYMBOL_REF
1780    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1781   "call %0;"
1782   [(set_attr "type" "call")
1783    (set_attr "length" "4")])
1784
1785 (define_insn "*sibcall_symbol"
1786   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1787          (match_operand 1 "general_operand" "g"))
1788    (use (match_operand 2 "" ""))
1789    (return)]
1790   "SIBLING_CALL_P (insn)
1791    && !TARGET_ID_SHARED_LIBRARY
1792    && GET_CODE (operands[0]) == SYMBOL_REF
1793    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1794   "jump.l %0;"
1795   [(set_attr "type" "br")
1796    (set_attr "length" "4")])
1797
1798 (define_insn "*call_value_symbol"
1799   [(set (match_operand 0 "register_operand" "=d")
1800         (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1801               (match_operand 2 "general_operand" "g")))
1802    (use (match_operand 3 "" ""))]
1803   "! SIBLING_CALL_P (insn)
1804    && !TARGET_ID_SHARED_LIBRARY
1805    && GET_CODE (operands[1]) == SYMBOL_REF
1806    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1807   "call %1;"
1808   [(set_attr "type" "call")
1809    (set_attr "length" "4")])
1810
1811 (define_insn "*sibcall_value_symbol"
1812   [(set (match_operand 0 "register_operand" "=d")
1813          (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1814                (match_operand 2 "general_operand" "g")))
1815    (use (match_operand 3 "" ""))
1816    (return)]
1817   "SIBLING_CALL_P (insn)
1818    && !TARGET_ID_SHARED_LIBRARY
1819    && GET_CODE (operands[1]) == SYMBOL_REF
1820    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1821   "jump.l %1;"
1822   [(set_attr "type" "br")
1823    (set_attr "length" "4")])
1824
1825 (define_insn "*call_insn"
1826   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "a"))
1827          (match_operand 1 "general_operand" "g"))
1828    (use (match_operand 2 "" ""))]
1829   "! SIBLING_CALL_P (insn)"
1830   "call (%0);"
1831   [(set_attr "type" "call")
1832    (set_attr "length" "2")])
1833
1834 (define_insn "*sibcall_insn"
1835   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "z"))
1836          (match_operand 1 "general_operand" "g"))
1837    (use (match_operand 2 "" ""))
1838    (return)]
1839   "SIBLING_CALL_P (insn)"
1840   "jump (%0);"
1841   [(set_attr "type" "br")
1842    (set_attr "length" "2")])
1843
1844 (define_insn "*call_value_insn"
1845   [(set (match_operand 0 "register_operand" "=d")
1846         (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "a"))
1847               (match_operand 2 "general_operand" "g")))
1848    (use (match_operand 3 "" ""))]
1849   "! SIBLING_CALL_P (insn)"
1850   "call (%1);"
1851   [(set_attr "type" "call")
1852    (set_attr "length" "2")])
1853
1854 (define_insn "*sibcall_value_insn"
1855   [(set (match_operand 0 "register_operand" "=d")
1856          (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "z"))
1857                (match_operand 2 "general_operand" "g")))
1858    (use (match_operand 3 "" ""))
1859    (return)]
1860   "SIBLING_CALL_P (insn)"
1861   "jump (%1);"
1862   [(set_attr "type" "br")
1863    (set_attr "length" "2")])
1864
1865 ;; Block move patterns
1866
1867 ;; We cheat.  This copies one more word than operand 2 indicates.
1868
1869 (define_insn "rep_movsi"
1870   [(set (match_operand:SI 0 "register_operand" "=&a")
1871         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1872                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1873                                      (const_int 2)))
1874                  (const_int 4)))
1875    (set (match_operand:SI 1 "register_operand" "=&b")
1876         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1877                           (ashift:SI (match_dup 2) (const_int 2)))
1878                  (const_int 4)))
1879    (set (mem:BLK (match_dup 3))
1880         (mem:BLK (match_dup 4)))
1881    (use (match_dup 2))
1882    (clobber (match_scratch:HI 5 "=&d"))
1883    (clobber (reg:SI REG_LT1))
1884    (clobber (reg:SI REG_LC1))
1885    (clobber (reg:SI REG_LB1))]
1886   ""
1887   "%5 = [%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || [%3++] = %5 || %5 = [%4++]; [%3++] = %5;"
1888   [(set_attr "type" "misc")
1889    (set_attr "length" "16")
1890    (set_attr "seq_insns" "multi")])
1891
1892 (define_insn "rep_movhi"
1893   [(set (match_operand:SI 0 "register_operand" "=&a")
1894         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1895                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1896                                      (const_int 1)))
1897                  (const_int 2)))
1898    (set (match_operand:SI 1 "register_operand" "=&b")
1899         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1900                           (ashift:SI (match_dup 2) (const_int 1)))
1901                  (const_int 2)))
1902    (set (mem:BLK (match_dup 3))
1903         (mem:BLK (match_dup 4)))
1904    (use (match_dup 2))
1905    (clobber (match_scratch:HI 5 "=&d"))
1906    (clobber (reg:SI REG_LT1))
1907    (clobber (reg:SI REG_LC1))
1908    (clobber (reg:SI REG_LB1))]
1909   ""
1910   "%h5 = W[%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || W [%3++] = %5 || %h5 = W [%4++]; W [%3++] = %5;"
1911   [(set_attr "type" "misc")
1912    (set_attr "length" "16")
1913    (set_attr "seq_insns" "multi")])
1914
1915 (define_expand "movmemsi"
1916   [(match_operand:BLK 0 "general_operand" "")
1917    (match_operand:BLK 1 "general_operand" "")
1918    (match_operand:SI 2 "const_int_operand" "")
1919    (match_operand:SI 3 "const_int_operand" "")]
1920   ""
1921 {
1922   if (bfin_expand_movmem (operands[0], operands[1], operands[2], operands[3]))
1923     DONE;
1924   FAIL;
1925 })
1926
1927 ;; Conditional branch patterns
1928 ;; The Blackfin has only few condition codes: eq, lt, lte, ltu, leu
1929
1930 ;; The only outcome of this pattern is that global variables
1931 ;; bfin_compare_op[01] are set for use in bcond patterns.
1932
1933 (define_expand "cmpbi"
1934  [(set (cc0) (compare (match_operand:BI 0 "register_operand" "")
1935                       (match_operand:BI 1 "immediate_operand" "")))]
1936  ""
1937 {
1938   bfin_compare_op0 = operands[0];
1939   bfin_compare_op1 = operands[1];
1940   DONE;
1941 })
1942
1943 (define_expand "cmpsi"
1944  [(set (cc0) (compare (match_operand:SI 0 "register_operand" "")
1945                       (match_operand:SI 1 "reg_or_const_int_operand" "")))]
1946  ""
1947 {
1948   bfin_compare_op0 = operands[0];
1949   bfin_compare_op1 = operands[1];
1950   DONE;
1951 })
1952
1953 (define_insn "compare_eq"
1954   [(set (match_operand:BI 0 "register_operand" "=C,C")
1955         (eq:BI (match_operand:SI 1 "register_operand" "d,a")
1956                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1957   ""
1958   "cc =%1==%2;"
1959   [(set_attr "type" "compare")])
1960
1961 (define_insn "compare_ne"
1962   [(set (match_operand:BI 0 "register_operand" "=C,C")
1963         (ne:BI (match_operand:SI 1 "register_operand" "d,a")
1964                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1965   "0"
1966   "cc =%1!=%2;"
1967   [(set_attr "type" "compare")])
1968
1969 (define_insn "compare_lt"
1970   [(set (match_operand:BI 0 "register_operand" "=C,C")
1971         (lt:BI (match_operand:SI 1 "register_operand" "d,a")
1972                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1973   ""
1974   "cc =%1<%2;"
1975   [(set_attr "type" "compare")])
1976
1977 (define_insn "compare_le"
1978   [(set (match_operand:BI 0 "register_operand" "=C,C")
1979         (le:BI (match_operand:SI 1 "register_operand" "d,a")
1980                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1981   ""
1982   "cc =%1<=%2;"
1983   [(set_attr "type" "compare")])
1984
1985 (define_insn "compare_leu"
1986   [(set (match_operand:BI 0 "register_operand" "=C,C")
1987         (leu:BI (match_operand:SI 1 "register_operand" "d,a")
1988                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1989   ""
1990   "cc =%1<=%2 (iu);"
1991   [(set_attr "type" "compare")])
1992
1993 (define_insn "compare_ltu"
1994   [(set (match_operand:BI 0 "register_operand" "=C,C")
1995         (ltu:BI (match_operand:SI 1 "register_operand" "d,a")
1996                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1997   ""
1998   "cc =%1<%2 (iu);"
1999   [(set_attr "type" "compare")])
2000
2001 (define_expand "beq"
2002   [(set (match_dup 1) (match_dup 2))
2003    (set (pc)
2004         (if_then_else (match_dup 3)
2005                    (label_ref (match_operand 0 "" ""))
2006                    (pc)))]
2007   ""
2008 {
2009   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
2010   operands[1] = bfin_cc_rtx;    /* hard register: CC */
2011   operands[2] = gen_rtx_EQ (BImode, op0, op1);
2012   /* If we have a BImode input, then we already have a compare result, and
2013      do not need to emit another comparison.  */
2014   if (GET_MODE (bfin_compare_op0) == BImode)
2015     {
2016       gcc_assert (bfin_compare_op1 == const0_rtx);
2017       emit_insn (gen_cbranchbi4 (operands[2], op0, op1, operands[0]));
2018       DONE;
2019     }
2020
2021   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2022 })
2023
2024 (define_expand "bne"
2025   [(set (match_dup 1) (match_dup 2))
2026    (set (pc)
2027         (if_then_else (match_dup 3)
2028                       (label_ref (match_operand 0 "" ""))
2029                     (pc)))]
2030   ""
2031 {
2032   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
2033   /* If we have a BImode input, then we already have a compare result, and
2034      do not need to emit another comparison.  */
2035   if (GET_MODE (bfin_compare_op0) == BImode)
2036     {
2037       rtx cmp = gen_rtx_NE (BImode, op0, op1);
2038
2039       gcc_assert (bfin_compare_op1 == const0_rtx);
2040       emit_insn (gen_cbranchbi4 (cmp, op0, op1, operands[0]));
2041       DONE;
2042     }
2043
2044   operands[1] = bfin_cc_rtx;    /* hard register: CC */
2045   operands[2] = gen_rtx_EQ (BImode, op0, op1);
2046   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
2047 })
2048
2049 (define_expand "bgt"
2050   [(set (match_dup 1) (match_dup 2))
2051    (set (pc)
2052         (if_then_else (match_dup 3)
2053                       (label_ref (match_operand 0 "" ""))
2054                     (pc)))]
2055   ""
2056 {
2057   operands[1] = bfin_cc_rtx;
2058   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
2059   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
2060 })
2061
2062 (define_expand "bgtu"
2063   [(set (match_dup 1) (match_dup 2))
2064    (set (pc)
2065         (if_then_else (match_dup 3)
2066                       (label_ref (match_operand 0 "" ""))
2067                     (pc)))]
2068   ""
2069 {
2070   operands[1] = bfin_cc_rtx;
2071   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
2072   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
2073 })
2074
2075 (define_expand "blt"
2076   [(set (match_dup 1) (match_dup 2))
2077    (set (pc)
2078         (if_then_else (match_dup 3)
2079                       (label_ref (match_operand 0 "" ""))
2080                     (pc)))]
2081   ""
2082 {
2083   operands[1] = bfin_cc_rtx;
2084   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
2085   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2086 })
2087
2088 (define_expand "bltu"
2089   [(set (match_dup 1) (match_dup 2))
2090    (set (pc)
2091         (if_then_else (match_dup 3)
2092                       (label_ref (match_operand 0 "" ""))
2093                       (pc)))]
2094   ""
2095 {
2096   operands[1] = bfin_cc_rtx;
2097   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
2098   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2099 })
2100
2101
2102 (define_expand "bge"
2103   [(set (match_dup 1) (match_dup 2))
2104    (set (pc)
2105         (if_then_else (match_dup 3)
2106                       (label_ref (match_operand 0 "" ""))
2107                       (pc)))]
2108   ""
2109 {
2110   operands[1] = bfin_cc_rtx;
2111   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
2112   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
2113 })
2114
2115 (define_expand "bgeu"
2116   [(set (match_dup 1) (match_dup 2))
2117    (set (pc)
2118         (if_then_else (match_dup 3)
2119                       (label_ref (match_operand 0 "" ""))
2120                       (pc)))]
2121   ""
2122 {
2123   operands[1] = bfin_cc_rtx;
2124   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
2125   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
2126 })
2127
2128 (define_expand "ble"
2129   [(set (match_dup 1) (match_dup 2))
2130    (set (pc)
2131         (if_then_else (match_dup 3)
2132                       (label_ref (match_operand 0 "" ""))
2133                       (pc)))]
2134   ""
2135 {
2136   operands[1] = bfin_cc_rtx;
2137   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
2138   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2139 })
2140
2141 (define_expand "bleu"
2142   [(set (match_dup 1) (match_dup 2))
2143    (set (pc)
2144         (if_then_else (match_dup 3)
2145                       (label_ref (match_operand 0 "" ""))
2146                       (pc)))
2147   ]
2148   ""
2149 {
2150   operands[1] = bfin_cc_rtx;
2151   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
2152   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
2153 })
2154
2155 (define_insn "cbranchbi4"
2156   [(set (pc)
2157         (if_then_else
2158          (match_operator 0 "bfin_cbranch_operator"
2159                          [(match_operand:BI 1 "register_operand" "C")
2160                           (match_operand:BI 2 "immediate_operand" "P0")])
2161          (label_ref (match_operand 3 "" ""))
2162          (pc)))]
2163   ""
2164 {
2165   asm_conditional_branch (insn, operands, 0, 0);
2166   return "";
2167 }
2168   [(set_attr "type" "brcc")])
2169
2170 ;; Special cbranch patterns to deal with the speculative load problem - see
2171 ;; bfin_reorg for details.
2172
2173 (define_insn "cbranch_predicted_taken"
2174   [(set (pc)
2175         (if_then_else
2176          (match_operator 0 "bfin_cbranch_operator"
2177                          [(match_operand:BI 1 "register_operand" "C")
2178                           (match_operand:BI 2 "immediate_operand" "P0")])
2179          (label_ref (match_operand 3 "" ""))
2180          (pc)))
2181    (unspec [(const_int 0)] UNSPEC_CBRANCH_TAKEN)]
2182   ""
2183 {
2184   asm_conditional_branch (insn, operands, 0, 1);
2185   return "";
2186 }
2187   [(set_attr "type" "brcc")])
2188
2189 (define_insn "cbranch_with_nops"
2190   [(set (pc)
2191         (if_then_else
2192          (match_operator 0 "bfin_cbranch_operator"
2193                          [(match_operand:BI 1 "register_operand" "C")
2194                           (match_operand:BI 2 "immediate_operand" "P0")])
2195          (label_ref (match_operand 3 "" ""))
2196          (pc)))
2197    (unspec [(match_operand 4 "immediate_operand" "")] UNSPEC_CBRANCH_NOPS)]
2198   "reload_completed"
2199 {
2200   asm_conditional_branch (insn, operands, INTVAL (operands[4]), 0);
2201   return "";
2202 }
2203   [(set_attr "type" "brcc")
2204    (set_attr "length" "6")])
2205
2206 ;; setcc insns.  */
2207 (define_expand "seq"
2208   [(set (match_dup 1) (eq:BI (match_dup 2) (match_dup 3)))
2209    (set (match_operand:SI 0 "register_operand" "")
2210         (ne:SI (match_dup 1) (const_int 0)))]
2211   ""
2212 {
2213   operands[2] = bfin_compare_op0;
2214   operands[3] = bfin_compare_op1;
2215   operands[1] = bfin_cc_rtx;
2216 })
2217
2218 (define_expand "slt"
2219   [(set (match_dup 1) (lt:BI (match_dup 2) (match_dup 3)))
2220    (set (match_operand:SI 0 "register_operand" "")
2221         (ne:SI (match_dup 1) (const_int 0)))]
2222   ""
2223 {
2224    operands[2] = bfin_compare_op0;
2225    operands[3] = bfin_compare_op1;
2226    operands[1] = bfin_cc_rtx;
2227 })
2228
2229 (define_expand "sle"
2230   [(set (match_dup 1) (le:BI (match_dup 2) (match_dup 3)))
2231    (set (match_operand:SI 0 "register_operand" "")
2232         (ne:SI (match_dup 1) (const_int 0)))]
2233   ""
2234 {
2235    operands[2] = bfin_compare_op0;
2236    operands[3] = bfin_compare_op1;
2237    operands[1] = bfin_cc_rtx;
2238 })
2239
2240 (define_expand "sltu"
2241   [(set (match_dup 1) (ltu:BI (match_dup 2) (match_dup 3)))
2242    (set (match_operand:SI 0 "register_operand" "")
2243         (ne:SI (match_dup 1) (const_int 0)))]
2244   ""
2245 {
2246    operands[2] = bfin_compare_op0;
2247    operands[3] = bfin_compare_op1;
2248    operands[1] = bfin_cc_rtx;
2249 })
2250
2251 (define_expand "sleu"
2252   [(set (match_dup 1) (leu:BI (match_dup 2) (match_dup 3)))
2253    (set (match_operand:SI 0 "register_operand" "")
2254         (ne:SI (match_dup 1) (const_int 0)))]
2255   ""
2256 {
2257    operands[2] = bfin_compare_op0;
2258    operands[3] = bfin_compare_op1;
2259    operands[1] = bfin_cc_rtx;
2260 })
2261
2262 (define_insn "nop"
2263   [(const_int 0)]
2264   ""
2265   "nop;")
2266
2267 ;;;;;;;;;;;;;;;;;;;;   CC2dreg   ;;;;;;;;;;;;;;;;;;;;;;;;;
2268 (define_insn "movsibi"
2269   [(set (match_operand:BI 0 "register_operand" "=C")
2270         (ne:BI (match_operand:SI 1 "register_operand" "d")
2271                (const_int 0)))]
2272   ""
2273   "CC = %1;"
2274   [(set_attr "length" "2")])
2275
2276 (define_insn "movbisi"
2277   [(set (match_operand:SI 0 "register_operand" "=d")
2278         (ne:SI (match_operand:BI 1 "register_operand" "C")
2279                (const_int 0)))]
2280   ""
2281   "%0 = CC;"
2282   [(set_attr "length" "2")])
2283
2284 (define_insn ""
2285   [(set (match_operand:BI 0 "register_operand" "=C")
2286         (eq:BI (match_operand:BI 1 "register_operand" " 0")
2287                (const_int 0)))]
2288   ""
2289   "%0 = ! %0;"    /*  NOT CC;"  */
2290   [(set_attr "type" "compare")])
2291
2292 ;; Vector and DSP insns
2293
2294 (define_insn ""
2295   [(set (match_operand:SI 0 "register_operand" "=d")
2296         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2297                            (const_int 24))
2298                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2299                              (const_int 8))))]
2300   ""
2301   "%0 = ALIGN8(%1, %2);"
2302   [(set_attr "type" "dsp32")])
2303
2304 (define_insn ""
2305   [(set (match_operand:SI 0 "register_operand" "=d")
2306         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2307                            (const_int 16))
2308                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2309                              (const_int 16))))]
2310   ""
2311   "%0 = ALIGN16(%1, %2);"
2312   [(set_attr "type" "dsp32")])
2313
2314 (define_insn ""
2315   [(set (match_operand:SI 0 "register_operand" "=d")
2316         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
2317                            (const_int 8))
2318                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
2319                              (const_int 24))))]
2320   ""
2321   "%0 = ALIGN24(%1, %2);"
2322   [(set_attr "type" "dsp32")])
2323
2324 ;; Prologue and epilogue.
2325
2326 (define_expand "prologue"
2327   [(const_int 1)]
2328   ""
2329   "bfin_expand_prologue (); DONE;")
2330
2331 (define_expand "epilogue"
2332   [(const_int 1)]
2333   ""
2334   "bfin_expand_epilogue (1, 0); DONE;")
2335
2336 (define_expand "sibcall_epilogue"
2337   [(const_int 1)]
2338   ""
2339   "bfin_expand_epilogue (0, 0); DONE;")
2340
2341 (define_expand "eh_return"
2342   [(unspec_volatile [(match_operand:SI 0 "register_operand" "")]
2343                     UNSPEC_VOLATILE_EH_RETURN)]
2344   ""
2345 {
2346   emit_move_insn (EH_RETURN_HANDLER_RTX, operands[0]);
2347   emit_insn (gen_eh_return_internal ());
2348   emit_barrier ();
2349   DONE;
2350 })
2351
2352 (define_insn_and_split "eh_return_internal"
2353   [(unspec_volatile [(reg:SI REG_P2)] UNSPEC_VOLATILE_EH_RETURN)]
2354   ""
2355   "#"
2356   "reload_completed"
2357   [(const_int 1)]
2358   "bfin_expand_epilogue (1, 1); DONE;")
2359
2360 (define_insn "link"
2361   [(set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -4))) (reg:SI REG_RETS))
2362    (set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -8))) (reg:SI REG_FP))
2363    (set (reg:SI REG_FP)
2364         (plus:SI (reg:SI REG_SP) (const_int -8)))
2365    (set (reg:SI REG_SP)
2366         (plus:SI (reg:SI REG_SP) (match_operand:SI 0 "immediate_operand" "i")))]
2367   ""
2368   "LINK %Z0;"
2369   [(set_attr "length" "4")])
2370
2371 (define_insn "unlink"
2372   [(set (reg:SI REG_FP) (mem:SI (reg:SI REG_FP)))
2373    (set (reg:SI REG_RETS) (mem:SI (plus:SI (reg:SI REG_FP) (const_int 4))))
2374    (set (reg:SI REG_SP) (plus:SI (reg:SI REG_FP) (const_int 8)))]
2375   ""
2376   "UNLINK;"
2377   [(set_attr "length" "4")])
2378
2379 ;; This pattern is slightly clumsy.  The stack adjust must be the final SET in
2380 ;; the pattern, otherwise dwarf2out becomes very confused about which reg goes
2381 ;; where on the stack, since it goes through all elements of the parallel in
2382 ;; sequence.
2383 (define_insn "push_multiple"
2384   [(match_parallel 0 "push_multiple_operation"
2385     [(unspec [(match_operand:SI 1 "immediate_operand" "i")] UNSPEC_PUSH_MULTIPLE)])]
2386   ""
2387 {
2388   output_push_multiple (insn, operands);
2389   return "";
2390 })
2391
2392 (define_insn "pop_multiple"
2393   [(match_parallel 0 "pop_multiple_operation"
2394     [(set (reg:SI REG_SP)
2395           (plus:SI (reg:SI REG_SP) (match_operand:SI 1 "immediate_operand" "i")))])]
2396   ""
2397 {
2398   output_pop_multiple (insn, operands);
2399   return "";
2400 })
2401
2402 (define_insn "return_internal"
2403   [(return)
2404    (unspec [(match_operand 0 "immediate_operand" "i")] UNSPEC_RETURN)]
2405   "reload_completed"
2406 {
2407   switch (INTVAL (operands[0]))
2408     {
2409     case EXCPT_HANDLER:
2410       return "rtx;";
2411     case NMI_HANDLER:
2412       return "rtn;";
2413     case INTERRUPT_HANDLER:
2414       return "rti;";
2415     case SUBROUTINE:
2416       return "rts;";
2417     }
2418   gcc_unreachable ();
2419 })
2420
2421 (define_insn "csync"
2422   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_CSYNC)]
2423   ""
2424   "csync;"
2425   [(set_attr "type" "sync")])
2426
2427 (define_insn "ssync"
2428   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_SSYNC)]
2429   ""
2430   "ssync;"
2431   [(set_attr "type" "sync")])
2432
2433 (define_insn "trap"
2434   [(trap_if (const_int 1) (const_int 3))]
2435   ""
2436   "excpt 3;"
2437   [(set_attr "type" "misc")
2438    (set_attr "length" "2")])
2439
2440 (define_insn "trapifcc"
2441   [(trap_if (reg:BI REG_CC) (const_int 3))]
2442   ""
2443   "if !cc jump 4 (bp); excpt 3;"
2444   [(set_attr "type" "misc")
2445    (set_attr "length" "4")
2446    (set_attr "seq_insns" "multi")])
2447
2448 ;;; Vector instructions
2449
2450 ;; First, all sorts of move variants
2451
2452 (define_insn "movhi_low2high"
2453   [(set (match_operand:V2HI 0 "register_operand" "=d")
2454         (vec_concat:V2HI
2455          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2456                         (parallel [(const_int 0)]))
2457          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2458                         (parallel [(const_int 0)]))))]
2459   ""
2460   "%d0 = %h2 << 0;"
2461   [(set_attr "type" "dsp32")])
2462
2463 (define_insn "movhi_high2high"
2464   [(set (match_operand:V2HI 0 "register_operand" "=d")
2465         (vec_concat:V2HI
2466          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2467                         (parallel [(const_int 0)]))
2468          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2469                         (parallel [(const_int 1)]))))]
2470   ""
2471   "%d0 = %d2 << 0;"
2472   [(set_attr "type" "dsp32")])
2473
2474 (define_insn "movhi_low2low"
2475   [(set (match_operand:V2HI 0 "register_operand" "=d")
2476         (vec_concat:V2HI
2477          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2478                         (parallel [(const_int 0)]))
2479          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2480                         (parallel [(const_int 1)]))))]
2481   ""
2482   "%h0 = %h2 << 0;"
2483   [(set_attr "type" "dsp32")])
2484
2485 (define_insn "movhi_high2low"
2486   [(set (match_operand:V2HI 0 "register_operand" "=d")
2487         (vec_concat:V2HI
2488          (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2489                         (parallel [(const_int 1)]))
2490          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2491                         (parallel [(const_int 1)]))))]
2492   ""
2493   "%h0 = %d2 << 0;"
2494   [(set_attr "type" "dsp32")])
2495
2496 (define_insn "movhiv2hi_low"
2497   [(set (match_operand:V2HI 0 "register_operand" "=d")
2498         (vec_concat:V2HI
2499          (match_operand:HI 2 "register_operand" "d")
2500          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2501                         (parallel [(const_int 1)]))))]
2502   ""
2503   "%h0 = %h2 << 0;"
2504   [(set_attr "type" "dsp32")])
2505
2506 (define_insn "movhiv2hi_high"
2507   [(set (match_operand:V2HI 0 "register_operand" "=d")
2508         (vec_concat:V2HI
2509          (vec_select:HI (match_operand:V2HI 1 "register_operand" "0")
2510                         (parallel [(const_int 0)]))
2511          (match_operand:HI 2 "register_operand" "d")))]
2512   ""
2513   "%d0 = %h2 << 0;"
2514   [(set_attr "type" "dsp32")])
2515
2516 ;; No earlyclobber on alternative two since our sequence ought to be safe.
2517 ;; The order of operands is intentional to match the VDSP builtin (high word
2518 ;; is passed first).
2519 (define_insn_and_split "composev2hi"
2520   [(set (match_operand:V2HI 0 "register_operand" "=d,d")
2521         (vec_concat:V2HI (match_operand:HI 2 "register_operand" "0,d")
2522                          (match_operand:HI 1 "register_operand" "d,d")))]
2523   ""
2524   "@
2525    %d0 = %h2 << 0;
2526    #"
2527   "reload_completed"
2528   [(set (match_dup 0)
2529         (vec_concat:V2HI
2530          (vec_select:HI (match_dup 0) (parallel [(const_int 0)]))
2531          (match_dup 2)))
2532    (set (match_dup 0)
2533         (vec_concat:V2HI
2534          (match_dup 1)
2535          (vec_select:HI (match_dup 0) (parallel [(const_int 1)]))))]
2536   ""
2537   [(set_attr "type" "dsp32")])
2538
2539 ; Like composev2hi, but operating on elements of V2HI vectors.
2540 ; Useful on its own, and as a combiner bridge for the multiply and
2541 ; mac patterns.
2542 (define_insn "packv2hi"
2543   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d,d")
2544         (vec_concat:V2HI (vec_select:HI
2545                           (match_operand:V2HI 1 "register_operand" "d,d,d,d")
2546                           (parallel [(match_operand 3 "const01_operand" "P0,P1,P0,P1")]))
2547                          (vec_select:HI
2548                           (match_operand:V2HI 2 "register_operand" "d,d,d,d")
2549                           (parallel [(match_operand 4 "const01_operand" "P0,P0,P1,P1")]))))]
2550   ""
2551   "@
2552    %0 = PACK (%h2,%h1);
2553    %0 = PACK (%h2,%d1);
2554    %0 = PACK (%d2,%h1);
2555    %0 = PACK (%d2,%d1);"
2556   [(set_attr "type" "dsp32")])
2557
2558 (define_insn "movv2hi_hi"
2559   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
2560         (vec_select:HI (match_operand:V2HI 1 "register_operand" "0,d,d")
2561                        (parallel [(match_operand 2 "const01_operand" "P0,P0,P1")])))]
2562   ""
2563   "@
2564    /* optimized out */
2565    %h0 = %h1 << 0;
2566    %h0 = %d1 << 0;"
2567   [(set_attr "type" "dsp32")])
2568
2569 (define_expand "movv2hi_hi_low"
2570   [(set (match_operand:HI 0 "register_operand" "")
2571         (vec_select:HI (match_operand:V2HI 1 "register_operand" "")
2572                        (parallel [(const_int 0)])))]
2573   ""
2574   "")
2575
2576 (define_expand "movv2hi_hi_high"
2577   [(set (match_operand:HI 0 "register_operand" "")
2578         (vec_select:HI (match_operand:V2HI 1 "register_operand" "")
2579                        (parallel [(const_int 1)])))]
2580   ""
2581   "")
2582
2583 ;; Unusual arithmetic operations on 16 bit registers.
2584
2585 (define_insn "ssaddhi3"
2586   [(set (match_operand:HI 0 "register_operand" "=d")
2587         (ss_plus:HI (match_operand:HI 1 "register_operand" "d")
2588                     (match_operand:HI 2 "register_operand" "d")))]
2589   ""
2590   "%h0 = %h1 + %h2 (S);"
2591   [(set_attr "type" "dsp32")])
2592
2593 (define_insn "sssubhi3"
2594   [(set (match_operand:HI 0 "register_operand" "=d")
2595         (ss_minus:HI (match_operand:HI 1 "register_operand" "d")
2596                      (match_operand:HI 2 "register_operand" "d")))]
2597   ""
2598   "%h0 = %h1 - %h2 (S);"
2599   [(set_attr "type" "dsp32")])
2600
2601 ;; V2HI vector insns
2602
2603 (define_insn "addv2hi3"
2604   [(set (match_operand:V2HI 0 "register_operand" "=d")
2605         (plus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2606                    (match_operand:V2HI 2 "register_operand" "d")))]
2607   ""
2608   "%0 = %1 +|+ %2;"
2609   [(set_attr "type" "dsp32")])
2610
2611 (define_insn "ssaddv2hi3"
2612   [(set (match_operand:V2HI 0 "register_operand" "=d")
2613         (ss_plus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2614                       (match_operand:V2HI 2 "register_operand" "d")))]
2615   ""
2616   "%0 = %1 +|+ %2 (S);"
2617   [(set_attr "type" "dsp32")])
2618
2619 (define_insn "subv2hi3"
2620   [(set (match_operand:V2HI 0 "register_operand" "=d")
2621         (minus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2622                    (match_operand:V2HI 2 "register_operand" "d")))]
2623   ""
2624   "%0 = %1 -|- %2;"
2625   [(set_attr "type" "dsp32")])
2626
2627 (define_insn "sssubv2hi3"
2628   [(set (match_operand:V2HI 0 "register_operand" "=d")
2629         (ss_minus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2630                        (match_operand:V2HI 2 "register_operand" "d")))]
2631   ""
2632   "%0 = %1 -|- %2 (S);"
2633   [(set_attr "type" "dsp32")])
2634
2635 (define_insn "addsubv2hi3"
2636   [(set (match_operand:V2HI 0 "register_operand" "=d")
2637         (vec_concat:V2HI
2638          (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2639                                  (parallel [(const_int 0)]))
2640                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2641                                  (parallel [(const_int 0)])))
2642          (minus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2643                    (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2644   ""
2645   "%0 = %1 +|- %2;"
2646   [(set_attr "type" "dsp32")])
2647
2648 (define_insn "subaddv2hi3"
2649   [(set (match_operand:V2HI 0 "register_operand" "=d")
2650         (vec_concat:V2HI
2651          (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2652                                   (parallel [(const_int 0)]))
2653                    (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2654                                   (parallel [(const_int 0)])))
2655          (plus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2656                   (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2657   ""
2658   "%0 = %1 -|+ %2;"
2659   [(set_attr "type" "dsp32")])
2660
2661 (define_insn "ssaddsubv2hi3"
2662   [(set (match_operand:V2HI 0 "register_operand" "=d")
2663         (vec_concat:V2HI
2664          (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2665                                     (parallel [(const_int 0)]))
2666                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2667                                     (parallel [(const_int 0)])))
2668          (ss_minus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2669                       (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2670   ""
2671   "%0 = %1 +|- %2 (S);"
2672   [(set_attr "type" "dsp32")])
2673
2674 (define_insn "sssubaddv2hi3"
2675   [(set (match_operand:V2HI 0 "register_operand" "=d")
2676         (vec_concat:V2HI
2677          (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2678                                      (parallel [(const_int 0)]))
2679                       (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2680                                      (parallel [(const_int 0)])))
2681          (ss_plus:HI (vec_select:HI (match_dup 1) (parallel [(const_int 1)]))
2682                      (vec_select:HI (match_dup 2) (parallel [(const_int 1)])))))]
2683   ""
2684   "%0 = %1 -|+ %2 (S);"
2685   [(set_attr "type" "dsp32")])
2686
2687 (define_insn "sublohiv2hi3"
2688   [(set (match_operand:HI 0 "register_operand" "=d")
2689         (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2690                                  (parallel [(const_int 1)]))
2691                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2692                                  (parallel [(const_int 0)]))))]
2693   ""
2694   "%h0 = %d1 - %h2;"
2695   [(set_attr "type" "dsp32")])
2696
2697 (define_insn "subhilov2hi3"
2698   [(set (match_operand:HI 0 "register_operand" "=d")
2699         (minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2700                                  (parallel [(const_int 0)]))
2701                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2702                                  (parallel [(const_int 1)]))))]
2703   ""
2704   "%h0 = %h1 - %d2;"
2705   [(set_attr "type" "dsp32")])
2706
2707 (define_insn "sssublohiv2hi3"
2708   [(set (match_operand:HI 0 "register_operand" "=d")
2709         (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2710                                     (parallel [(const_int 1)]))
2711                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2712                                     (parallel [(const_int 0)]))))]
2713   ""
2714   "%h0 = %d1 - %h2 (S);"
2715   [(set_attr "type" "dsp32")])
2716
2717 (define_insn "sssubhilov2hi3"
2718   [(set (match_operand:HI 0 "register_operand" "=d")
2719         (ss_minus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2720                                     (parallel [(const_int 0)]))
2721                      (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2722                                     (parallel [(const_int 1)]))))]
2723   ""
2724   "%h0 = %h1 - %d2 (S);"
2725   [(set_attr "type" "dsp32")])
2726
2727 (define_insn "addlohiv2hi3"
2728   [(set (match_operand:HI 0 "register_operand" "=d")
2729         (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2730                                 (parallel [(const_int 1)]))
2731                  (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2732                                 (parallel [(const_int 0)]))))]
2733   ""
2734   "%h0 = %d1 + %h2;"
2735   [(set_attr "type" "dsp32")])
2736
2737 (define_insn "addhilov2hi3"
2738   [(set (match_operand:HI 0 "register_operand" "=d")
2739         (plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2740                                 (parallel [(const_int 0)]))
2741                  (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2742                                 (parallel [(const_int 1)]))))]
2743   ""
2744   "%h0 = %h1 + %d2;"
2745   [(set_attr "type" "dsp32")])
2746
2747 (define_insn "ssaddlohiv2hi3"
2748   [(set (match_operand:HI 0 "register_operand" "=d")
2749         (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2750                                    (parallel [(const_int 1)]))
2751                     (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2752                                    (parallel [(const_int 0)]))))]
2753   ""
2754   "%h0 = %d1 + %h2 (S);"
2755   [(set_attr "type" "dsp32")])
2756
2757 (define_insn "ssaddhilov2hi3"
2758   [(set (match_operand:HI 0 "register_operand" "=d")
2759         (ss_plus:HI (vec_select:HI (match_operand:V2HI 1 "register_operand" "d")
2760                                    (parallel [(const_int 0)]))
2761                     (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2762                                    (parallel [(const_int 1)]))))]
2763   ""
2764   "%h0 = %h1 + %d2 (S);"
2765   [(set_attr "type" "dsp32")])
2766
2767 (define_insn "sminv2hi3"
2768   [(set (match_operand:V2HI 0 "register_operand" "=d")
2769         (smin:V2HI (match_operand:V2HI 1 "register_operand" "d")
2770                    (match_operand:V2HI 2 "register_operand" "d")))]
2771   ""
2772   "%0 = MIN (%1, %2) (V);"
2773   [(set_attr "type" "dsp32")])
2774
2775 (define_insn "smaxv2hi3"
2776   [(set (match_operand:V2HI 0 "register_operand" "=d")
2777         (smax:V2HI (match_operand:V2HI 1 "register_operand" "d")
2778                    (match_operand:V2HI 2 "register_operand" "d")))]
2779   ""
2780   "%0 = MAX (%1, %2) (V);"
2781   [(set_attr "type" "dsp32")])
2782
2783 ;; Multiplications.
2784
2785 ;; The Blackfin allows a lot of different options, and we need many patterns to
2786 ;; cover most of the hardware's abilities.
2787 ;; There are a few simple patterns using MULT rtx codes, but most of them use
2788 ;; an unspec with a const_int operand that determines which flag to use in the
2789 ;; instruction.
2790 ;; There are variants for single and parallel multiplications.
2791 ;; There are variants which just use 16 bit lowparts as inputs, and variants
2792 ;; which allow the user to choose just which halves to use as input values.
2793 ;; There are variants which set D registers, variants which set accumulators,
2794 ;; variants which set both, some of them optionally using the accumulators as
2795 ;; inputs for multiply-accumulate operations.
2796
2797 (define_insn "flag_mulhi"
2798   [(set (match_operand:HI 0 "register_operand" "=d")
2799         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2800                     (match_operand:HI 2 "register_operand" "d")
2801                     (match_operand 3 "const_int_operand" "n")]
2802                    UNSPEC_MUL_WITH_FLAG))]
2803   ""
2804   "%h0 = %h1 * %h2 %M3;"
2805   [(set_attr "type" "dsp32")])
2806
2807 (define_insn "flag_mulhisi"
2808   [(set (match_operand:SI 0 "register_operand" "=d")
2809         (unspec:SI [(match_operand:HI 1 "register_operand" "d")
2810                     (match_operand:HI 2 "register_operand" "d")
2811                     (match_operand 3 "const_int_operand" "n")]
2812                    UNSPEC_MUL_WITH_FLAG))]
2813   ""
2814   "%0 = %h1 * %h2 %M3;"
2815   [(set_attr "type" "dsp32")])
2816
2817 (define_insn "flag_mulhisi_parts"
2818   [(set (match_operand:SI 0 "register_operand" "=d")
2819         (unspec:SI [(vec_select:HI
2820                      (match_operand:V2HI 1 "register_operand" "d")
2821                      (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2822                     (vec_select:HI
2823                      (match_operand:V2HI 2 "register_operand" "d")
2824                      (parallel [(match_operand 4 "const01_operand" "P0P1")]))
2825                     (match_operand 5 "const_int_operand" "n")]
2826                    UNSPEC_MUL_WITH_FLAG))]
2827   ""
2828 {
2829   const char *templates[] = {
2830     "%0 = %h1 * %h2 %M5;",
2831     "%0 = %d1 * %h2 %M5;",
2832     "%0 = %h1 * %d2 %M5;",
2833     "%0 = %d1 * %d2 %M5;" };
2834   int alt = INTVAL (operands[3]) + (INTVAL (operands[4]) << 1);
2835   return templates[alt];
2836 }
2837   [(set_attr "type" "dsp32")])
2838
2839 (define_insn "flag_machi"
2840   [(set (match_operand:HI 0 "register_operand" "=d")
2841         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2842                     (match_operand:HI 2 "register_operand" "d")
2843                     (match_operand 3 "register_operand" "A")
2844                     (match_operand 4 "const01_operand" "P0P1")
2845                     (match_operand 5 "const_int_operand" "n")]
2846                    UNSPEC_MAC_WITH_FLAG))
2847    (set (match_operand:PDI 6 "register_operand" "=A")
2848         (unspec:PDI [(match_dup 1) (match_dup 2) (match_dup 3)
2849                      (match_dup 4) (match_dup 5)]
2850                     UNSPEC_MAC_WITH_FLAG))]
2851   ""
2852   "%h0 = (A0 %b4 %h1 * %h2) %M6;"
2853   [(set_attr "type" "dsp32")])
2854
2855 (define_insn "flag_machi_acconly"
2856   [(set (match_operand:PDI 0 "register_operand" "=e")
2857         (unspec:PDI [(match_operand:HI 1 "register_operand" "d")
2858                      (match_operand:HI 2 "register_operand" "d")
2859                      (match_operand 3 "register_operand" "A")
2860                      (match_operand 4 "const01_operand" "P0P1")
2861                      (match_operand 5 "const_int_operand" "n")]
2862                     UNSPEC_MAC_WITH_FLAG))]
2863   ""
2864   "%0 %b4 %h1 * %h2 %M6;"
2865   [(set_attr "type" "dsp32")])
2866
2867 (define_insn "flag_macinithi"
2868   [(set (match_operand:HI 0 "register_operand" "=d")
2869         (unspec:HI [(match_operand:HI 1 "register_operand" "d")
2870                     (match_operand:HI 2 "register_operand" "d")
2871                     (match_operand 3 "const_int_operand" "n")]
2872                    UNSPEC_MAC_WITH_FLAG))
2873    (set (match_operand:PDI 4 "register_operand" "=A")
2874         (unspec:PDI [(match_dup 1) (match_dup 2) (match_dup 3)]
2875                     UNSPEC_MAC_WITH_FLAG))]
2876   ""
2877   "%h0 = (A0 = %h1 * %h2) %M3;"
2878   [(set_attr "type" "dsp32")])
2879
2880 (define_insn "flag_macinit1hi"
2881   [(set (match_operand:PDI 0 "register_operand" "=e")
2882         (unspec:PDI [(match_operand:HI 1 "register_operand" "d")
2883                      (match_operand:HI 2 "register_operand" "d")
2884                      (match_operand 3 "const_int_operand" "n")]
2885                     UNSPEC_MAC_WITH_FLAG))]
2886   ""
2887   "%0 = %h1 * %h2 %M3;"
2888   [(set_attr "type" "dsp32")])
2889
2890 (define_insn "mulv2hi3"
2891   [(set (match_operand:V2HI 0 "register_operand" "=d")
2892         (mult:V2HI (match_operand:V2HI 1 "register_operand" "d")
2893                    (match_operand:V2HI 2 "register_operand" "d")))]
2894   ""
2895   "%h0 = %h1 * %h2, %d0 = %d1 * %d2 (IS);"
2896   [(set_attr "type" "dsp32")])
2897
2898 (define_insn "flag_mulv2hi"
2899   [(set (match_operand:V2HI 0 "register_operand" "=d")
2900         (unspec:V2HI [(match_operand:V2HI 1 "register_operand" "d")
2901                       (match_operand:V2HI 2 "register_operand" "d")
2902                       (match_operand 3 "const_int_operand" "n")]
2903                      UNSPEC_MUL_WITH_FLAG))]
2904   ""
2905   "%h0 = %h1 * %h2, %d0 = %d1 * %d2 %M3;"
2906   [(set_attr "type" "dsp32")])
2907
2908 (define_insn "flag_mulv2hi_parts"
2909   [(set (match_operand:V2HI 0 "register_operand" "=d")
2910         (unspec:V2HI [(vec_concat:V2HI
2911                        (vec_select:HI
2912                         (match_operand:V2HI 1 "register_operand" "d")
2913                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2914                        (vec_select:HI
2915                         (match_dup 1)
2916                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2917                       (vec_concat:V2HI
2918                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2919                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2920                        (vec_select:HI (match_dup 2)
2921                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2922                       (match_operand 7 "const_int_operand" "n")]
2923                      UNSPEC_MUL_WITH_FLAG))]
2924   ""
2925 {
2926   const char *templates[] = {
2927     "%h0 = %h1 * %h2, %d0 = %h1 * %h2 %M7;",
2928     "%h0 = %d1 * %h2, %d0 = %h1 * %h2 %M7;",
2929     "%h0 = %h1 * %h2, %d0 = %d1 * %h2 %M7;",
2930     "%h0 = %d1 * %h2, %d0 = %d1 * %h2 %M7;",
2931     "%h0 = %h1 * %d2, %d0 = %h1 * %h2 %M7;",
2932     "%h0 = %d1 * %d2, %d0 = %h1 * %h2 %M7;",
2933     "%h0 = %h1 * %d2, %d0 = %d1 * %h2 %M7;",
2934     "%h0 = %d1 * %d2, %d0 = %d1 * %h2 %M7;",
2935     "%h0 = %h1 * %h2, %d0 = %h1 * %d2 %M7;",
2936     "%h0 = %d1 * %h2, %d0 = %h1 * %d2 %M7;",
2937     "%h0 = %h1 * %h2, %d0 = %d1 * %d2 %M7;",
2938     "%h0 = %d1 * %h2, %d0 = %d1 * %d2 %M7;",
2939     "%h0 = %h1 * %d2, %d0 = %h1 * %d2 %M7;",
2940     "%h0 = %d1 * %d2, %d0 = %h1 * %d2 %M7;",
2941     "%h0 = %h1 * %d2, %d0 = %d1 * %d2 %M7;",
2942     "%h0 = %d1 * %d2, %d0 = %d1 * %d2 %M7;" };
2943   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
2944              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
2945   return templates[alt];
2946 }
2947   [(set_attr "type" "dsp32")])
2948
2949 ;; A slightly complicated pattern.
2950 ;; Operand 0 is the halfword output; operand 11 is the accumulator output
2951 ;; Halfword inputs are operands 1 and 2; operands 3, 4, 5 and 6 specify which
2952 ;; parts of these 2x16 bit registers to use.
2953 ;; Operand 7 is the accumulator input.
2954 ;; Operands 8/9 specify whether low/high parts are mac (0) or msu (1)
2955 ;; Operand 10 is the macflag to be used.
2956 (define_insn "flag_macv2hi_parts"
2957   [(set (match_operand:V2HI 0 "register_operand" "=d")
2958         (unspec:V2HI [(vec_concat:V2HI
2959                        (vec_select:HI
2960                         (match_operand:V2HI 1 "register_operand" "d")
2961                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
2962                        (vec_select:HI
2963                         (match_dup 1)
2964                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
2965                       (vec_concat:V2HI
2966                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
2967                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
2968                        (vec_select:HI (match_dup 2)
2969                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
2970                       (match_operand:V2PDI 7 "register_operand" "e")
2971                       (match_operand 8 "const01_operand" "P0P1")
2972                       (match_operand 9 "const01_operand" "P0P1")
2973                       (match_operand 10 "const_int_operand" "n")]
2974                      UNSPEC_MAC_WITH_FLAG))
2975    (set (match_operand:V2PDI 11 "register_operand" "=e")
2976         (unspec:V2PDI [(vec_concat:V2HI
2977                         (vec_select:HI (match_dup 1) (parallel [(match_dup 3)]))
2978                         (vec_select:HI (match_dup 1) (parallel [(match_dup 4)])))
2979                        (vec_concat:V2HI
2980                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)]))
2981                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)])))
2982                        (match_dup 7) (match_dup 8) (match_dup 9) (match_dup 10)]
2983                       UNSPEC_MAC_WITH_FLAG))]
2984   ""
2985 {
2986   const char *templates[] = {
2987     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2988     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2989     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2990     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2991     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2992     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %h1 * %h2) %M10;",
2993     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2994     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %d1 * %h2) %M10;",
2995     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2996     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
2997     "%h0 = (A0 %b8 %h1 * %h2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
2998     "%h0 = (A0 %b8 %d1 * %h2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
2999     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
3000     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %h1 * %d2) %M10;",
3001     "%h0 = (A0 %b8 %h1 * %d2), %d0 = (A1 %b9 %d1 * %d2) %M10;",
3002     "%h0 = (A0 %b8 %d1 * %d2), %d0 = (A1 %b9 %d1 * %d2) %M10;" };
3003   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
3004              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
3005   return templates[alt];
3006 }
3007   [(set_attr "type" "dsp32")])
3008
3009 (define_insn "flag_macv2hi_parts_acconly"
3010   [(set (match_operand:V2PDI 0 "register_operand" "=e")
3011         (unspec:V2PDI [(vec_concat:V2HI
3012                         (vec_select:HI
3013                          (match_operand:V2HI 1 "register_operand" "d")
3014                          (parallel [(match_operand 3 "const01_operand" "P0P1")]))
3015                         (vec_select:HI
3016                          (match_dup 1)
3017                          (parallel [(match_operand 4 "const01_operand" "P0P1")])))
3018                        (vec_concat:V2HI
3019                         (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3020                                        (parallel [(match_operand 5 "const01_operand" "P0P1")]))
3021                         (vec_select:HI (match_dup 2)
3022                                        (parallel [(match_operand 6 "const01_operand" "P0P1")])))
3023                        (match_operand:V2PDI 7 "register_operand" "e")
3024                        (match_operand 8 "const01_operand" "P0P1")
3025                        (match_operand 9 "const01_operand" "P0P1")
3026                        (match_operand 10 "const_int_operand" "n")]
3027                       UNSPEC_MAC_WITH_FLAG))]
3028   ""
3029 {
3030   const char *templates[] = {
3031     "A0 %b8 %h1 * %h2, A1 %b9 %h1 * %h2 %M10;",
3032     "A0 %b8 %d1 * %h2, A1 %b9 %h1 * %h2 %M10;",
3033     "A0 %b8 %h1 * %h2, A1 %b9 %d1 * %h2 %M10;",
3034     "A0 %b8 %d1 * %h2, A1 %b9 %d1 * %h2 %M10;",
3035     "A0 %b8 %h1 * %d2, A1 %b9 %h1 * %h2 %M10;",
3036     "A0 %b8 %d1 * %d2, A1 %b9 %h1 * %h2 %M10;",
3037     "A0 %b8 %h1 * %d2, A1 %b9 %d1 * %h2 %M10;",
3038     "A0 %b8 %d1 * %d2, A1 %b9 %d1 * %h2 %M10;",
3039     "A0 %b8 %h1 * %h2, A1 %b9 %h1 * %d2 %M10;",
3040     "A0 %b8 %d1 * %h2, A1 %b9 %h1 * %d2 %M10;",
3041     "A0 %b8 %h1 * %h2, A1 %b9 %d1 * %d2 %M10;",
3042     "A0 %b8 %d1 * %h2, A1 %b9 %d1 * %d2 %M10;",
3043     "A0 %b8 %h1 * %d2, A1 %b9 %h1 * %d2 %M10;",
3044     "A0 %b8 %d1 * %d2, A1 %b9 %h1 * %d2 %M10;",
3045     "A0 %b8 %h1 * %d2, A1 %b9 %d1 * %d2 %M10;",
3046     "A0 %b8 %d1 * %d2, A1 %b9 %d1 * %d2 %M10;" };
3047   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
3048              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
3049   return templates[alt];
3050 }
3051   [(set_attr "type" "dsp32")])
3052
3053 ;; Same as above, but initializing the accumulators and therefore a couple fewer
3054 ;; necessary operands.
3055 (define_insn "flag_macinitv2hi_parts"
3056   [(set (match_operand:V2HI 0 "register_operand" "=d")
3057         (unspec:V2HI [(vec_concat:V2HI
3058                        (vec_select:HI
3059                         (match_operand:V2HI 1 "register_operand" "d")
3060                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
3061                        (vec_select:HI
3062                         (match_dup 1)
3063                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
3064                       (vec_concat:V2HI
3065                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3066                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
3067                        (vec_select:HI (match_dup 2)
3068                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
3069                       (match_operand 7 "const_int_operand" "n")]
3070                      UNSPEC_MAC_WITH_FLAG))
3071    (set (match_operand:V2PDI 8 "register_operand" "=e")
3072         (unspec:V2PDI [(vec_concat:V2HI
3073                         (vec_select:HI (match_dup 1) (parallel [(match_dup 3)]))
3074                         (vec_select:HI (match_dup 1) (parallel [(match_dup 4)])))
3075                        (vec_concat:V2HI
3076                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)]))
3077                         (vec_select:HI (match_dup 2) (parallel [(match_dup 5)])))
3078                        (match_dup 7)]
3079                       UNSPEC_MAC_WITH_FLAG))]
3080   ""
3081 {
3082   const char *templates[] = {
3083     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %h1 * %h2) %M7;",
3084     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %h1 * %h2) %M7;",
3085     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %d1 * %h2) %M7;",
3086     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %d1 * %h2) %M7;",
3087     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %h1 * %h2) %M7;",
3088     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %h1 * %h2) %M7;",
3089     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %d1 * %h2) %M7;",
3090     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %d1 * %h2) %M7;",
3091     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %h1 * %d2) %M7;",
3092     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %h1 * %d2) %M7;",
3093     "%h0 = (A0 = %h1 * %h2), %d0 = (A1 = %d1 * %d2) %M7;",
3094     "%h0 = (A0 = %d1 * %h2), %d0 = (A1 = %d1 * %d2) %M7;",
3095     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %h1 * %d2) %M7;",
3096     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %h1 * %d2) %M7;",
3097     "%h0 = (A0 = %h1 * %d2), %d0 = (A1 = %d1 * %d2) %M7;",
3098     "%h0 = (A0 = %d1 * %d2), %d0 = (A1 = %d1 * %d2) %M7;" };
3099   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
3100              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
3101   return templates[alt];
3102 }
3103   [(set_attr "type" "dsp32")])
3104
3105 (define_insn "flag_macinit1v2hi_parts"
3106   [(set (match_operand:V2PDI 0 "register_operand" "=e")
3107         (unspec:V2PDI [(vec_concat:V2HI
3108                        (vec_select:HI
3109                         (match_operand:V2HI 1 "register_operand" "d")
3110                         (parallel [(match_operand 3 "const01_operand" "P0P1")]))
3111                        (vec_select:HI
3112                         (match_dup 1)
3113                         (parallel [(match_operand 4 "const01_operand" "P0P1")])))
3114                       (vec_concat:V2HI
3115                        (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3116                         (parallel [(match_operand 5 "const01_operand" "P0P1")]))
3117                        (vec_select:HI (match_dup 2)
3118                         (parallel [(match_operand 6 "const01_operand" "P0P1")])))
3119                       (match_operand 7 "const_int_operand" "n")]
3120                      UNSPEC_MAC_WITH_FLAG))]
3121   ""
3122 {
3123   const char *templates[] = {
3124     "A0 = %h1 * %h2, A1 = %h1 * %h2 %M7;",
3125     "A0 = %d1 * %h2, A1 = %h1 * %h2 %M7;",
3126     "A0 = %h1 * %h2, A1 = %d1 * %h2 %M7;",
3127     "A0 = %d1 * %h2, A1 = %d1 * %h2 %M7;",
3128     "A0 = %h1 * %d2, A1 = %h1 * %h2 %M7;",
3129     "A0 = %d1 * %d2, A1 = %h1 * %h2 %M7;",
3130     "A0 = %h1 * %d2, A1 = %d1 * %h2 %M7;",
3131     "A0 = %d1 * %d2, A1 = %d1 * %h2 %M7;",
3132     "A0 = %h1 * %h2, A1 = %h1 * %d2 %M7;",
3133     "A0 = %d1 * %h2, A1 = %h1 * %d2 %M7;",
3134     "A0 = %h1 * %h2, A1 = %d1 * %d2 %M7;",
3135     "A0 = %d1 * %h2, A1 = %d1 * %d2 %M7;",
3136     "A0 = %h1 * %d2, A1 = %h1 * %d2 %M7;",
3137     "A0 = %d1 * %d2, A1 = %h1 * %d2 %M7;",
3138     "A0 = %h1 * %d2, A1 = %d1 * %d2 %M7;",
3139     "A0 = %d1 * %d2, A1 = %d1 * %d2 %M7;" };
3140   int alt = (INTVAL (operands[3]) + (INTVAL (operands[4]) << 1)
3141              + (INTVAL (operands[5]) << 2)  + (INTVAL (operands[6]) << 3));
3142   return templates[alt];
3143 }
3144   [(set_attr "type" "dsp32")])
3145
3146 (define_insn "mulhisi_ll"
3147   [(set (match_operand:SI 0 "register_operand" "=d")
3148         (mult:SI (sign_extend:SI
3149                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3150                                  (parallel [(const_int 0)])))
3151                  (sign_extend:SI
3152                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3153                                  (parallel [(const_int 0)])))))]
3154   ""
3155   "%0 = %h1 * %h2 (IS);"
3156   [(set_attr "type" "dsp32")])
3157
3158 (define_insn "mulhisi_lh"
3159   [(set (match_operand:SI 0 "register_operand" "=d")
3160         (mult:SI (sign_extend:SI
3161                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3162                                  (parallel [(const_int 0)])))
3163                  (sign_extend:SI
3164                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3165                                  (parallel [(const_int 1)])))))]
3166   ""
3167   "%0 = %h1 * %d2 (IS);"
3168   [(set_attr "type" "dsp32")])
3169
3170 (define_insn "mulhisi_hl"
3171   [(set (match_operand:SI 0 "register_operand" "=d")
3172         (mult:SI (sign_extend:SI
3173                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3174                                  (parallel [(const_int 1)])))
3175                  (sign_extend:SI
3176                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3177                                  (parallel [(const_int 0)])))))]
3178   ""
3179   "%0 = %d1 * %h2 (IS);"
3180   [(set_attr "type" "dsp32")])
3181
3182 (define_insn "mulhisi_hh"
3183   [(set (match_operand:SI 0 "register_operand" "=d")
3184         (mult:SI (sign_extend:SI
3185                   (vec_select:HI (match_operand:V2HI 1 "register_operand" "%d")
3186                                  (parallel [(const_int 1)])))
3187                  (sign_extend:SI
3188                   (vec_select:HI (match_operand:V2HI 2 "register_operand" "d")
3189                                  (parallel [(const_int 1)])))))]
3190   ""
3191   "%0 = %d1 * %d2 (IS);"
3192   [(set_attr "type" "dsp32")])
3193
3194 (define_insn "ssnegv2hi2"
3195   [(set (match_operand:V2HI 0 "register_operand" "=d")
3196         (ss_neg:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
3197   ""
3198   "%0 = - %1 (V);"
3199   [(set_attr "type" "dsp32")])
3200
3201 (define_insn "absv2hi2"
3202   [(set (match_operand:V2HI 0 "register_operand" "=d")
3203         (abs:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
3204   ""
3205   "%0 = ABS %1 (V);"
3206   [(set_attr "type" "dsp32")])
3207
3208 ;; Shifts.
3209
3210 (define_insn "ssashiftv2hi3"
3211   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d")
3212         (if_then_else:V2HI
3213          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3214          (ashiftrt:V2HI (match_operand:V2HI 1 "register_operand" "d,d,d")
3215                         (match_dup 2))
3216          (ss_ashift:V2HI (match_dup 1) (match_dup 2))))]
3217   ""
3218   "@
3219    %0 = ASHIFT %1 BY %2 (V, S);
3220    %0 = %1 >>> %2 (V,S);
3221    %0 = %1 << %2 (V,S);"
3222   [(set_attr "type" "dsp32")])
3223
3224 (define_insn "ssashifthi3"
3225   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
3226         (if_then_else:HI
3227          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3228          (ashiftrt:HI (match_operand:HI 1 "register_operand" "d,d,d")
3229                       (match_dup 2))
3230          (ss_ashift:HI (match_dup 1) (match_dup 2))))]
3231   ""
3232   "@
3233    %0 = ASHIFT %1 BY %2 (V, S);
3234    %0 = %1 >>> %2 (V,S);
3235    %0 = %1 << %2 (V,S);"
3236   [(set_attr "type" "dsp32")])
3237
3238 (define_insn "lshiftv2hi3"
3239   [(set (match_operand:V2HI 0 "register_operand" "=d,d,d")
3240         (if_then_else:V2HI
3241          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3242          (lshiftrt:V2HI (match_operand:V2HI 1 "register_operand" "d,d,d")
3243                         (match_dup 2))
3244          (ashift:V2HI (match_dup 1) (match_dup 2))))]
3245   ""
3246   "@
3247    %0 = LSHIFT %1 BY %2 (V);
3248    %0 = %1 >> %2 (V);
3249    %0 = %1 << %2 (V);"
3250   [(set_attr "type" "dsp32")])
3251
3252 (define_insn "lshifthi3"
3253   [(set (match_operand:HI 0 "register_operand" "=d,d,d")
3254         (if_then_else:HI
3255          (lt (match_operand:SI 2 "vec_shift_operand" "d,Ku4,Ks4") (const_int 0))
3256          (lshiftrt:HI (match_operand:HI 1 "register_operand" "d,d,d")
3257                       (match_dup 2))
3258          (ashift:HI (match_dup 1) (match_dup 2))))]
3259   ""
3260   "@
3261    %0 = LSHIFT %1 BY %2 (V);
3262    %0 = %1 >> %2 (V);
3263    %0 = %1 << %2 (V);"
3264   [(set_attr "type" "dsp32")])
3265