gcc/config/bfin/bfin.md

   1 ;;- Machine description for Blackfin for GNU compiler
   2 ;;  Copyright 2005  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 ;
  53
  54 ;; Define constants for hard registers.
  55
  56 (define_constants
  57   [(REG_R0 0)
  58    (REG_R1 1)
  59    (REG_R2 2)
  60    (REG_R3 3)
  61    (REG_R4 4)
  62    (REG_R5 5)
  63    (REG_R6 6)
  64    (REG_R7 7)
  65
  66    (REG_P0 8)
  67    (REG_P1 9)
  68    (REG_P2 10)
  69    (REG_P3 11)
  70    (REG_P4 12)
  71    (REG_P5 13)
  72    (REG_P6 14)
  73    (REG_P7 15)
  74
  75    (REG_SP 14)
  76    (REG_FP 15)
  77
  78    (REG_I0 16)
  79    (REG_I1 17)
  80    (REG_I2 18)
  81    (REG_I3 19)
  82
  83    (REG_B0 20)
  84    (REG_B1 21)
  85    (REG_B2 22)
  86    (REG_B3 23)
  87
  88    (REG_L0 24)
  89    (REG_L1 25)
  90    (REG_L2 26)
  91    (REG_L3 27)
  92
  93    (REG_M0 28)
  94    (REG_M1 29)
  95    (REG_M2 30)
  96    (REG_M3 31)
  97
  98    (REG_A0 32)
  99    (REG_A1 33)
 100
 101    (REG_CC 34)
 102    (REG_RETS 35)
 103    (REG_RETI 36)
 104    (REG_RETX 37)
 105    (REG_RETN 38)
 106    (REG_RETE 39)
 107
 108    (REG_ASTAT 40)
 109    (REG_SEQSTAT 41)
 110    (REG_USP 42)
 111
 112    (REG_ARGP 43)])
 113
 114 ;; Constants used in UNSPECs and UNSPEC_VOLATILEs.
 115
 116 (define_constants
 117   [(UNSPEC_CBRANCH_TAKEN 0)
 118    (UNSPEC_CBRANCH_NOPS 1)
 119    (UNSPEC_RETURN 2)
 120    (UNSPEC_MOVE_PIC 3)
 121    (UNSPEC_LIBRARY_OFFSET 4)
 122    (UNSPEC_PUSH_MULTIPLE 5)])
 123
 124 (define_constants
 125   [(UNSPEC_VOLATILE_EH_RETURN 0)
 126    (UNSPEC_VOLATILE_CSYNC 1)
 127    (UNSPEC_VOLATILE_SSYNC 2)])
 128
 129 (define_attr "type"
 130   "move,mvi,mcld,mcst,dsp32,mult,alu0,shft,brcc,br,call,misc,sync,compare,dummy"
 131   (const_string "misc"))
 132
 133 ;; Scheduling definitions
 134
 135 (define_automaton "bfin")
 136
 137 (define_cpu_unit "core" "bfin")
 138
 139 (define_insn_reservation "alu" 1
 140   (eq_attr "type" "move,mvi,mcst,dsp32,alu0,shft,brcc,br,call,misc,sync,compare")
 141   "core")
 142
 143 (define_insn_reservation "imul" 3
 144   (eq_attr "type" "mult")
 145   "core*3")
 146
 147 (define_insn_reservation "load" 1
 148   (eq_attr "type" "mcld")
 149   "core")
 150
 151 ;; Make sure genautomata knows about the maximum latency that can be produced
 152 ;; by the adjust_cost function.
 153 (define_insn_reservation "dummy" 5
 154   (eq_attr "type" "mcld")
 155   "core")
 156 \f
 157 ;; Operand and operator predicates
 158
 159 (include "predicates.md")
 160
 161 \f
 162 ;;; FRIO branches have been optimized for code density
 163 ;;; this comes at a slight cost of complexity when
 164 ;;; a compiler needs to generate branches in the general
 165 ;;; case.  In order to generate the correct branching
 166 ;;; mechanisms the compiler needs keep track of instruction
 167 ;;; lengths.  The follow table describes how to count instructions
 168 ;;; for the FRIO architecture.
 169 ;;;
 170 ;;; unconditional br are 12-bit imm pcrelative branches *2
 171 ;;; conditional   br are 10-bit imm pcrelative branches *2
 172 ;;; brcc 10-bit:
 173 ;;;   1024 10-bit imm *2 is 2048 (-1024..1022)
 174 ;;; br 12-bit  :
 175 ;;;   4096 12-bit imm *2 is 8192 (-4096..4094)
 176 ;;; NOTE : For brcc we generate instructions such as
 177 ;;;   if cc jmp; jump.[sl] offset
 178 ;;;   offset of jump.[sl] is from the jump instruction but
 179 ;;;     gcc calculates length from the if cc jmp instruction
 180 ;;;     furthermore gcc takes the end address of the branch instruction
 181 ;;;     as (pc) for a forward branch
 182 ;;;     hence our range is (-4094, 4092) instead of (-4096, 4094) for a br
 183 ;;;
 184 ;;; The way the (pc) rtx works in these calculations is somewhat odd;
 185 ;;; for backward branches it's the address of the current instruction,
 186 ;;; for forward branches it's the previously known address of the following
 187 ;;; instruction - we have to take this into account by reducing the range
 188 ;;; for a forward branch.
 189
 190 ;; Lengths for type "mvi" insns are always defined by the instructions
 191 ;; themselves.
 192 (define_attr "length" ""
 193   (cond [(eq_attr "type" "mcld")
 194          (if_then_else (match_operand 1 "effective_address_32bit_p" "")
 195                        (const_int 4) (const_int 2))
 196
 197          (eq_attr "type" "mcst")
 198          (if_then_else (match_operand 0 "effective_address_32bit_p" "")
 199                        (const_int 4) (const_int 2))
 200
 201          (eq_attr "type" "move") (const_int 2)
 202
 203          (eq_attr "type" "dsp32") (const_int 4)
 204          (eq_attr "type" "call")  (const_int 4)
 205
 206          (eq_attr "type" "br")
 207          (if_then_else (and
 208                           (le (minus (match_dup 0) (pc)) (const_int 4092))
 209                           (ge (minus (match_dup 0) (pc)) (const_int -4096)))
 210                   (const_int 2)
 211                   (const_int 4))
 212
 213          (eq_attr "type" "brcc")
 214          (cond [(and
 215                     (le (minus (match_dup 3) (pc)) (const_int 1020))
 216                     (ge (minus (match_dup 3) (pc)) (const_int -1024)))
 217                   (const_int 2)
 218                 (and
 219                     (le (minus (match_dup 3) (pc)) (const_int 4092))
 220                     (ge (minus (match_dup 3) (pc)) (const_int -4094)))
 221                   (const_int 4)]
 222                (const_int 6))
 223         ]
 224
 225         (const_int 2)))
 226
 227 ;; Conditional moves
 228
 229 (define_expand "movsicc"
 230   [(set (match_operand:SI 0 "register_operand" "")
 231         (if_then_else:SI (match_operand 1 "comparison_operator" "")
 232                          (match_operand:SI 2 "register_operand" "")
 233                          (match_operand:SI 3 "register_operand" "")))]
 234   ""
 235 {
 236   operands[1] = bfin_gen_compare (operands[1], SImode);
 237 })
 238
 239 (define_insn "*movsicc_insn1"
 240   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
 241         (if_then_else:SI
 242             (eq:BI (match_operand:BI 3 "cc_operand" "C,C,C")
 243                 (const_int 0))
 244             (match_operand:SI 1 "register_operand" "da,0,da")
 245             (match_operand:SI 2 "register_operand" "0,da,da")))]
 246   ""
 247   "@
 248     if !cc %0 =%1; /* movsicc-1a */
 249     if cc %0 =%2; /* movsicc-1b */
 250     if !cc %0 =%1; if cc %0=%2; /* movsicc-1 */"
 251   [(set_attr "length" "2,2,4")
 252    (set_attr "type" "move")])
 253
 254 (define_insn "*movsicc_insn2"
 255   [(set (match_operand:SI 0 "register_operand" "=da,da,da")
 256         (if_then_else:SI
 257             (ne:BI (match_operand:BI 3 "cc_operand" "C,C,C")
 258                 (const_int 0))
 259             (match_operand:SI 1 "register_operand" "0,da,da")
 260             (match_operand:SI 2 "register_operand" "da,0,da")))]
 261   ""
 262   "@
 263    if !cc %0 =%2; /* movsicc-2b */
 264    if cc %0 =%1; /* movsicc-2a */
 265    if cc %0 =%1; if !cc %0=%2; /* movsicc-1 */"
 266   [(set_attr "length" "2,2,4")
 267    (set_attr "type" "move")])
 268
 269 ;; Insns to load HIGH and LO_SUM
 270
 271 (define_insn "movsi_high"
 272   [(set (match_operand:SI 0 "register_operand" "=x")
 273         (high:SI (match_operand:SI 1 "immediate_operand" "i")))]
 274   "reload_completed"
 275   "%d0 = %d1;"
 276   [(set_attr "type" "mvi")
 277    (set_attr "length" "4")])
 278
 279 (define_insn "movstricthi_high"
 280   [(set (match_operand:SI 0 "register_operand" "+x")
 281         (ior:SI (and:SI (match_dup 0) (const_int 65535))
 282                 (match_operand:SI 1 "immediate_operand" "i")))]
 283   "reload_completed"
 284   "%d0 = %d1;"
 285   [(set_attr "type" "mvi")
 286    (set_attr "length" "4")])
 287
 288 (define_insn "movsi_low"
 289   [(set (match_operand:SI 0 "register_operand" "=x")
 290         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
 291                    (match_operand:SI 2 "immediate_operand" "i")))]
 292   "reload_completed"
 293   "%h0 = %h2;"
 294   [(set_attr "type" "mvi")
 295    (set_attr "length" "4")])
 296
 297 (define_insn "movsi_high_pic"
 298   [(set (match_operand:SI 0 "register_operand" "=x")
 299         (high:SI (unspec:SI [(match_operand:SI 1 "" "")]
 300                             UNSPEC_MOVE_PIC)))]
 301   ""
 302   "%d0 = %1@GOT_LOW;"
 303   [(set_attr "type" "mvi")
 304    (set_attr "length" "4")])
 305
 306 (define_insn "movsi_low_pic"
 307   [(set (match_operand:SI 0 "register_operand" "=x")
 308         (lo_sum:SI (match_operand:SI 1 "register_operand" "0")
 309                    (unspec:SI [(match_operand:SI 2 "" "")]
 310                               UNSPEC_MOVE_PIC)))]
 311   ""
 312   "%h0 = %h2@GOT_HIGH;"
 313   [(set_attr "type" "mvi")
 314    (set_attr "length" "4")])
 315
 316 ;;; Move instructions
 317
 318 (define_insn_and_split "movdi_insn"
 319   [(set (match_operand:DI 0 "nonimmediate_operand" "=x,mx,r")
 320         (match_operand:DI 1 "general_operand" "iFx,r,mx"))]
 321   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 322   "#"
 323   "reload_completed"
 324   [(set (match_dup 2) (match_dup 3))
 325    (set (match_dup 4) (match_dup 5))]
 326 {
 327   rtx lo_half[2], hi_half[2];
 328   split_di (operands, 2, lo_half, hi_half);
 329
 330   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
 331     {
 332       operands[2] = hi_half[0];
 333       operands[3] = hi_half[1];
 334       operands[4] = lo_half[0];
 335       operands[5] = lo_half[1];
 336     }
 337   else
 338     {
 339       operands[2] = lo_half[0];
 340       operands[3] = lo_half[1];
 341       operands[4] = hi_half[0];
 342       operands[5] = hi_half[1];
 343     }
 344 })
 345
 346 (define_insn "movbi"
 347   [(set (match_operand:BI 0 "nonimmediate_operand" "=x,x,d,mr,C,d,C")
 348         (match_operand:BI 1 "general_operand" "x,xKs3,mr,d,d,C,P0"))]
 349
 350   ""
 351   "@
 352    %0 = %1;
 353    %0 = %1 (X);
 354    %0 = %1;
 355    %0 = %1;
 356    CC = %1;
 357    %0 = CC;
 358    R0 = R0 | R0; CC = AC0;"
 359   [(set_attr "type" "move,mvi,mcld,mcst,compare,compare,alu0")
 360    (set_attr "length" "2,2,*,*,2,2,4")])
 361
 362 (define_insn "movpdi"
 363   [(set (match_operand:PDI 0 "nonimmediate_operand" "=e,<,e")
 364         (match_operand:PDI 1 "general_operand" " e,e,>"))]
 365   ""
 366   "@
 367    %0 = %1;
 368    %0 = %x1; %0 = %w1;
 369    %w0 = %1; %x0 = %1;"
 370   [(set_attr "type" "move,mcst,mcld")])
 371
 372 (define_insn "*pushsi_insn"
 373   [(set (mem:SI (pre_dec:SI (reg:SI REG_SP)))
 374         (match_operand:SI 0 "register_operand" "xy"))]
 375   ""
 376   "[--SP] = %0;"
 377   [(set_attr "type" "mcst")
 378    (set_attr "length" "2")])
 379
 380 (define_insn "*popsi_insn"
 381   [(set (match_operand:SI 0 "register_operand" "=xy")
 382         (mem:SI (post_inc:SI (reg:SI REG_SP))))]
 383   ""
 384   "%0 = [SP++];"
 385   [(set_attr "type" "mcld")
 386    (set_attr "length" "2")])
 387
 388 ;; The first alternative is used to make reload choose a limited register
 389 ;; class when faced with a movsi_insn that had its input operand replaced
 390 ;; with a PLUS.  We generally require fewer secondary reloads this way.
 391 (define_insn "*movsi_insn"
 392   [(set (match_operand:SI 0 "nonimmediate_operand" "=da,x*y,da,x,x,x,da,mr")
 393         (match_operand:SI 1 "general_operand" "da,x*y,xKs7,xKsh,xKuh,ix,mr,da"))]
 394
 395   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 396   "@
 397    %0 = %1;
 398    %0 = %1;
 399    %0 = %1 (X);
 400    %0 = %1 (X);
 401    %0 = %1 (Z);
 402    #
 403    %0 = %1;
 404    %0 = %1;"
 405   [(set_attr "type" "move,move,mvi,mvi,mvi,*,mcld,mcst")
 406    (set_attr "length" "2,2,2,4,4,*,*,*")])
 407
 408 (define_insn "*movv2hi_insn"
 409   [(set (match_operand:V2HI 0 "nonimmediate_operand" "=da,d,m")
 410         (match_operand:V2HI 1 "general_operand" "d,m,d"))]
 411
 412   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 413   "%0 = %1;"
 414   [(set_attr "type" "move,mcld,mcst")
 415    (set_attr "length" "2,*,*")])
 416
 417 (define_insn "*movhi_insn"
 418   [(set (match_operand:HI 0 "nonimmediate_operand" "=x,da,x,d,mr")
 419         (match_operand:HI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
 420   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 421   "@
 422    %0 = %1;
 423    %0 = %1 (X);
 424    %0 = %1 (X);
 425    %0 = W %1 (X);
 426    W %0 = %1;"
 427   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
 428    (set_attr "length" "2,2,4,*,*")])
 429
 430 (define_insn "*movqi_insn"
 431   [(set (match_operand:QI 0 "nonimmediate_operand" "=x,da,x,d,mr")
 432         (match_operand:QI 1 "general_operand" "x,xKs7,xKsh,mr,d"))]
 433   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 434   "@
 435    %0 = %1;
 436    %0 = %1 (X);
 437    %0 = %1 (X);
 438    %0 = B %1 (X);
 439    B %0 = %1;"
 440   [(set_attr "type" "move,mvi,mvi,mcld,mcst")
 441    (set_attr "length" "2,2,4,*,*")])
 442
 443 (define_insn "*movsf_insn"
 444   [(set (match_operand:SF 0 "nonimmediate_operand" "=x,x,da,mr")
 445         (match_operand:SF 1 "general_operand" "x,Fx,mr,da"))]
 446   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 447   "@
 448    %0 = %1;
 449    #
 450    %0 = %1;
 451    %0 = %1;"
 452   [(set_attr "type" "move,*,mcld,mcst")])
 453
 454 (define_insn_and_split "movdf_insn"
 455   [(set (match_operand:DF 0 "nonimmediate_operand" "=x,mx,r")
 456         (match_operand:DF 1 "general_operand" "iFx,r,mx"))]
 457   "GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM"
 458   "#"
 459   "reload_completed"
 460   [(set (match_dup 2) (match_dup 3))
 461    (set (match_dup 4) (match_dup 5))]
 462 {
 463   rtx lo_half[2], hi_half[2];
 464   split_di (operands, 2, lo_half, hi_half);
 465
 466   if (reg_overlap_mentioned_p (lo_half[0], hi_half[1]))
 467     {
 468       operands[2] = hi_half[0];
 469       operands[3] = hi_half[1];
 470       operands[4] = lo_half[0];
 471       operands[5] = lo_half[1];
 472     }
 473   else
 474     {
 475       operands[2] = lo_half[0];
 476       operands[3] = lo_half[1];
 477       operands[4] = hi_half[0];
 478       operands[5] = hi_half[1];
 479     }
 480 })
 481
 482 ;; This is the main "hook" for PIC code.  When generating
 483 ;; PIC, movsi is responsible for determining when the source address
 484 ;; needs PIC relocation and appropriately calling legitimize_pic_address
 485 ;; to perform the actual relocation.
 486
 487 (define_expand "movsi"
 488   [(set (match_operand:SI 0 "nonimmediate_operand" "")
 489         (match_operand:SI 1 "general_operand" ""))]
 490   ""
 491   "expand_move (operands, SImode);")
 492
 493 (define_expand "movv2hi"
 494   [(set (match_operand:V2HI 0 "nonimmediate_operand" "")
 495         (match_operand:V2HI 1 "general_operand" ""))]
 496   ""
 497   "expand_move (operands, V2HImode);")
 498
 499 (define_expand "movdi"
 500   [(set (match_operand:DI 0 "nonimmediate_operand" "")
 501         (match_operand:DI 1 "general_operand" ""))]
 502   ""
 503   "expand_move (operands, DImode);")
 504
 505 (define_expand "movsf"
 506  [(set (match_operand:SF 0 "nonimmediate_operand" "")
 507        (match_operand:SF 1 "general_operand" ""))]
 508   ""
 509   "expand_move (operands, SFmode);")
 510
 511 (define_expand "movdf"
 512  [(set (match_operand:DF 0 "nonimmediate_operand" "")
 513        (match_operand:DF 1 "general_operand" ""))]
 514   ""
 515   "expand_move (operands, DFmode);")
 516
 517 (define_expand "movhi"
 518   [(set (match_operand:HI 0 "nonimmediate_operand" "")
 519         (match_operand:HI 1 "general_operand" ""))]
 520   ""
 521   "expand_move (operands, HImode);")
 522
 523 (define_expand "movqi"
 524   [(set (match_operand:QI 0 "nonimmediate_operand" "")
 525         (match_operand:QI 1 "general_operand" ""))]
 526   ""
 527   " expand_move (operands, QImode); ")
 528
 529 ;; Some define_splits to break up SI/SFmode loads of immediate constants.
 530
 531 (define_split
 532   [(set (match_operand:SI 0 "register_operand" "")
 533         (match_operand:SI 1 "symbolic_or_const_operand" ""))]
 534   "reload_completed
 535    /* Always split symbolic operands; split integer constants that are
 536       too large for a single instruction.  */
 537    && (GET_CODE (operands[1]) != CONST_INT
 538        || (INTVAL (operands[1]) < -32768
 539            || INTVAL (operands[1]) >= 65536
 540            || (INTVAL (operands[1]) >= 32768 && PREG_P (operands[0]))))"
 541   [(set (match_dup 0) (high:SI (match_dup 1)))
 542    (set (match_dup 0) (lo_sum:SI (match_dup 0) (match_dup 1)))]
 543 {
 544   if (GET_CODE (operands[1]) == CONST_INT
 545       && split_load_immediate (operands))
 546     DONE;
 547   /* ??? Do something about TARGET_LOW_64K.  */
 548 })
 549
 550 (define_split
 551   [(set (match_operand:SF 0 "register_operand" "")
 552         (match_operand:SF 1 "immediate_operand" ""))]
 553   "reload_completed"
 554   [(set (match_dup 2) (high:SI (match_dup 3)))
 555    (set (match_dup 2) (lo_sum:SI (match_dup 2) (match_dup 3)))]
 556 {
 557   long values;
 558   REAL_VALUE_TYPE value;
 559
 560   gcc_assert (GET_CODE (operands[1]) == CONST_DOUBLE);
 561
 562   REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
 563   REAL_VALUE_TO_TARGET_SINGLE (value, values);
 564
 565   operands[2] = gen_rtx_REG (SImode, true_regnum (operands[0]));
 566   operands[3] = GEN_INT (trunc_int_for_mode (values, SImode));
 567   if (values >= -32768 && values < 65536)
 568     {
 569       emit_move_insn (operands[2], operands[3]);
 570       DONE;
 571     }
 572   if (split_load_immediate (operands + 2))
 573     DONE;
 574 })
 575
 576 ;; Sadly, this can't be a proper named movstrict pattern, since the compiler
 577 ;; expects to be able to use registers for operand 1.
 578 ;; Note that the asm instruction is defined by the manual to take an unsigned
 579 ;; constant, but it doesn't matter to the assembler, and the compiler only
 580 ;; deals with sign-extended constants.  Hence "Ksh".
 581 (define_insn "*movstricthi"
 582   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+x"))
 583         (match_operand:HI 1 "immediate_operand" "Ksh"))]
 584   ""
 585   "%h0 = %1;"
 586   [(set_attr "type" "mvi")
 587    (set_attr "length" "4")])
 588
 589 ;; Sign and zero extensions
 590
 591 (define_insn "extendhisi2"
 592   [(set (match_operand:SI 0 "register_operand" "=d, d")
 593         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
 594   ""
 595   "@
 596    %0 = %h1 (X);
 597    %0 = W %h1 (X);"
 598   [(set_attr "type" "alu0,mcld")])
 599
 600 (define_insn "zero_extendhisi2"
 601   [(set (match_operand:SI 0 "register_operand" "=d, d")
 602         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d, m")))]
 603   ""
 604   "@
 605    %0 = %h1 (Z);
 606    %0 = W%h1 (Z);"
 607   [(set_attr "type" "alu0,mcld")])
 608
 609 (define_insn "zero_extendbisi2"
 610   [(set (match_operand:SI 0 "register_operand" "=d")
 611         (zero_extend:SI (match_operand:BI 1 "nonimmediate_operand" "C")))]
 612   ""
 613   "%0 = %1;"
 614   [(set_attr "type" "compare")])
 615
 616 (define_insn "extendqihi2"
 617   [(set (match_operand:HI 0 "register_operand" "=d, d")
 618         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 619   ""
 620   "@
 621    %0 = B %1 (X);
 622    %0 = %T1 (X);"
 623   [(set_attr "type" "mcld,alu0")])
 624
 625 (define_insn "extendqisi2"
 626   [(set (match_operand:SI 0 "register_operand" "=d, d")
 627         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 628   ""
 629   "@
 630    %0 = B %1 (X);
 631    %0 = %T1 (X);"
 632   [(set_attr "type" "mcld,alu0")])
 633
 634
 635 (define_insn "zero_extendqihi2"
 636   [(set (match_operand:HI 0 "register_operand" "=d, d")
 637         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 638   ""
 639   "@
 640    %0 = B %1 (Z);
 641    %0 = %T1 (Z);"
 642   [(set_attr "type" "mcld,alu0")])
 643
 644
 645 (define_insn "zero_extendqisi2"
 646   [(set (match_operand:SI 0 "register_operand" "=d, d")
 647         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "m, d")))]
 648   ""
 649   "@
 650    %0 = B %1 (Z);
 651    %0 = %T1 (Z);"
 652   [(set_attr "type" "mcld,alu0")])
 653
 654 ;; DImode logical operations
 655
 656 (define_code_macro any_logical [and ior xor])
 657 (define_code_attr optab [(and "and")
 658                          (ior "ior")
 659                          (xor "xor")])
 660 (define_code_attr op [(and "&")
 661                       (ior "|")
 662                       (xor "^")])
 663 (define_code_attr high_result [(and "0")
 664                                (ior "%H1")
 665                                (xor "%H1")])
 666
 667 (define_insn "<optab>di3"
 668   [(set (match_operand:DI 0 "register_operand" "=d")
 669         (any_logical:DI (match_operand:DI 1 "register_operand" "0")
 670                         (match_operand:DI 2 "register_operand" "d")))]
 671   ""
 672   "%0 = %1 <op> %2;\\n\\t%H0 = %H1 <op> %H2;"
 673   [(set_attr "length" "4")])
 674
 675 (define_insn "*<optab>di_zesidi_di"
 676   [(set (match_operand:DI 0 "register_operand" "=d")
 677         (any_logical:DI (zero_extend:DI
 678                          (match_operand:SI 2 "register_operand" "d"))
 679                         (match_operand:DI 1 "register_operand" "d")))]
 680   ""
 681   "%0 = %1 <op>  %2;\\n\\t%H0 = <high_result>;"
 682   [(set_attr "length" "4")])
 683
 684 (define_insn "*<optab>di_sesdi_di"
 685   [(set (match_operand:DI 0 "register_operand" "=d")
 686         (any_logical:DI (sign_extend:DI
 687                          (match_operand:SI 2 "register_operand" "d"))
 688                         (match_operand:DI 1 "register_operand" "0")))
 689    (clobber (match_scratch:SI 3 "=&d"))]
 690   ""
 691   "%0 = %1 <op> %2;\\n\\t%3 = %2;\\n\\t%3 >>>= 31;\\n\\t%H0 = %H1 <op> %3;"
 692   [(set_attr "length" "8")])
 693
 694 (define_insn "negdi2"
 695   [(set (match_operand:DI 0 "register_operand" "=d")
 696         (neg:DI (match_operand:DI 1 "register_operand" "d")))
 697    (clobber (match_scratch:SI 2 "=&d"))
 698    (clobber (reg:CC REG_CC))]
 699   ""
 700   "%2 = 0; %2 = %2 - %1; cc = ac0; cc = !cc; %2 = cc;\\n\\t%0 = -%1; %H0 = -%H1; %H0 = %H0 - %2;"
 701   [(set_attr "length" "16")])
 702
 703 (define_insn "one_cmpldi2"
 704   [(set (match_operand:DI 0 "register_operand" "=d")
 705         (not:DI (match_operand:DI 1 "register_operand" "d")))]
 706   ""
 707   "%0 = ~%1;\\n\\t%H0 = ~%H1;"
 708   [(set_attr "length" "4")])
 709
 710 ;; DImode zero and sign extend patterns
 711
 712 (define_insn_and_split "zero_extendsidi2"
 713   [(set (match_operand:DI 0 "register_operand" "=d")
 714         (zero_extend:DI (match_operand:SI 1 "register_operand" "d")))]
 715   ""
 716   "#"
 717   "reload_completed"
 718   [(set (match_dup 3) (const_int 0))]
 719 {
 720   split_di (operands, 1, operands + 2, operands + 3);
 721   if (REGNO (operands[0]) != REGNO (operands[1]))
 722     emit_move_insn (operands[2], operands[1]);
 723 })
 724
 725 (define_insn "zero_extendqidi2"
 726   [(set (match_operand:DI 0 "register_operand" "=d")
 727         (zero_extend:DI (match_operand:QI 1 "register_operand" "d")))]
 728   ""
 729   "%0 = %T1 (Z);\\n\\t%H0 = 0;"
 730   [(set_attr "length" "4")])
 731
 732 (define_insn "zero_extendhidi2"
 733   [(set (match_operand:DI 0 "register_operand" "=d")
 734         (zero_extend:DI (match_operand:HI 1 "register_operand" "d")))]
 735   ""
 736   "%0 = %h1 (Z);\\n\\t%H0 = 0;"
 737   [(set_attr "length" "4")])
 738
 739 (define_insn_and_split "extendsidi2"
 740   [(set (match_operand:DI 0 "register_operand" "=d")
 741         (sign_extend:DI (match_operand:SI 1 "register_operand" "d")))]
 742   ""
 743   "#"
 744   "reload_completed"
 745   [(set (match_dup 3) (match_dup 1))
 746    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 747 {
 748   split_di (operands, 1, operands + 2, operands + 3);
 749   if (REGNO (operands[0]) != REGNO (operands[1]))
 750     emit_move_insn (operands[2], operands[1]);
 751 })
 752
 753 (define_insn_and_split "extendqidi2"
 754   [(set (match_operand:DI 0 "register_operand" "=d")
 755         (sign_extend:DI (match_operand:QI 1 "register_operand" "d")))]
 756   ""
 757   "#"
 758   "reload_completed"
 759   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
 760    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
 761    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 762 {
 763   split_di (operands, 1, operands + 2, operands + 3);
 764 })
 765
 766 (define_insn_and_split "extendhidi2"
 767   [(set (match_operand:DI 0 "register_operand" "=d")
 768         (sign_extend:DI (match_operand:HI 1 "register_operand" "d")))]
 769   ""
 770   "#"
 771   "reload_completed"
 772   [(set (match_dup 2) (sign_extend:SI (match_dup 1)))
 773    (set (match_dup 3) (sign_extend:SI (match_dup 1)))
 774    (set (match_dup 3) (ashiftrt:SI (match_dup 3) (const_int 31)))]
 775 {
 776   split_di (operands, 1, operands + 2, operands + 3);
 777 })
 778
 779 ;; DImode arithmetic operations
 780
 781 (define_insn "adddi3"
 782   [(set (match_operand:DI 0 "register_operand" "=&d,&d,&d")
 783         (plus:DI (match_operand:DI 1 "register_operand" "%0,0,0")
 784                  (match_operand:DI 2 "nonmemory_operand" "Kn7,Ks7,d")))
 785    (clobber (match_scratch:SI 3 "=&d,&d,&d"))
 786    (clobber (reg:CC 34))]
 787   ""
 788   "@
 789    %0 += %2; cc = ac0; %3 = cc; %H0 += -1; %H0 = %H0 + %3;
 790    %0 += %2; cc = ac0; %3 = cc; %H0 = %H0 + %3;
 791    %0 = %0 + %2; cc = ac0; %3 = cc; %H0 = %H0 + %H2; %H0 = %H0 + %3;"
 792   [(set_attr "type" "alu0")
 793    (set_attr "length" "10,8,10")])
 794
 795 (define_insn "subdi3"
 796   [(set (match_operand:DI 0 "register_operand" "=&d")
 797         (minus:DI (match_operand:DI 1 "register_operand" "0")
 798                   (match_operand:DI 2 "register_operand" "d")))
 799    (clobber (reg:CC 34))]
 800   ""
 801   "%0 = %1-%2;\\n\\tcc = ac0;\\n\\t%H0 = %H1-%H2;\\n\\tif cc jump 1f;\\n\\t%H0 += -1;\\n\\t1:"
 802   [(set_attr "length" "10")])
 803
 804 (define_insn "*subdi_di_zesidi"
 805   [(set (match_operand:DI 0 "register_operand" "=d")
 806         (minus:DI (match_operand:DI 1 "register_operand" "0")
 807                   (zero_extend:DI
 808                   (match_operand:SI 2 "register_operand" "d"))))
 809    (clobber (match_scratch:SI 3 "=&d"))
 810    (clobber (reg:CC 34))]
 811   ""
 812   "%0 = %1 - %2;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%H0 = %H1 - %3;"
 813   [(set_attr "length" "10")])
 814
 815 (define_insn "*subdi_zesidi_di"
 816   [(set (match_operand:DI 0 "register_operand" "=d")
 817         (minus:DI (zero_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    (clobber (reg:CC 34))]
 822   ""
 823   "%0 = %2 - %1;\\n\\tcc = ac0;\\n\\tcc = ! cc;\\n\\t%3 = cc;\\n\\t%3 = -%3;\\n\\t%H0 = %3 - %H1"
 824   [(set_attr "length" "12")])
 825
 826 (define_insn "*subdi_di_sesidi"
 827   [(set (match_operand:DI 0 "register_operand" "=d")
 828         (minus:DI (match_operand:DI 1 "register_operand" "0")
 829                   (sign_extend:DI
 830                   (match_operand:SI 2 "register_operand" "d"))))
 831    (clobber (match_scratch:SI 3 "=&d"))
 832    (clobber (reg:CC 34))]
 833   ""
 834   "%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:"
 835   [(set_attr "length" "14")])
 836
 837 (define_insn "*subdi_sesidi_di"
 838   [(set (match_operand:DI 0 "register_operand" "=d")
 839         (minus:DI (sign_extend:DI
 840                   (match_operand:SI 2 "register_operand" "d"))
 841                   (match_operand:DI 1 "register_operand" "0")))
 842    (clobber (match_scratch:SI 3 "=&d"))
 843    (clobber (reg:CC 34))]
 844   ""
 845   "%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:"
 846   [(set_attr "length" "14")])
 847
 848 ;; Combined shift/add instructions
 849
 850 (define_insn ""
 851   [(set (match_operand:SI 0 "register_operand" "=a,d")
 852         (ashift:SI (plus:SI (match_operand:SI 1 "register_operand" "%0,0")
 853                             (match_operand:SI 2 "register_operand" "a,d"))
 854                    (match_operand:SI 3 "pos_scale_operand" "P1P2,P1P2")))]
 855   ""
 856   "%0 = (%0 + %2) << %3;" /* "shadd %0,%2,%3;" */
 857   [(set_attr "type" "alu0")])
 858
 859 (define_insn ""
 860   [(set (match_operand:SI 0 "register_operand" "=a")
 861         (plus:SI (match_operand:SI 1 "register_operand" "a")
 862                  (mult:SI (match_operand:SI 2 "register_operand" "a")
 863                           (match_operand:SI 3 "scale_by_operand" "i"))))]
 864   ""
 865   "%0 = %1 + (%2 << %X3);"
 866   [(set_attr "type" "alu0")])
 867
 868 (define_insn ""
 869   [(set (match_operand:SI 0 "register_operand" "=a")
 870         (plus:SI (match_operand:SI 1 "register_operand" "a")
 871                  (ashift:SI (match_operand:SI 2 "register_operand" "a")
 872                             (match_operand:SI 3 "pos_scale_operand" "i"))))]
 873   ""
 874   "%0 = %1 + (%2 << %3);"
 875   [(set_attr "type" "alu0")])
 876
 877 (define_insn ""
 878   [(set (match_operand:SI 0 "register_operand" "=a")
 879         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "a")
 880                           (match_operand:SI 2 "scale_by_operand" "i"))
 881                  (match_operand:SI 3 "register_operand" "a")))]
 882   ""
 883   "%0 = %3 + (%1 << %X2);"
 884   [(set_attr "type" "alu0")])
 885
 886 (define_insn ""
 887   [(set (match_operand:SI 0 "register_operand" "=a")
 888         (plus:SI (ashift:SI (match_operand:SI 1 "register_operand" "a")
 889                             (match_operand:SI 2 "pos_scale_operand" "i"))
 890                  (match_operand:SI 3 "register_operand" "a")))]
 891   ""
 892   "%0 = %3 + (%1 << %2);"
 893   [(set_attr "type" "alu0")])
 894
 895 (define_insn "mulhisi3"
 896   [(set (match_operand:SI 0 "register_operand" "=d")
 897         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "%d"))
 898                  (sign_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
 899   ""
 900   "%0 = %h1 * %h2 (IS);"
 901   [(set_attr "type" "dsp32")])
 902
 903 (define_insn "umulhisi3"
 904   [(set (match_operand:SI 0 "register_operand" "=d")
 905         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%d"))
 906                  (zero_extend:SI (match_operand:HI 2 "register_operand" "d"))))]
 907   ""
 908   "%0 = %h1 * %h2 (FU);"
 909   [(set_attr "type" "dsp32")])
 910
 911 (define_insn "usmulhisi3"
 912   [(set (match_operand:SI 0 "register_operand" "=W")
 913         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "W"))
 914                  (sign_extend:SI (match_operand:HI 2 "register_operand" "W"))))]
 915   ""
 916   "%0 = %h2 * %h1 (IS,M);"
 917   [(set_attr "type" "dsp32")])
 918
 919 ;; The processor also supports ireg += mreg or ireg -= mreg, but these
 920 ;; are unusable if we don't ensure that the corresponding lreg is zero.
 921 ;; The same applies to the add/subtract constant versions involving
 922 ;; iregs
 923
 924 (define_insn "addsi3"
 925   [(set (match_operand:SI 0 "register_operand" "=ad,a,d")
 926         (plus:SI (match_operand:SI 1 "register_operand" "%0, a,d")
 927                  (match_operand:SI 2 "reg_or_7bit_operand" "Ks7, a,d")))]
 928   ""
 929   "@
 930    %0 += %2;
 931    %0 = %1 + %2;
 932    %0 = %1 + %2;"
 933   [(set_attr "type" "alu0")
 934    (set_attr "length" "2,2,2")])
 935
 936 (define_expand "subsi3"
 937   [(set (match_operand:SI 0 "register_operand" "")
 938         (minus:SI (match_operand:SI 1 "register_operand" "")
 939                   (match_operand:SI 2 "reg_or_7bit_operand" "")))]
 940   ""
 941   "")
 942
 943 (define_insn ""
 944   [(set (match_operand:SI 0 "register_operand" "=da,d,a")
 945         (minus:SI (match_operand:SI 1 "register_operand" "0,d,0")
 946                   (match_operand:SI 2 "reg_or_7bit_operand" "Ks7,d,a")))]
 947   "GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != -64"
 948 {
 949   static const char *const strings_subsi3[] = {
 950     "%0 += -%2;",
 951     "%0 = %1 - %2;",
 952     "%0 -= %2;",
 953   };
 954
 955   if (CONSTANT_P (operands[2]) && INTVAL (operands[2]) < 0) {
 956      rtx tmp_op = operands[2];
 957      operands[2] = GEN_INT (-INTVAL (operands[2]));
 958      output_asm_insn ("%0 += %2;", operands);
 959      operands[2] = tmp_op;
 960      return "";
 961   }
 962
 963   return strings_subsi3[which_alternative];
 964 }
 965   [(set_attr "type" "alu0")])
 966
 967 ;; Bit test instructions
 968
 969 (define_insn "*not_bittst"
 970  [(set (match_operand:BI 0 "cc_operand" "=C")
 971        (eq:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
 972                                (const_int 1)
 973                                (match_operand:SI 2 "immediate_operand" "Ku5"))
 974               (const_int 0)))]
 975  ""
 976  "cc = !BITTST (%1,%2);"
 977   [(set_attr "type" "alu0")])
 978
 979 (define_insn "*bittst"
 980  [(set (match_operand:BI 0 "cc_operand" "=C")
 981        (ne:BI (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
 982                                (const_int 1)
 983                                (match_operand:SI 2 "immediate_operand" "Ku5"))
 984                 (const_int 0)))]
 985  ""
 986  "cc = BITTST (%1,%2);"
 987   [(set_attr "type" "alu0")])
 988
 989 (define_insn_and_split "*bit_extract"
 990   [(set (match_operand:SI 0 "register_operand" "=d")
 991         (zero_extract:SI (match_operand:SI 1 "register_operand" "d")
 992                          (const_int 1)
 993                          (match_operand:SI 2 "immediate_operand" "Ku5")))
 994    (clobber (reg:BI REG_CC))]
 995   ""
 996   "#"
 997   ""
 998   [(set (reg:BI REG_CC)
 999         (ne:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1000                (const_int 0)))
1001    (set (match_dup 0)
1002         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1003
1004 (define_insn_and_split "*not_bit_extract"
1005   [(set (match_operand:SI 0 "register_operand" "=d")
1006         (zero_extract:SI (not:SI (match_operand:SI 1 "register_operand" "d"))
1007                          (const_int 1)
1008                          (match_operand:SI 2 "immediate_operand" "Ku5")))
1009    (clobber (reg:BI REG_CC))]
1010   ""
1011   "#"
1012   ""
1013   [(set (reg:BI REG_CC)
1014         (eq:BI (zero_extract:SI (match_dup 1) (const_int 1) (match_dup 2))
1015                (const_int 0)))
1016    (set (match_dup 0)
1017         (ne:SI (reg:BI REG_CC) (const_int 0)))])
1018
1019 (define_insn "*andsi_insn"
1020   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
1021         (and:SI (match_operand:SI 1 "register_operand" "%0,d,d,d")
1022                 (match_operand:SI 2 "rhs_andsi3_operand" "L,M1,M2,d")))]
1023   ""
1024   "@
1025    BITCLR (%0,%Y2);
1026    %0 = %T1 (Z);
1027    %0 = %h1 (Z);
1028    %0 = %1 & %2;"
1029   [(set_attr "type" "alu0")])
1030
1031 (define_expand "andsi3"
1032   [(set (match_operand:SI 0 "register_operand" "")
1033         (and:SI (match_operand:SI 1 "register_operand" "")
1034                 (match_operand:SI 2 "general_operand" "")))]
1035   ""
1036 {
1037   if (highbits_operand (operands[2], SImode))
1038     {
1039       operands[2] = GEN_INT (exact_log2 (-INTVAL (operands[2])));
1040       emit_insn (gen_ashrsi3 (operands[0], operands[1], operands[2]));
1041       emit_insn (gen_ashlsi3 (operands[0], operands[0], operands[2]));
1042       DONE;
1043     }
1044   if (! rhs_andsi3_operand (operands[2], SImode))
1045     operands[2] = force_reg (SImode, operands[2]);
1046 })
1047
1048 (define_insn "iorsi3"
1049   [(set (match_operand:SI 0 "register_operand" "=d,d")
1050         (ior:SI (match_operand:SI 1 "register_operand" "%0,d")
1051                 (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1052   ""
1053   "@
1054    BITSET (%0, %X2);
1055    %0 = %1 | %2;"
1056   [(set_attr "type" "alu0")])
1057
1058 (define_insn "xorsi3"
1059   [(set (match_operand:SI 0 "register_operand" "=d,d")
1060         (xor:SI (match_operand:SI 1 "register_operand" "%0,d")
1061                   (match_operand:SI 2 "regorlog2_operand" "J,d")))]
1062   ""
1063   "@
1064    BITTGL (%0, %X2);
1065    %0 = %1 ^ %2;"
1066   [(set_attr "type" "alu0")])
1067
1068 (define_insn "smaxsi3"
1069   [(set (match_operand:SI 0 "register_operand" "=d")
1070         (smax:SI (match_operand:SI 1 "register_operand" "d")
1071                  (match_operand:SI 2 "register_operand" "d")))]
1072   ""
1073   "%0 =max(%1,%2);"
1074   [(set_attr "type" "dsp32")])
1075
1076 (define_insn "sminsi3"
1077   [(set (match_operand:SI 0 "register_operand" "=d")
1078         (smin:SI (match_operand:SI 1 "register_operand" "d")
1079                  (match_operand:SI 2 "register_operand" "d")))]
1080   ""
1081   "%0 =min(%1,%2);"
1082   [(set_attr "type" "dsp32")])
1083
1084 (define_insn "abssi2"
1085   [(set (match_operand:SI 0 "register_operand" "=d")
1086         (abs:SI (match_operand:SI 1 "register_operand" " d")))]
1087   ""
1088   "%0 =abs %1;"
1089   [(set_attr "type" "dsp32")])
1090
1091
1092 (define_insn "negsi2"
1093   [(set (match_operand:SI 0 "register_operand" "=d")
1094         (neg:SI (match_operand:SI 1 "register_operand" " d")))]
1095   ""
1096   "%0 =-%1;"
1097   [(set_attr "type" "alu0")])
1098
1099 (define_insn "one_cmplsi2"
1100   [(set (match_operand:SI 0 "register_operand" "=d")
1101         (not:SI (match_operand:SI 1 "register_operand" " d")))]
1102   ""
1103   "%0 =~%1;"
1104   [(set_attr "type" "alu0")])
1105
1106 (define_insn "mulsi3"
1107   [(set (match_operand:SI 0 "register_operand" "=d")
1108         (mult:SI (match_operand:SI 1 "register_operand" "%0")
1109                  (match_operand:SI 2 "register_operand" "d")))]
1110   ""
1111   "%0 *=%2;"
1112   [(set_attr "type" "mult")])
1113
1114 (define_expand "ashlsi3"
1115   [(set (match_operand:SI 0 "register_operand" "")
1116         (ashift:SI (match_operand:SI 1 "register_operand" "")
1117                    (match_operand:SI 2 "nonmemory_operand" "")))]
1118   ""
1119 {
1120  if (GET_CODE (operands[2]) == CONST_INT
1121      && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1122    {
1123      emit_insn (gen_movsi (operands[0], const0_rtx));
1124      DONE;
1125    }
1126 })
1127
1128 (define_insn_and_split "*ashlsi3_insn"
1129   [(set (match_operand:SI 0 "register_operand" "=d,a,a,a")
1130         (ashift:SI (match_operand:SI 1 "register_operand" "0,a,a,a")
1131                    (match_operand:SI 2 "nonmemory_operand" "dKu5,P1,P2,?P3P4")))]
1132   ""
1133   "@
1134    %0 <<= %2;
1135    %0 = %1 + %1;
1136    %0 = %1 << %2;
1137    #"
1138   "PREG_P (operands[0]) && INTVAL (operands[2]) > 2"
1139   [(set (match_dup 0) (ashift:SI (match_dup 1) (const_int 2)))
1140    (set (match_dup 0) (ashift:SI (match_dup 0) (match_dup 3)))]
1141   "operands[3] = GEN_INT (INTVAL (operands[2]) - 2);"
1142   [(set_attr "type" "shft")])
1143
1144 (define_insn "ashrsi3"
1145   [(set (match_operand:SI 0 "register_operand" "=d")
1146         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
1147                      (match_operand:SI 2 "nonmemory_operand" "dKu5")))]
1148   ""
1149   "%0 >>>= %2;"
1150   [(set_attr "type" "shft")])
1151
1152 (define_insn "ror_one"
1153   [(set (match_operand:SI 0 "register_operand" "=d")
1154         (ior:SI (lshiftrt:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1155                 (ashift:SI (zero_extend:SI (reg:BI REG_CC)) (const_int 31))))
1156    (set (reg:BI REG_CC)
1157         (zero_extract:BI (match_dup 1) (const_int 1) (const_int 0)))]
1158   ""
1159   "%0 = ROT %1 BY -1;"
1160   [(set_attr "type" "shft")
1161    (set_attr "length" "4")])
1162
1163 (define_insn "rol_one"
1164   [(set (match_operand:SI 0 "register_operand" "+d")
1165         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d") (const_int 1))
1166                 (zero_extend:SI (reg:BI REG_CC))))
1167    (set (reg:BI REG_CC)
1168         (zero_extract:BI (match_dup 1) (const_int 31) (const_int 0)))]
1169   ""
1170   "%0 = ROT %1 BY 1;"
1171   [(set_attr "type" "shft")
1172    (set_attr "length" "4")])
1173
1174 (define_expand "lshrdi3"
1175   [(set (match_operand:DI 0 "register_operand" "")
1176         (lshiftrt:DI (match_operand:DI 1 "register_operand" "")
1177                      (match_operand:DI 2 "general_operand" "")))]
1178   ""
1179 {
1180   rtx lo_half[2], hi_half[2];
1181
1182   if (operands[2] != const1_rtx)
1183     FAIL;
1184   if (! rtx_equal_p (operands[0], operands[1]))
1185     emit_move_insn (operands[0], operands[1]);
1186
1187   split_di (operands, 2, lo_half, hi_half);
1188
1189   emit_move_insn (bfin_cc_rtx, const0_rtx);
1190   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1191   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1192   DONE;
1193 })
1194
1195 (define_expand "ashrdi3"
1196   [(set (match_operand:DI 0 "register_operand" "")
1197         (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
1198                      (match_operand:DI 2 "general_operand" "")))]
1199   ""
1200 {
1201   rtx lo_half[2], hi_half[2];
1202
1203   if (operands[2] != const1_rtx)
1204     FAIL;
1205   if (! rtx_equal_p (operands[0], operands[1]))
1206     emit_move_insn (operands[0], operands[1]);
1207
1208   split_di (operands, 2, lo_half, hi_half);
1209
1210   emit_insn (gen_compare_lt (gen_rtx_REG (BImode, REG_CC),
1211                              hi_half[1], const0_rtx));
1212   emit_insn (gen_ror_one (hi_half[0], hi_half[0]));
1213   emit_insn (gen_ror_one (lo_half[0], lo_half[0]));
1214   DONE;
1215 })
1216
1217 (define_expand "ashldi3"
1218   [(set (match_operand:DI 0 "register_operand" "")
1219         (ashift:DI (match_operand:DI 1 "register_operand" "")
1220                    (match_operand:DI 2 "general_operand" "")))]
1221   ""
1222 {
1223   rtx lo_half[2], hi_half[2];
1224
1225   if (operands[2] != const1_rtx)
1226     FAIL;
1227   if (! rtx_equal_p (operands[0], operands[1]))
1228     emit_move_insn (operands[0], operands[1]);
1229
1230   split_di (operands, 2, lo_half, hi_half);
1231
1232   emit_move_insn (bfin_cc_rtx, const0_rtx);
1233   emit_insn (gen_rol_one (lo_half[0], lo_half[0]));
1234   emit_insn (gen_rol_one (hi_half[0], hi_half[0]));
1235   DONE;
1236 })
1237
1238 (define_insn "lshrsi3"
1239   [(set (match_operand:SI 0 "register_operand" "=d,a")
1240         (lshiftrt:SI (match_operand:SI 1 "register_operand" " 0,a")
1241                      (match_operand:SI 2 "nonmemory_operand" "dKu5,P1P2")))]
1242   ""
1243   "@
1244    %0 >>= %2;
1245    %0 = %1 >> %2;"
1246   [(set_attr "type" "shft")])
1247
1248 ;; A pattern to reload the equivalent of
1249 ;;   (set (Dreg) (plus (FP) (large_constant)))
1250 ;; or
1251 ;;   (set (dagreg) (plus (FP) (arbitrary_constant)))
1252 ;; using a scratch register
1253 (define_expand "reload_insi"
1254   [(parallel [(set (match_operand:SI 0 "register_operand" "=w")
1255                    (match_operand:SI 1 "fp_plus_const_operand" ""))
1256               (clobber (match_operand:SI 2 "register_operand" "=&a"))])]
1257   ""
1258 {
1259   rtx fp_op = XEXP (operands[1], 0);
1260   rtx const_op = XEXP (operands[1], 1);
1261   rtx primary = operands[0];
1262   rtx scratch = operands[2];
1263
1264   emit_move_insn (scratch, const_op);
1265   emit_insn (gen_addsi3 (scratch, scratch, fp_op));
1266   emit_move_insn (primary, scratch);
1267   DONE;
1268 })
1269
1270 ;; Jump instructions
1271
1272 (define_insn "jump"
1273   [(set (pc)
1274         (label_ref (match_operand 0 "" "")))]
1275   ""
1276 {
1277   if (get_attr_length (insn) == 2)
1278     return "jump.s %0;";
1279   else
1280     return "jump.l %0;";
1281 }
1282   [(set_attr "type" "br")])
1283
1284 (define_insn "indirect_jump"
1285   [(set (pc)
1286         (match_operand:SI 0 "register_operand" "a"))]
1287   ""
1288   "jump (%0);"
1289   [(set_attr "type" "misc")])
1290
1291 (define_expand "tablejump"
1292   [(parallel [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1293               (use (label_ref (match_operand 1 "" "")))])]
1294   ""
1295 {
1296   /* In PIC mode, the table entries are stored PC relative.
1297      Convert the relative address to an absolute address.  */
1298   if (flag_pic)
1299     {
1300       rtx op1 = gen_rtx_LABEL_REF (Pmode, operands[1]);
1301
1302       operands[0] = expand_simple_binop (Pmode, PLUS, operands[0],
1303                                          op1, NULL_RTX, 0, OPTAB_DIRECT);
1304     }
1305 })
1306
1307 (define_insn "*tablejump_internal"
1308   [(set (pc) (match_operand:SI 0 "register_operand" "a"))
1309    (use (label_ref (match_operand 1 "" "")))]
1310   ""
1311   "jump (%0);"
1312   [(set_attr "type" "misc")])
1313
1314 ;;  Call instructions..
1315
1316 (define_expand "call"
1317   [(parallel [(call (match_operand:SI 0 "" "")
1318                     (match_operand 1 "" ""))
1319               (use (match_operand 2 "" ""))])]
1320   ""
1321 {
1322   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 0);
1323   DONE;
1324 })
1325
1326 (define_expand "sibcall"
1327   [(parallel [(call (match_operand:SI 0 "" "")
1328                     (match_operand 1 "" ""))
1329               (use (match_operand 2 "" ""))
1330               (return)])]
1331   ""
1332 {
1333   bfin_expand_call (NULL_RTX, operands[0], operands[1], operands[2], 1);
1334   DONE;
1335 })
1336
1337 (define_expand "call_value"
1338   [(parallel [(set (match_operand 0 "register_operand" "")
1339                    (call (match_operand:SI 1 "" "")
1340                          (match_operand 2 "" "")))
1341               (use (match_operand 3 "" ""))])]
1342   ""
1343 {
1344   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 0);
1345   DONE;
1346 })
1347
1348 (define_expand "sibcall_value"
1349   [(parallel [(set (match_operand 0 "register_operand" "")
1350                    (call (match_operand:SI 1 "" "")
1351                          (match_operand 2 "" "")))
1352               (use (match_operand 3 "" ""))
1353               (return)])]
1354   ""
1355 {
1356   bfin_expand_call (operands[0], operands[1], operands[2], operands[3], 1);
1357   DONE;
1358 })
1359
1360 (define_insn "*call_symbol"
1361   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1362          (match_operand 1 "general_operand" "g"))
1363    (use (match_operand 2 "" ""))]
1364   "! SIBLING_CALL_P (insn)
1365    && !flag_pic
1366    && GET_CODE (operands[0]) == SYMBOL_REF
1367    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1368   "call %G0;"
1369   [(set_attr "type" "call")
1370    (set_attr "length" "4")])
1371
1372 (define_insn "*sibcall_symbol"
1373   [(call (mem:SI (match_operand:SI 0 "symbol_ref_operand" "Q"))
1374          (match_operand 1 "general_operand" "g"))
1375    (use (match_operand 2 "" ""))
1376    (return)]
1377   "SIBLING_CALL_P (insn)
1378    && !flag_pic
1379    && GET_CODE (operands[0]) == SYMBOL_REF
1380    && !bfin_longcall_p (operands[0], INTVAL (operands[2]))"
1381   "jump.l %G0;"
1382   [(set_attr "type" "br")
1383    (set_attr "length" "4")])
1384
1385 (define_insn "*call_value_symbol"
1386   [(set (match_operand 0 "register_operand" "=d")
1387         (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1388               (match_operand 2 "general_operand" "g")))
1389    (use (match_operand 3 "" ""))]
1390   "! SIBLING_CALL_P (insn)
1391    && !flag_pic
1392    && GET_CODE (operands[1]) == SYMBOL_REF
1393    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1394   "call %G1;"
1395   [(set_attr "type" "call")
1396    (set_attr "length" "4")])
1397
1398 (define_insn "*sibcall_value_symbol"
1399   [(set (match_operand 0 "register_operand" "=d")
1400          (call (mem:SI (match_operand:SI 1 "symbol_ref_operand" "Q"))
1401                (match_operand 2 "general_operand" "g")))
1402    (use (match_operand 3 "" ""))
1403    (return)]
1404   "SIBLING_CALL_P (insn)
1405    && !flag_pic
1406    && GET_CODE (operands[1]) == SYMBOL_REF
1407    && !bfin_longcall_p (operands[1], INTVAL (operands[3]))"
1408   "jump.l %G1;"
1409   [(set_attr "type" "br")
1410    (set_attr "length" "4")])
1411
1412 (define_insn "*call_insn"
1413   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "a"))
1414          (match_operand 1 "general_operand" "g"))
1415    (use (match_operand 2 "" ""))]
1416   "! SIBLING_CALL_P (insn)"
1417   "call (%0);"
1418   [(set_attr "type" "call")
1419    (set_attr "length" "2")])
1420
1421 (define_insn "*sibcall_insn"
1422   [(call (mem:SI (match_operand:SI 0 "register_no_elim_operand" "z"))
1423          (match_operand 1 "general_operand" "g"))
1424    (use (match_operand 2 "" ""))
1425    (return)]
1426   "SIBLING_CALL_P (insn)"
1427   "jump (%0);"
1428   [(set_attr "type" "br")
1429    (set_attr "length" "2")])
1430
1431 (define_insn "*call_value_insn"
1432   [(set (match_operand 0 "register_operand" "=d")
1433         (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "a"))
1434               (match_operand 2 "general_operand" "g")))
1435    (use (match_operand 3 "" ""))]
1436   "! SIBLING_CALL_P (insn)"
1437   "call (%1);"
1438   [(set_attr "type" "call")
1439    (set_attr "length" "2")])
1440
1441 (define_insn "*sibcall_value_insn"
1442   [(set (match_operand 0 "register_operand" "=d")
1443          (call (mem:SI (match_operand:SI 1 "register_no_elim_operand" "z"))
1444                (match_operand 2 "general_operand" "g")))
1445    (use (match_operand 3 "" ""))
1446    (return)]
1447   "SIBLING_CALL_P (insn)"
1448   "jump (%1);"
1449   [(set_attr "type" "br")
1450    (set_attr "length" "2")])
1451
1452 ;; Block move patterns
1453
1454 ;; We cheat.  This copies one more word than operand 2 indicates.
1455
1456 (define_insn "rep_movsi"
1457   [(set (match_operand:SI 0 "register_operand" "=&a")
1458         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1459                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1460                                      (const_int 2)))
1461                  (const_int 4)))
1462    (set (match_operand:SI 1 "register_operand" "=&b")
1463         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1464                           (ashift:SI (match_dup 2) (const_int 2)))
1465                  (const_int 4)))
1466    (set (mem:BLK (match_dup 3))
1467         (mem:BLK (match_dup 4)))
1468    (use (match_dup 2))
1469    (clobber (match_scratch:HI 5 "=&d"))]
1470   ""
1471   "%5 = [%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || [%3++] = %5 || %5 = [%4++]; [%3++] = %5;"
1472   [(set_attr "type" "misc")
1473    (set_attr "length" "16")])
1474
1475 (define_insn "rep_movhi"
1476   [(set (match_operand:SI 0 "register_operand" "=&a")
1477         (plus:SI (plus:SI (match_operand:SI 3 "register_operand" "0")
1478                           (ashift:SI (match_operand:SI 2 "register_operand" "a")
1479                                      (const_int 1)))
1480                  (const_int 2)))
1481    (set (match_operand:SI 1 "register_operand" "=&b")
1482         (plus:SI (plus:SI (match_operand:SI 4 "register_operand" "1")
1483                           (ashift:SI (match_dup 2) (const_int 1)))
1484                  (const_int 2)))
1485    (set (mem:BLK (match_dup 3))
1486         (mem:BLK (match_dup 4)))
1487    (use (match_dup 2))
1488    (clobber (match_scratch:HI 5 "=&d"))]
1489   ""
1490   "%h5 = W[%4++]; lsetup (1f, 1f) LC1 = %2; 1: MNOP || W [%3++] = %5 || %h5 = W [%4++]; W [%3++] = %5;"
1491   [(set_attr "type" "misc")
1492    (set_attr "length" "16")])
1493
1494 (define_expand "movstrsi"
1495   [(match_operand:BLK 0 "general_operand" "")
1496    (match_operand:BLK 1 "general_operand" "")
1497    (match_operand:SI 2 "const_int_operand" "")
1498    (match_operand:SI 3 "const_int_operand" "")]
1499   ""
1500 {
1501   if (bfin_expand_strmov (operands[0], operands[1], operands[2], operands[3]))
1502     DONE;
1503   FAIL;
1504 })
1505
1506 ;; Conditional branch patterns
1507 ;; The Blackfin has only few condition codes: eq, lt, lte, ltu, leu
1508
1509 ;; The only outcome of this pattern is that global variables
1510 ;; bfin_compare_op[01] are set for use in bcond patterns.
1511
1512 (define_expand "cmpbi"
1513  [(set (cc0) (compare (match_operand:BI 0 "register_operand" "")
1514                       (match_operand:BI 1 "immediate_operand" "")))]
1515  ""
1516 {
1517   bfin_compare_op0 = operands[0];
1518   bfin_compare_op1 = operands[1];
1519   DONE;
1520 })
1521
1522 (define_expand "cmpsi"
1523  [(set (cc0) (compare (match_operand:SI 0 "register_operand" "")
1524                       (match_operand:SI 1 "reg_or_const_int_operand" "")))]
1525  ""
1526 {
1527   bfin_compare_op0 = operands[0];
1528   bfin_compare_op1 = operands[1];
1529   DONE;
1530 })
1531
1532 (define_insn "compare_eq"
1533   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1534         (eq:BI (match_operand:SI 1 "register_operand" "d,a")
1535                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1536   ""
1537   "cc =%1==%2;"
1538   [(set_attr "type" "compare")])
1539
1540 (define_insn "compare_ne"
1541   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1542         (ne:BI (match_operand:SI 1 "register_operand" "d,a")
1543                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1544   "0"
1545   "cc =%1!=%2;"
1546   [(set_attr "type" "compare")])
1547
1548 (define_insn "compare_lt"
1549   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1550         (lt:BI (match_operand:SI 1 "register_operand" "d,a")
1551                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1552   ""
1553   "cc =%1<%2;"
1554   [(set_attr "type" "compare")])
1555
1556 (define_insn "compare_le"
1557   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1558         (le:BI (match_operand:SI 1 "register_operand" "d,a")
1559                (match_operand:SI 2 "reg_or_const_int_operand" "dKs3,aKs3")))]
1560   ""
1561   "cc =%1<=%2;"
1562   [(set_attr "type" "compare")])
1563
1564 (define_insn "compare_leu"
1565   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1566         (leu:BI (match_operand:SI 1 "register_operand" "d,a")
1567                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1568   ""
1569   "cc =%1<=%2 (iu);"
1570   [(set_attr "type" "compare")])
1571
1572 (define_insn "compare_ltu"
1573   [(set (match_operand:BI 0 "cc_operand" "=C,C")
1574         (ltu:BI (match_operand:SI 1 "register_operand" "d,a")
1575                 (match_operand:SI 2 "reg_or_const_int_operand" "dKu3,aKu3")))]
1576   ""
1577   "cc =%1<%2 (iu);"
1578   [(set_attr "type" "compare")])
1579
1580 (define_expand "beq"
1581   [(set (match_dup 1) (match_dup 2))
1582    (set (pc)
1583         (if_then_else (match_dup 3)
1584                    (label_ref (match_operand 0 "" ""))
1585                    (pc)))]
1586   ""
1587 {
1588   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
1589   operands[1] = bfin_cc_rtx;    /* hard register: CC */
1590   operands[2] = gen_rtx_EQ (BImode, op0, op1);
1591   /* If we have a BImode input, then we already have a compare result, and
1592      do not need to emit another comparison.  */
1593   if (GET_MODE (bfin_compare_op0) == BImode)
1594     {
1595       gcc_assert (bfin_compare_op1 == const0_rtx);
1596       emit_insn (gen_cbranchbi4 (operands[2], op0, op1, operands[0]));
1597       DONE;
1598     }
1599
1600   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1601 })
1602
1603 (define_expand "bne"
1604   [(set (match_dup 1) (match_dup 2))
1605    (set (pc)
1606         (if_then_else (match_dup 3)
1607                       (label_ref (match_operand 0 "" ""))
1608                     (pc)))]
1609   ""
1610 {
1611   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
1612   /* If we have a BImode input, then we already have a compare result, and
1613      do not need to emit another comparison.  */
1614   if (GET_MODE (bfin_compare_op0) == BImode)
1615     {
1616       rtx cmp = gen_rtx_NE (BImode, op0, op1);
1617
1618       gcc_assert (bfin_compare_op1 == const0_rtx);
1619       emit_insn (gen_cbranchbi4 (cmp, op0, op1, operands[0]));
1620       DONE;
1621     }
1622
1623   operands[1] = bfin_cc_rtx;    /* hard register: CC */
1624   operands[2] = gen_rtx_EQ (BImode, op0, op1);
1625   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1626 })
1627
1628 (define_expand "bgt"
1629   [(set (match_dup 1) (match_dup 2))
1630    (set (pc)
1631         (if_then_else (match_dup 3)
1632                       (label_ref (match_operand 0 "" ""))
1633                     (pc)))]
1634   ""
1635 {
1636   operands[1] = bfin_cc_rtx;
1637   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
1638   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1639 })
1640
1641 (define_expand "bgtu"
1642   [(set (match_dup 1) (match_dup 2))
1643    (set (pc)
1644         (if_then_else (match_dup 3)
1645                       (label_ref (match_operand 0 "" ""))
1646                     (pc)))]
1647   ""
1648 {
1649   operands[1] = bfin_cc_rtx;
1650   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
1651   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1652 })
1653
1654 (define_expand "blt"
1655   [(set (match_dup 1) (match_dup 2))
1656    (set (pc)
1657         (if_then_else (match_dup 3)
1658                       (label_ref (match_operand 0 "" ""))
1659                     (pc)))]
1660   ""
1661 {
1662   operands[1] = bfin_cc_rtx;
1663   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
1664   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1665 })
1666
1667 (define_expand "bltu"
1668   [(set (match_dup 1) (match_dup 2))
1669    (set (pc)
1670         (if_then_else (match_dup 3)
1671                       (label_ref (match_operand 0 "" ""))
1672                       (pc)))]
1673   ""
1674 {
1675   operands[1] = bfin_cc_rtx;
1676   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
1677   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1678 })
1679
1680
1681 (define_expand "bge"
1682   [(set (match_dup 1) (match_dup 2))
1683    (set (pc)
1684         (if_then_else (match_dup 3)
1685                       (label_ref (match_operand 0 "" ""))
1686                       (pc)))]
1687   ""
1688 {
1689   operands[1] = bfin_cc_rtx;
1690   operands[2] = gen_rtx_LT (BImode, bfin_compare_op0, bfin_compare_op1);
1691   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1692 })
1693
1694 (define_expand "bgeu"
1695   [(set (match_dup 1) (match_dup 2))
1696    (set (pc)
1697         (if_then_else (match_dup 3)
1698                       (label_ref (match_operand 0 "" ""))
1699                       (pc)))]
1700   ""
1701 {
1702   operands[1] = bfin_cc_rtx;
1703   operands[2] = gen_rtx_LTU (BImode, bfin_compare_op0, bfin_compare_op1);
1704   operands[3] = gen_rtx_EQ (BImode, operands[1], const0_rtx);
1705 })
1706
1707 (define_expand "ble"
1708   [(set (match_dup 1) (match_dup 2))
1709    (set (pc)
1710         (if_then_else (match_dup 3)
1711                       (label_ref (match_operand 0 "" ""))
1712                       (pc)))]
1713   ""
1714 {
1715   operands[1] = bfin_cc_rtx;
1716   operands[2] = gen_rtx_LE (BImode, bfin_compare_op0, bfin_compare_op1);
1717   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1718 })
1719
1720 (define_expand "bleu"
1721   [(set (match_dup 1) (match_dup 2))
1722    (set (pc)
1723         (if_then_else (match_dup 3)
1724                       (label_ref (match_operand 0 "" ""))
1725                       (pc)))
1726   ]
1727   ""
1728 {
1729   operands[1] = bfin_cc_rtx;
1730   operands[2] = gen_rtx_LEU (BImode, bfin_compare_op0, bfin_compare_op1);
1731   operands[3] = gen_rtx_NE (BImode, operands[1], const0_rtx);
1732 })
1733
1734 (define_insn "cbranchbi4"
1735   [(set (pc)
1736         (if_then_else
1737          (match_operator 0 "bfin_cbranch_operator"
1738                          [(match_operand:BI 1 "cc_operand" "C")
1739                           (match_operand:BI 2 "immediate_operand" "P0")])
1740          (label_ref (match_operand 3 "" ""))
1741          (pc)))]
1742   ""
1743 {
1744   asm_conditional_branch (insn, operands, 0, 0);
1745   return "";
1746 }
1747   [(set_attr "type" "brcc")])
1748
1749 ;; Special cbranch patterns to deal with the speculative load problem - see
1750 ;; bfin_reorg for details.
1751
1752 (define_insn "cbranch_predicted_taken"
1753   [(set (pc)
1754         (if_then_else
1755          (match_operator 0 "bfin_cbranch_operator"
1756                          [(match_operand:BI 1 "cc_operand" "C")
1757                           (match_operand:BI 2 "immediate_operand" "P0")])
1758          (label_ref (match_operand 3 "" ""))
1759          (pc)))
1760    (unspec [(const_int 0)] UNSPEC_CBRANCH_TAKEN)]
1761   ""
1762 {
1763   asm_conditional_branch (insn, operands, 0, 1);
1764   return "";
1765 }
1766   [(set_attr "type" "brcc")])
1767
1768 (define_insn "cbranch_with_nops"
1769   [(set (pc)
1770         (if_then_else
1771          (match_operator 0 "bfin_cbranch_operator"
1772                          [(match_operand:BI 1 "cc_operand" "C")
1773                           (match_operand:BI 2 "immediate_operand" "P0")])
1774          (label_ref (match_operand 3 "" ""))
1775          (pc)))
1776    (unspec [(match_operand 4 "immediate_operand" "")] UNSPEC_CBRANCH_NOPS)]
1777   "reload_completed"
1778 {
1779   asm_conditional_branch (insn, operands, INTVAL (operands[4]), 0);
1780   return "";
1781 }
1782   [(set_attr "type" "brcc")
1783    (set_attr "length" "6")])
1784
1785 ;; setcc insns.  */
1786 (define_expand "seq"
1787   [(set (match_dup 1) (eq:BI (match_dup 2) (match_dup 3)))
1788    (set (match_operand:SI 0 "register_operand" "")
1789         (ne:SI (match_dup 1) (const_int 0)))]
1790   ""
1791 {
1792   operands[2] = bfin_compare_op0;
1793   operands[3] = bfin_compare_op1;
1794   operands[1] = bfin_cc_rtx;
1795 })
1796
1797 (define_expand "slt"
1798   [(set (match_dup 1) (lt:BI (match_dup 2) (match_dup 3)))
1799    (set (match_operand:SI 0 "register_operand" "")
1800         (ne:SI (match_dup 1) (const_int 0)))]
1801   ""
1802 {
1803    operands[2] = bfin_compare_op0;
1804    operands[3] = bfin_compare_op1;
1805    operands[1] = bfin_cc_rtx;
1806 })
1807
1808 (define_expand "sle"
1809   [(set (match_dup 1) (le:BI (match_dup 2) (match_dup 3)))
1810    (set (match_operand:SI 0 "register_operand" "")
1811         (ne:SI (match_dup 1) (const_int 0)))]
1812   ""
1813 {
1814    operands[2] = bfin_compare_op0;
1815    operands[3] = bfin_compare_op1;
1816    operands[1] = bfin_cc_rtx;
1817 })
1818
1819 (define_expand "sltu"
1820   [(set (match_dup 1) (ltu:BI (match_dup 2) (match_dup 3)))
1821    (set (match_operand:SI 0 "register_operand" "")
1822         (ne:SI (match_dup 1) (const_int 0)))]
1823   ""
1824 {
1825    operands[2] = bfin_compare_op0;
1826    operands[3] = bfin_compare_op1;
1827    operands[1] = bfin_cc_rtx;
1828 })
1829
1830 (define_expand "sleu"
1831   [(set (match_dup 1) (leu:BI (match_dup 2) (match_dup 3)))
1832    (set (match_operand:SI 0 "register_operand" "")
1833         (ne:SI (match_dup 1) (const_int 0)))]
1834   ""
1835 {
1836    operands[2] = bfin_compare_op0;
1837    operands[3] = bfin_compare_op1;
1838    operands[1] = bfin_cc_rtx;
1839 })
1840
1841 (define_insn "nop"
1842   [(const_int 0)]
1843   ""
1844   "nop;")
1845
1846 ;;;;;;;;;;;;;;;;;;;;   CC2dreg   ;;;;;;;;;;;;;;;;;;;;;;;;;
1847 (define_insn "movsibi"
1848   [(set (match_operand:BI 0 "cc_operand" "=C")
1849         (ne:BI (match_operand:SI 1 "register_operand" "d")
1850                (const_int 0)))]
1851   ""
1852   "CC = %1;"
1853   [(set_attr "length" "2")])
1854
1855 (define_insn "movbisi"
1856   [(set (match_operand:SI 0 "register_operand" "=d")
1857         (ne:SI (match_operand:BI 1 "cc_operand" "C")
1858                (const_int 0)))]
1859   ""
1860   "%0 = CC;"
1861   [(set_attr "length" "2")])
1862
1863 (define_insn ""
1864   [(set (match_operand:BI 0 "cc_operand" "=C")
1865         (eq:BI (match_operand:BI 1 "cc_operand" " 0")
1866                (const_int 0)))]
1867   ""
1868   "%0 = ! %0;"    /*  NOT CC;"  */
1869   [(set_attr "type" "compare")])
1870
1871 ;; Vector and DSP insns
1872
1873 (define_insn ""
1874   [(set (match_operand:SI 0 "register_operand" "=d")
1875         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
1876                            (const_int 24))
1877                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
1878                              (const_int 8))))]
1879   ""
1880   "%0 = ALIGN8(%1, %2);"
1881   [(set_attr "type" "dsp32")])
1882
1883 (define_insn ""
1884   [(set (match_operand:SI 0 "register_operand" "=d")
1885         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
1886                            (const_int 16))
1887                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
1888                              (const_int 16))))]
1889   ""
1890   "%0 = ALIGN16(%1, %2);"
1891   [(set_attr "type" "dsp32")])
1892
1893 (define_insn ""
1894   [(set (match_operand:SI 0 "register_operand" "=d")
1895         (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d")
1896                            (const_int 8))
1897                 (lshiftrt:SI (match_operand:SI 2 "register_operand" "d")
1898                              (const_int 24))))]
1899   ""
1900   "%0 = ALIGN24(%1, %2);"
1901   [(set_attr "type" "dsp32")])
1902
1903 ;; Prologue and epilogue.
1904
1905 (define_expand "prologue"
1906   [(const_int 1)]
1907   ""
1908   "bfin_expand_prologue (); DONE;")
1909
1910 (define_expand "epilogue"
1911   [(const_int 1)]
1912   ""
1913   "bfin_expand_epilogue (1, 0); DONE;")
1914
1915 (define_expand "sibcall_epilogue"
1916   [(const_int 1)]
1917   ""
1918   "bfin_expand_epilogue (0, 0); DONE;")
1919
1920 (define_expand "eh_return"
1921   [(unspec_volatile [(match_operand:SI 0 "register_operand" "")]
1922                     UNSPEC_VOLATILE_EH_RETURN)]
1923   ""
1924 {
1925   emit_move_insn (EH_RETURN_HANDLER_RTX, operands[0]);
1926   emit_insn (gen_eh_return_internal ());
1927   emit_barrier ();
1928   DONE;
1929 })
1930
1931 (define_insn_and_split "eh_return_internal"
1932   [(unspec_volatile [(reg:SI REG_P2)] UNSPEC_VOLATILE_EH_RETURN)]
1933   ""
1934   "#"
1935   "reload_completed"
1936   [(const_int 1)]
1937   "bfin_expand_epilogue (1, 1); DONE;")
1938
1939 (define_insn "link"
1940   [(set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -4))) (reg:SI REG_RETS))
1941    (set (mem:SI (plus:SI (reg:SI REG_SP) (const_int -8))) (reg:SI REG_FP))
1942    (set (reg:SI REG_FP)
1943         (plus:SI (reg:SI REG_SP) (const_int -8)))
1944    (set (reg:SI REG_SP)
1945         (plus:SI (reg:SI REG_SP) (match_operand:SI 0 "immediate_operand" "i")))]
1946   ""
1947   "LINK %Z0;"
1948   [(set_attr "length" "4")])
1949
1950 (define_insn "unlink"
1951   [(set (reg:SI REG_FP) (mem:SI (reg:SI REG_FP)))
1952    (set (reg:SI REG_RETS) (mem:SI (plus:SI (reg:SI REG_FP) (const_int 4))))
1953    (set (reg:SI REG_SP) (plus:SI (reg:SI REG_FP) (const_int 8)))]
1954   ""
1955   "UNLINK;"
1956   [(set_attr "length" "4")])
1957
1958 ;; This pattern is slightly clumsy.  The stack adjust must be the final SET in
1959 ;; the pattern, otherwise dwarf2out becomes very confused about which reg goes
1960 ;; where on the stack, since it goes through all elements of the parallel in
1961 ;; sequence.
1962 (define_insn "push_multiple"
1963   [(match_parallel 0 "push_multiple_operation"
1964     [(unspec [(match_operand:SI 1 "immediate_operand" "i")] UNSPEC_PUSH_MULTIPLE)])]
1965   ""
1966 {
1967   output_push_multiple (insn, operands);
1968   return "";
1969 })
1970
1971 (define_insn "pop_multiple"
1972   [(match_parallel 0 "pop_multiple_operation"
1973     [(set (reg:SI REG_SP)
1974           (plus:SI (reg:SI REG_SP) (match_operand:SI 1 "immediate_operand" "i")))])]
1975   ""
1976 {
1977   output_pop_multiple (insn, operands);
1978   return "";
1979 })
1980
1981 (define_insn "return_internal"
1982   [(return)
1983    (unspec [(match_operand 0 "immediate_operand" "i")] UNSPEC_RETURN)]
1984   "reload_completed"
1985 {
1986   switch (INTVAL (operands[0]))
1987     {
1988     case EXCPT_HANDLER:
1989       return "rtx;";
1990     case NMI_HANDLER:
1991       return "rtn;";
1992     case INTERRUPT_HANDLER:
1993       return "rti;";
1994     case SUBROUTINE:
1995       return "rts;";
1996     }
1997   gcc_unreachable ();
1998 })
1999
2000 (define_insn "csync"
2001   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_CSYNC)]
2002   ""
2003   "csync;"
2004   [(set_attr "type" "sync")])
2005
2006 (define_insn "ssync"
2007   [(unspec_volatile [(const_int 0)] UNSPEC_VOLATILE_SSYNC)]
2008   ""
2009   "ssync;"
2010   [(set_attr "type" "sync")])
2011
2012 (define_insn "trap"
2013   [(trap_if (const_int 1) (const_int 3))]
2014   ""
2015   "excpt 3;"
2016   [(set_attr "type" "misc")
2017    (set_attr "length" "2")])
2018
2019 (define_insn "trapifcc"
2020   [(trap_if (reg:BI REG_CC) (const_int 3))]
2021   ""
2022   "if !cc jump 4 (bp); excpt 3;"
2023   [(set_attr "type" "misc")
2024    (set_attr "length" "4")])
2025
2026 ;;; Vector instructions
2027
2028 (define_insn "addv2hi3"
2029   [(set (match_operand:V2HI 0 "register_operand" "=d")
2030         (plus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2031                    (match_operand:V2HI 2 "register_operand" "d")))]
2032   ""
2033   "%0 = %1 +|+ %2;"
2034   [(set_attr "type" "dsp32")])
2035
2036 (define_insn "subv2hi3"
2037   [(set (match_operand:V2HI 0 "register_operand" "=d")
2038         (minus:V2HI (match_operand:V2HI 1 "register_operand" "d")
2039                    (match_operand:V2HI 2 "register_operand" "d")))]
2040   ""
2041   "%0 = %1 -|- %2;"
2042   [(set_attr "type" "dsp32")])
2043
2044 (define_insn "sminv2hi3"
2045   [(set (match_operand:V2HI 0 "register_operand" "=d")
2046         (smin:V2HI (match_operand:V2HI 1 "register_operand" "d")
2047                    (match_operand:V2HI 2 "register_operand" "d")))]
2048   ""
2049   "%0 = MIN (%1, %2) (V);"
2050   [(set_attr "type" "dsp32")])
2051
2052 (define_insn "smaxv2hi3"
2053   [(set (match_operand:V2HI 0 "register_operand" "=d")
2054         (smax:V2HI (match_operand:V2HI 1 "register_operand" "d")
2055                    (match_operand:V2HI 2 "register_operand" "d")))]
2056   ""
2057   "%0 = MAX (%1, %2) (V);"
2058   [(set_attr "type" "dsp32")])
2059
2060 (define_insn "mulv2hi3"
2061   [(set (match_operand:V2HI 0 "register_operand" "=d")
2062         (mult:V2HI (match_operand:V2HI 1 "register_operand" "d")
2063                    (match_operand:V2HI 2 "register_operand" "d")))]
2064   ""
2065   "%h0 = %h1 * %h2, %d0 = %d1 * %d2 (IS);"
2066   [(set_attr "type" "dsp32")])
2067
2068 (define_insn "negv2hi2"
2069   [(set (match_operand:V2HI 0 "register_operand" "=d")
2070         (neg:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
2071   ""
2072   "%0 = - %1 (V);"
2073   [(set_attr "type" "dsp32")])
2074
2075 (define_insn "absv2hi2"
2076   [(set (match_operand:V2HI 0 "register_operand" "=d")
2077         (abs:V2HI (match_operand:V2HI 1 "register_operand" "d")))]
2078   ""
2079   "%0 = ABS %1 (V);"
2080   [(set_attr "type" "dsp32")])
2081