gcc/config/arm/arm.md

   1 ;;- Machine description for Advanced RISC Machines' ARM for GNU compiler
   2 ;;  Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
   3 ;;  Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
   4 ;;             and Martin Simmons (@harleqn.co.uk).
   5 ;;  More major hacks by Richard Earnshaw (rwe11@cl.cam.ac.uk)
   6
   7 ;; This file is part of GNU CC.
   8
   9 ;; GNU CC is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU CC is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU CC; see the file COPYING.  If not, write to
  21 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22
  23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  24
  25 ;; There are patterns in this file to support XFmode arithmetic.
  26 ;; Unfortunately RISC iX doesn't work well with these so they are disabled.
  27 ;; (See arm.h)
  28 \f
  29 ;; UNSPEC Usage:
  30 ;; 0 `sin' operation: operand 0 is the result, operand 1 the parameter,
  31 ;;   the mode is MODE_FLOAT
  32 ;; 1 `cos' operation: operand 0 is the result, operand 1 the parameter,
  33 ;;   the mode is MODE_FLOAT
  34 ;; 2 `push multiple' operation: operand 0 is the first register.  Subsequent
  35 ;;   registers are in parallel (use...) expressions.
  36 \f
  37 ;; Attributes
  38
  39 ; condition codes: this one is used by final_prescan_insn to speed up
  40 ; conditionalizing instructions.  It saves having to scan the rtl to see if
  41 ; it uses or alters the condition codes.
  42
  43 ; USE means that the condition codes are used by the insn in the process of
  44 ; outputting code, this means (at present) that we can't use the insn in
  45 ; inlined branches
  46
  47 ; SET means that the purpose of the insn is to set the condition codes in a
  48 ; well defined manner.
  49
  50 ; CLOB means that the condition codes are altered in an undefined manner, if
  51 ; they are altered at all
  52
  53 ; JUMP_CLOB is used when the conditions are not defined if a branch is taken,
  54 ; but are if the branch wasn't taken; the effect is to limit the branch
  55 ; elimination scanning.
  56
  57 ; NOCOND means that the condition codes are niether altered nor affect the
  58 ; output of this insn
  59
  60 (define_attr "conds" "use,set,clob,jump_clob,nocond"
  61         (const_string "nocond"))
  62
  63 ; CPU attribute is used to determine whether condition codes are clobbered
  64 ; by a call insn: on the arm6 they are if in 32-bit addressing mode; on the
  65 ; arm2 and arm3 the condition codes are restored by the return.
  66
  67 (define_attr "cpu" "arm2,arm3,arm6" (const (symbol_ref "arm_cpu_attr")))
  68
  69 ; Floating Point Unit.  If we only have floating point emulation, then there
  70 ; is no point in scheduling the floating point insns.  (Well, for best
  71 ; performance we should try and group them together).
  72
  73 (define_attr "fpu" "fpa,fpe" (const (symbol_ref "arm_fpu_attr")))
  74
  75 ; LENGTH of an instruction (in bytes)
  76 (define_attr "length" "" (const_int 4))
  77
  78 ; An assembler sequence may clobber the condition codes without us knowing
  79 (define_asm_attributes
  80  [(set_attr "conds" "clob")
  81   (set_attr "length" "4")])
  82
  83 ; TYPE attribute is used to detect floating point instructions which, if
  84 ; running on a co-processor can run in parallel with other, basic instructions
  85 ; If write-buffer scheduling is enabled then it can also be used in the
  86 ; scheduling of writes.
  87
  88 ; Classification of each insn
  89 ; normal        any data instruction that doesn't hit memory or fp regs
  90 ; block         blockage insn, this blocks all functional units
  91 ; float         a floating point arithmetic operation (subject to expansion)
  92 ; fdivx         XFmode floating point division
  93 ; fdivd         DFmode floating point division
  94 ; fdivs         SFmode floating point division
  95 ; fmul          Floating point multiply
  96 ; ffmul         Fast floating point multiply
  97 ; farith        Floating point arithmetic (4 cycle)
  98 ; ffarith       Fast floating point arithmetic (2 cycle)
  99 ; float_em      a floating point arithmetic operation that is normally emulated
 100 ;               even on a machine with an fpa.
 101 ; f_load        a floating point load from memory
 102 ; f_store       a floating point store to memory
 103 ; f_mem_r       a transfer of a floating point register to a real reg via mem
 104 ; r_mem_f       the reverse of f_mem_r
 105 ; f_2_r         fast transfer float to arm (no memory needed)
 106 ; r_2_f         fast transfer arm to float
 107 ; call          a subroutine call
 108 ; load          any load from memory
 109 ; store1        store 1 word to memory from arm registers
 110 ; store2        store 2 words
 111 ; store3        store 3 words
 112 ; store4        store 4 words
 113 ;
 114 (define_attr "type"
 115         "normal,block,float,fdivx,fdivd,fdivs,fmul,ffmul,farith,ffarith,float_em,f_load,f_store,f_mem_r,r_mem_f,f_2_r,r_2_f,call,load,store1,store2,store3,store4"
 116         (const_string "normal"))
 117
 118 (define_attr "write_conflict" "no,yes"
 119   (if_then_else (eq_attr "type"
 120                  "block,float_em,f_load,f_store,f_mem_r,r_mem_f,call,load")
 121                 (const_string "yes")
 122                 (const_string "no")))
 123
 124 ; The write buffer on some of the arm6 processors is hard to model exactly.
 125 ; There is room in the buffer for up to two addresses and up to eight words
 126 ; of memory, but the two needn't be split evenly.  When writing the two
 127 ; addresses are fully pipelined.  However, a read from memory that is not
 128 ; currently in the cache will block until the writes have completed.
 129 ; It is normally the case that FCLK and MCLK will be in the ratio 2:1, so
 130 ; writes will take 2 FCLK cycles per word, if FCLK and MCLK are asynchronous
 131 ; (they aren't allowed to be at present) then there is a startup cost of 1MCLK
 132 ; cycle to add as well.
 133
 134 ;; (define_function_unit {name} {num-units} {n-users} {test}
 135 ;;                       {ready-delay} {issue-delay} [{conflict-list}])
 136 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 137                                      (eq_attr "type" "fdivx")) 71 69)
 138
 139 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 140                                      (eq_attr "type" "fdivd")) 59 57)
 141
 142 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 143                                      (eq_attr "type" "fdivs")) 31 29)
 144
 145 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 146                                      (eq_attr "type" "fmul")) 9 7)
 147
 148 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 149                                      (eq_attr "type" "ffmul")) 6 4)
 150
 151 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 152                                      (eq_attr "type" "farith")) 4 2)
 153
 154 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 155                                      (eq_attr "type" "ffarith")) 2 2)
 156
 157 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 158                                      (eq_attr "type" "r_2_f")) 5 3)
 159
 160 (define_function_unit "fpa" 1 0 (and (eq_attr "fpu" "fpa")
 161                                      (eq_attr "type" "f_2_r")) 1 2)
 162
 163 ;; The fpa10 doesn't really have a memory read unit, but it can start to
 164 ;; speculatively execute the instruction in the pipeline, provided the data
 165 ;; is already loaded, so pretend reads have a delay of 2 (and that the
 166 ;; pipeline is infinite.
 167
 168 (define_function_unit "fpa_mem" 1 0 (and (eq_attr "fpu" "fpa")
 169                                          (eq_attr "type" "f_load")) 3 1)
 170
 171 (define_function_unit "write_buf" 1 2 (eq_attr "type" "store1") 3 3
 172         [(eq_attr "write_conflict" "yes")])
 173 (define_function_unit "write_buf" 1 2 (eq_attr "type" "store2") 5 5
 174         [(eq_attr "write_conflict" "yes")])
 175 (define_function_unit "write_buf" 1 2 (eq_attr "type" "store3") 7 7
 176         [(eq_attr "write_conflict" "yes")])
 177 (define_function_unit "write_buf" 1 2 (eq_attr "type" "store4") 9 9
 178         [(eq_attr "write_conflict" "yes")])
 179 (define_function_unit "write_buf" 1 2 (eq_attr "type" "r_mem_f") 3 3
 180         [(eq_attr "write_conflict" "yes")])
 181 \f
 182 ;; Note: For DImode insns, there is normally no reason why operands should
 183 ;; not be in the same register, what we don't want is for something being
 184 ;; written to partially overlap something that is an input.
 185
 186 ;; Addition insns.
 187
 188 (define_insn "adddi3"
 189   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 190         (plus:DI (match_operand:DI 1 "s_register_operand" "%0,0")
 191                  (match_operand:DI 2 "s_register_operand" "r,0")))
 192    (clobber (reg:CC 24))]
 193   ""
 194   "adds\\t%0, %1, %2\;adc\\t%R0, %R1, %R2"
 195 [(set_attr "conds" "clob")
 196  (set_attr "length" "8")])
 197
 198 (define_insn ""
 199   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 200         (plus:DI (sign_extend:DI
 201                   (match_operand:SI 1 "s_register_operand" "r,r"))
 202                  (match_operand:DI 2 "s_register_operand" "r,0")))
 203    (clobber (reg:CC 24))]
 204   ""
 205   "adds\\t%0, %2, %1\;adc\\t%R0, %R2, %1, asr #31"
 206 [(set_attr "conds" "clob")
 207  (set_attr "length" "8")])
 208
 209 (define_insn ""
 210   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 211         (plus:DI (zero_extend:DI
 212                   (match_operand:SI 1 "s_register_operand" "r,r"))
 213                  (match_operand:DI 2 "s_register_operand" "r,0")))
 214    (clobber (reg:CC 24))]
 215   ""
 216   "adds\\t%0, %2, %1\;adc\\t%R0, %R2, #0"
 217 [(set_attr "conds" "clob")
 218  (set_attr "length" "8")])
 219
 220 (define_expand "addsi3"
 221   [(set (match_operand:SI 0 "s_register_operand" "")
 222         (plus:SI (match_operand:SI 1 "s_register_operand" "")
 223                  (match_operand:SI 2 "reg_or_int_operand" "")))]
 224   ""
 225   "
 226   if (GET_CODE (operands[2]) == CONST_INT)
 227     {
 228       arm_split_constant (PLUS, SImode, INTVAL (operands[2]), operands[0],
 229                           operands[1],
 230                           (reload_in_progress || reload_completed ? 0
 231                            : preserve_subexpressions_p ()));
 232       DONE;
 233     }
 234 ")
 235
 236 (define_split
 237   [(set (match_operand:SI 0 "s_register_operand" "")
 238         (plus:SI (match_operand:SI 1 "s_register_operand" "")
 239                  (match_operand:SI 2 "const_int_operand" "")))]
 240   "! (const_ok_for_arm (INTVAL (operands[2]))
 241       || const_ok_for_arm (-INTVAL (operands[2])))"
 242   [(clobber (const_int 0))]
 243   "
 244   arm_split_constant (PLUS, SImode, INTVAL (operands[2]), operands[0],
 245                       operands[1], 0);
 246   DONE;
 247 ")
 248
 249 (define_insn ""
 250   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
 251         (plus:SI (match_operand:SI 1 "s_register_operand" "r,r,r")
 252                  (match_operand:SI 2 "reg_or_int_operand" "rI,L,?n")))]
 253   ""
 254   "@
 255    add%?\\t%0, %1, %2
 256    sub%?\\t%0, %1, #%n2
 257    #"
 258 [(set_attr "length" "4,4,16")])
 259
 260 (define_insn ""
 261   [(set (reg:CC_NOOV 24)
 262         (compare:CC_NOOV
 263          (plus:SI (match_operand:SI 1 "s_register_operand" "r,r")
 264                   (match_operand:SI 2 "arm_add_operand" "rI,L"))
 265          (const_int 0)))
 266    (set (match_operand:SI 0 "s_register_operand" "=r,r")
 267         (plus:SI (match_dup 1) (match_dup 2)))]
 268   ""
 269   "@
 270    add%?s\\t%0, %1, %2
 271    sub%?s\\t%0, %1, #%n2"
 272 [(set_attr "conds" "set")])
 273
 274 (define_insn ""
 275   [(set (reg:CC 24)
 276         (compare:CC (match_operand:SI 1 "s_register_operand" "r,r")
 277                     (neg:SI (match_operand:SI 2 "arm_add_operand" "rI,L"))))
 278    (set (match_operand:SI 0 "s_register_operand" "=r,r")
 279         (plus:SI (match_dup 1) (match_dup 2)))]
 280   ""
 281   "@
 282    add%?s\\t%0, %1, %2
 283    sub%?s\\t%0, %1, #%n2"
 284 [(set_attr "conds" "set")])
 285
 286 (define_insn "incscc"
 287   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
 288         (plus:SI (match_operator:SI 2 "comparison_operator"
 289                     [(reg 24) (const_int 0)])
 290                  (match_operand:SI 1 "s_register_operand" "0,?r")))]
 291   ""
 292   "@
 293   add%d2\\t%0, %1, #1
 294   mov%D2\\t%0, %1\;add%d2\\t%0, %1, #1"
 295 [(set_attr "conds" "use")
 296  (set_attr "length" "4,8")])
 297
 298 ; If a constant is too big to fit in a single instruction then the constant
 299 ; will be pre-loaded into a register taking at least two insns, we might be
 300 ; able to merge it with an add, but it depends on the exact value.
 301
 302 (define_split
 303   [(set (match_operand:SI 0 "s_register_operand" "=r")
 304         (plus:SI (match_operand:SI 1 "s_register_operand" "r")
 305                  (match_operand:SI 2 "immediate_operand" "n")))]
 306   "!(const_ok_for_arm (INTVAL (operands[2]))
 307      || const_ok_for_arm (-INTVAL (operands[2])))"
 308   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))
 309    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 3)))]
 310   "
 311 {
 312   unsigned int val = (unsigned) INTVAL (operands[2]);
 313   int i;
 314   unsigned int temp;
 315
 316   /* this code is similar to the approach followed in movsi, but it must
 317      generate exactly two insns */
 318
 319   for (i = 30; i >= 0; i -= 2)
 320     {
 321       if (val & (3 << i))
 322         {
 323           i -= 6;
 324           if (i < 0) i = 0;
 325           if (const_ok_for_arm (temp = (val & ~(255 << i))))
 326             {
 327               val &= 255 << i;
 328               break;
 329             }
 330           /* we might be able to do this as (larger number - small number) */
 331           temp = ((val >> i) & 255) + 1;
 332           if (temp > 255 && i < 24)
 333             {
 334               i += 2;
 335               temp = ((val >> i) & 255) + 1;
 336             }
 337           if (const_ok_for_arm ((temp << i) - val))
 338             {
 339               i = temp << i;
 340               temp = (unsigned) - (int) (i - val);
 341               val = i;
 342               break;
 343             }
 344           FAIL;
 345         }
 346     }
 347   /* if we got here, we have found a way of doing it in two instructions.
 348      the two constants are in val and temp */
 349   operands[2] = GEN_INT ((int)val);
 350   operands[3] = GEN_INT ((int)temp);
 351 }
 352 ")
 353
 354 (define_insn "addsf3"
 355   [(set (match_operand:SF 0 "s_register_operand" "=f,f")
 356         (plus:SF (match_operand:SF 1 "s_register_operand" "f,f")
 357                  (match_operand:SF 2 "fpu_add_operand" "fG,H")))]
 358   ""
 359   "@
 360    adf%?s\\t%0, %1, %2
 361    suf%?s\\t%0, %1, #%N2"
 362 [(set_attr "type" "farith")])
 363
 364 (define_insn "adddf3"
 365   [(set (match_operand:DF 0 "s_register_operand" "=f,f")
 366         (plus:DF (match_operand:DF 1 "s_register_operand" "f,f")
 367                  (match_operand:DF 2 "fpu_add_operand" "fG,H")))]
 368   ""
 369   "@
 370    adf%?d\\t%0, %1, %2
 371    suf%?d\\t%0, %1, #%N2"
 372 [(set_attr "type" "farith")])
 373
 374 (define_insn ""
 375   [(set (match_operand:DF 0 "s_register_operand" "=f,f")
 376         (plus:DF (float_extend:DF
 377                   (match_operand:SF 1 "s_register_operand" "f,f"))
 378                  (match_operand:DF 2 "fpu_add_operand" "fG,H")))]
 379   ""
 380   "@
 381    adf%?d\\t%0, %1, %2
 382    suf%?d\\t%0, %1, #%N2"
 383 [(set_attr "type" "farith")])
 384
 385 (define_insn ""
 386   [(set (match_operand:DF 0 "s_register_operand" "=f")
 387         (plus:DF (match_operand:DF 1 "s_register_operand" "f")
 388                  (float_extend:DF
 389                   (match_operand:SF 2 "s_register_operand" "f"))))]
 390   ""
 391   "adf%?d\\t%0, %1, %2"
 392 [(set_attr "type" "farith")])
 393
 394 (define_insn ""
 395   [(set (match_operand:DF 0 "s_register_operand" "=f")
 396         (plus:DF (float_extend:DF
 397                   (match_operand:SF 1 "s_register_operand" "f"))
 398                  (float_extend:DF
 399                   (match_operand:SF 2 "s_register_operand" "f"))))]
 400   ""
 401   "adf%?d\\t%0, %1, %2"
 402 [(set_attr "type" "farith")])
 403
 404 (define_insn "addxf3"
 405   [(set (match_operand:XF 0 "s_register_operand" "=f,f")
 406         (plus:XF (match_operand:XF 1 "s_register_operand" "f,f")
 407                  (match_operand:XF 2 "fpu_add_operand" "fG,H")))]
 408   "ENABLE_XF_PATTERNS"
 409   "@
 410    adf%?e\\t%0, %1, %2
 411    suf%?e\\t%0, %1, #%N2"
 412 [(set_attr "type" "farith")])
 413
 414 (define_insn "subdi3"
 415   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r,&r")
 416         (minus:DI (match_operand:DI 1 "s_register_operand" "0,r,0")
 417                   (match_operand:DI 2 "s_register_operand" "r,0,0")))
 418    (clobber (reg:CC 24))]
 419   ""
 420   "subs\\t%0, %1, %2\;sbc\\t%R0, %R1, %R2"
 421 [(set_attr "conds" "clob")
 422  (set_attr "length" "8")])
 423
 424 (define_insn ""
 425   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 426         (minus:DI (match_operand:DI 1 "s_register_operand" "?r,0")
 427                   (zero_extend:DI
 428                    (match_operand:SI 2 "s_register_operand" "r,r"))))
 429    (clobber (reg:CC 24))]
 430   ""
 431   "subs\\t%0, %1, %2\;sbc\\t%R0, %R1, #0"
 432 [(set_attr "conds" "clob")
 433  (set_attr "length" "8")])
 434
 435 (define_insn ""
 436   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 437         (minus:DI (match_operand:DI 1 "s_register_operand" "r,0")
 438                   (sign_extend:DI
 439                    (match_operand:SI 2 "s_register_operand" "r,r"))))
 440    (clobber (reg:CC 24))]
 441   ""
 442   "subs\\t%0, %1, %2\;sbc\\t%R0, %R1, %2, asr #31"
 443 [(set_attr "conds" "clob")
 444  (set_attr "length" "8")])
 445
 446 (define_insn ""
 447   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 448         (minus:DI (zero_extend:DI
 449                    (match_operand:SI 2 "s_register_operand" "r,r"))
 450                   (match_operand:DI 1 "s_register_operand" "?r,0")))
 451    (clobber (reg:CC 24))]
 452   ""
 453   "rsbs\\t%0, %1, %2\;rsc\\t%R0, %R1, #0"
 454 [(set_attr "conds" "clob")
 455  (set_attr "length" "8")])
 456
 457 (define_insn ""
 458   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 459         (minus:DI (sign_extend:DI
 460                    (match_operand:SI 2 "s_register_operand" "r,r"))
 461                   (match_operand:DI 1 "s_register_operand" "?r,0")))
 462    (clobber (reg:CC 24))]
 463   ""
 464   "rsbs\\t%0, %1, %2\;rsc\\t%R0, %R1, %2, asr #31"
 465 [(set_attr "conds" "clob")
 466  (set_attr "length" "8")])
 467
 468 (define_insn ""
 469   [(set (match_operand:DI 0 "s_register_operand" "=r")
 470         (minus:DI (zero_extend:DI
 471                    (match_operand:SI 1 "s_register_operand" "r"))
 472                   (zero_extend:DI
 473                    (match_operand:SI 2 "s_register_operand" "r"))))
 474    (clobber (reg:CC 24))]
 475   ""
 476   "subs\\t%0, %1, %2\;rsc\\t%R0, %1, %1"
 477 [(set_attr "conds" "clob")
 478  (set_attr "length" "8")])
 479
 480 (define_expand "subsi3"
 481   [(set (match_operand:SI 0 "s_register_operand" "")
 482         (minus:SI (match_operand:SI 1 "reg_or_int_operand" "")
 483                   (match_operand:SI 2 "s_register_operand" "")))]
 484   ""
 485   "
 486   if (GET_CODE (operands[1]) == CONST_INT)
 487     {
 488       arm_split_constant (MINUS, SImode, INTVAL (operands[1]), operands[0],
 489                           operands[2],
 490                           (reload_in_progress || reload_completed ? 0
 491                            : preserve_subexpressions_p ()));
 492       DONE;
 493     }
 494 ")
 495
 496 (define_insn ""
 497   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
 498         (minus:SI (match_operand:SI 1 "reg_or_int_operand" "rI,?n")
 499                   (match_operand:SI 2 "s_register_operand" "r,r")))]
 500   ""
 501   "@
 502    rsb%?\\t%0, %2, %1
 503    #"
 504 [(set_attr "length" "4,16")])
 505
 506 (define_split
 507   [(set (match_operand:SI 0 "s_register_operand" "")
 508         (minus:SI (match_operand:SI 1 "const_int_operand" "")
 509                   (match_operand:SI 2 "s_register_operand" "")))]
 510   "! const_ok_for_arm (INTVAL (operands[1]))"
 511   [(clobber (const_int 0))]
 512   "
 513   arm_split_constant (MINUS, SImode, INTVAL (operands[1]), operands[0],
 514                       operands[2], 0);
 515   DONE;
 516 ")
 517
 518 (define_insn ""
 519   [(set (reg:CC_NOOV 24)
 520         (compare:CC_NOOV (minus:SI (match_operand:SI 1 "arm_rhs_operand" "r,I")
 521                                  (match_operand:SI 2 "arm_rhs_operand" "rI,r"))
 522                          (const_int 0)))
 523    (set (match_operand:SI 0 "s_register_operand" "=r,r")
 524         (minus:SI (match_dup 1) (match_dup 2)))]
 525   ""
 526   "@
 527    sub%?s\\t%0, %1, %2
 528    rsb%?s\\t%0, %2, %1"
 529 [(set_attr "conds" "set")])
 530
 531 (define_insn "decscc"
 532   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
 533         (minus:SI (match_operand:SI 1 "s_register_operand" "0,?r")
 534                   (match_operator:SI 2 "comparison_operator"
 535                    [(reg 24) (const_int 0)])))]
 536   ""
 537   "@
 538   sub%d2\\t%0, %1, #1
 539   mov%D2\\t%0, %1\;sub%d2\\t%0, %1, #1"
 540 [(set_attr "conds" "use")
 541  (set_attr "length" "*,8")])
 542
 543 (define_insn "subsf3"
 544   [(set (match_operand:SF 0 "s_register_operand" "=f,f")
 545         (minus:SF (match_operand:SF 1 "fpu_rhs_operand" "f,G")
 546                   (match_operand:SF 2 "fpu_rhs_operand" "fG,f")))]
 547   ""
 548   "@
 549    suf%?s\\t%0, %1, %2
 550    rsf%?s\\t%0, %2, %1"
 551 [(set_attr "type" "farith")])
 552
 553 (define_insn "subdf3"
 554   [(set (match_operand:DF 0 "s_register_operand" "=f,f")
 555         (minus:DF (match_operand:DF 1 "fpu_rhs_operand" "f,G")
 556                   (match_operand:DF 2 "fpu_rhs_operand" "fG,f")))]
 557   ""
 558   "@
 559    suf%?d\\t%0, %1, %2
 560    rsf%?d\\t%0, %2, %1"
 561 [(set_attr "type" "farith")])
 562
 563 (define_insn ""
 564   [(set (match_operand:DF 0 "s_register_operand" "=f")
 565         (minus:DF (float_extend:DF
 566                    (match_operand:SF 1 "s_register_operand" "f"))
 567                   (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 568   ""
 569   "suf%?d\\t%0, %1, %2"
 570 [(set_attr "type" "farith")])
 571
 572 (define_insn ""
 573   [(set (match_operand:DF 0 "s_register_operand" "=f,f")
 574         (minus:DF (match_operand:DF 1 "fpu_rhs_operand" "f,G")
 575                   (float_extend:DF
 576                    (match_operand:SF 2 "s_register_operand" "f,f"))))]
 577   ""
 578   "@
 579    suf%?d\\t%0, %1, %2
 580    rsf%?d\\t%0, %2, %1"
 581 [(set_attr "type" "farith")])
 582
 583 (define_insn ""
 584   [(set (match_operand:DF 0 "s_register_operand" "=f")
 585         (minus:DF (float_extend:DF
 586                    (match_operand:SF 1 "s_register_operand" "f"))
 587                   (float_extend:DF
 588                    (match_operand:SF 2 "s_register_operand" "f"))))]
 589   ""
 590   "suf%?d\\t%0, %1, %2"
 591 [(set_attr "type" "farith")])
 592
 593 (define_insn "subxf3"
 594   [(set (match_operand:XF 0 "s_register_operand" "=f,f")
 595         (minus:XF (match_operand:XF 1 "fpu_rhs_operand" "f,G")
 596                   (match_operand:XF 2 "fpu_rhs_operand" "fG,f")))]
 597   "ENABLE_XF_PATTERNS"
 598   "@
 599    suf%?e\\t%0, %1, %2
 600    rsf%?e\\t%0, %2, %1"
 601 [(set_attr "type" "farith")])
 602 \f
 603 ;; Multiplication insns
 604
 605 ;; Use `&' and then `0' to prevent the operands 0 and 1 being the same
 606 (define_insn "mulsi3"
 607   [(set (match_operand:SI 0 "s_register_operand" "=&r,&r")
 608         (mult:SI (match_operand:SI 2 "s_register_operand" "r,r")
 609                  (match_operand:SI 1 "s_register_operand" "%?r,0")))]
 610   ""
 611   "mul%?\\t%0, %2, %1")
 612
 613 (define_insn ""
 614   [(set (reg:CC_NOOV 24)
 615         (compare:CC_NOOV (mult:SI
 616                           (match_operand:SI 2 "s_register_operand" "r,r")
 617                           (match_operand:SI 1 "s_register_operand" "%?r,0"))
 618                          (const_int 0)))
 619    (set (match_operand:SI 0 "s_register_operand" "=&r,&r")
 620         (mult:SI (match_dup 2) (match_dup 1)))]
 621   ""
 622   "mul%?s\\t%0, %2, %1"
 623 [(set_attr "conds" "set")])
 624
 625 (define_insn ""
 626   [(set (reg:CC_NOOV 24)
 627         (compare:CC_NOOV (mult:SI
 628                           (match_operand:SI 2 "s_register_operand" "r,r")
 629                           (match_operand:SI 1 "s_register_operand" "%?r,0"))
 630                          (const_int 0)))
 631    (clobber (match_scratch:SI 0 "=&r,&r"))]
 632   ""
 633   "mul%?s\\t%0, %2, %1"
 634 [(set_attr "conds" "set")])
 635
 636 ;; Unnamed templates to match MLA instruction.
 637
 638 (define_insn ""
 639   [(set (match_operand:SI 0 "s_register_operand" "=&r,&r,&r,&r")
 640         (plus:SI
 641           (mult:SI (match_operand:SI 2 "s_register_operand" "r,r,r,r")
 642                    (match_operand:SI 1 "s_register_operand" "%r,0,r,0"))
 643           (match_operand:SI 3 "s_register_operand" "?r,r,0,0")))]
 644   ""
 645   "mla%?\\t%0, %2, %1, %3")
 646
 647 (define_insn ""
 648   [(set (reg:CC_NOOV 24)
 649         (compare:CC_NOOV (plus:SI
 650                           (mult:SI
 651                            (match_operand:SI 2 "s_register_operand" "r,r,r,r")
 652                            (match_operand:SI 1 "s_register_operand" "%r,0,r,0"))
 653                           (match_operand:SI 3 "s_register_operand" "?r,r,0,0"))
 654                          (const_int 0)))
 655    (set (match_operand:SI 0 "s_register_operand" "=&r,&r,&r,&r")
 656         (plus:SI (mult:SI (match_dup 2) (match_dup 1))
 657                  (match_dup 3)))]
 658   ""
 659   "mla%?s\\t%0, %2, %1, %3"
 660 [(set_attr "conds" "set")])
 661
 662 (define_insn ""
 663   [(set (reg:CC_NOOV 24)
 664         (compare:CC_NOOV (plus:SI
 665                           (mult:SI
 666                            (match_operand:SI 2 "s_register_operand" "r,r,r,r")
 667                            (match_operand:SI 1 "s_register_operand" "%r,0,r,0"))
 668                           (match_operand:SI 3 "s_register_operand" "?r,r,0,0"))
 669                          (const_int 0)))
 670    (clobber (match_scratch:SI 0 "=&r,&r,&r,&r"))]
 671   ""
 672   "mla%?s\\t%0, %2, %1, %3"
 673 [(set_attr "conds" "set")])
 674
 675 (define_insn "mulsf3"
 676   [(set (match_operand:SF 0 "s_register_operand" "=f")
 677         (mult:SF (match_operand:SF 1 "s_register_operand" "f")
 678                  (match_operand:SF 2 "fpu_rhs_operand" "fG")))]
 679   ""
 680   "fml%?s\\t%0, %1, %2"
 681 [(set_attr "type" "ffmul")])
 682
 683 (define_insn "muldf3"
 684   [(set (match_operand:DF 0 "s_register_operand" "=f")
 685         (mult:DF (match_operand:DF 1 "s_register_operand" "f")
 686                  (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 687   ""
 688   "muf%?d\\t%0, %1, %2"
 689 [(set_attr "type" "fmul")])
 690
 691 (define_insn ""
 692   [(set (match_operand:DF 0 "s_register_operand" "=f")
 693         (mult:DF (float_extend:DF
 694                   (match_operand:SF 1 "s_register_operand" "f"))
 695                  (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 696   ""
 697   "muf%?d\\t%0, %1, %2"
 698 [(set_attr "type" "fmul")])
 699
 700 (define_insn ""
 701   [(set (match_operand:DF 0 "s_register_operand" "=f")
 702         (mult:DF (match_operand:DF 1 "s_register_operand" "f")
 703                  (float_extend:DF
 704                   (match_operand:SF 2 "s_register_operand" "f"))))]
 705   ""
 706   "muf%?d\\t%0, %1, %2"
 707 [(set_attr "type" "fmul")])
 708
 709 (define_insn ""
 710   [(set (match_operand:DF 0 "s_register_operand" "=f")
 711         (mult:DF (float_extend:DF
 712                   (match_operand:SF 1 "s_register_operand" "f"))
 713                  (float_extend:DF
 714                   (match_operand:SF 2 "s_register_operand" "f"))))]
 715   ""
 716   "muf%?d\\t%0, %1, %2"
 717 [(set_attr "type" "fmul")])
 718
 719 (define_insn "mulxf3"
 720   [(set (match_operand:XF 0 "s_register_operand" "=f")
 721         (mult:XF (match_operand:XF 1 "s_register_operand" "f")
 722                  (match_operand:XF 2 "fpu_rhs_operand" "fG")))]
 723   "ENABLE_XF_PATTERNS"
 724   "muf%?e\\t%0, %1, %2"
 725 [(set_attr "type" "fmul")])
 726 \f
 727 ;; Division insns
 728
 729 (define_insn "divsf3"
 730   [(set (match_operand:SF 0 "s_register_operand" "=f,f")
 731         (div:SF (match_operand:SF 1 "fpu_rhs_operand" "f,G")
 732                 (match_operand:SF 2 "fpu_rhs_operand" "fG,f")))]
 733   ""
 734   "@
 735    fdv%?s\\t%0, %1, %2
 736    frd%?s\\t%0, %2, %1"
 737 [(set_attr "type" "fdivs")])
 738
 739 (define_insn "divdf3"
 740   [(set (match_operand:DF 0 "s_register_operand" "=f,f")
 741         (div:DF (match_operand:DF 1 "fpu_rhs_operand" "f,G")
 742                 (match_operand:DF 2 "fpu_rhs_operand" "fG,f")))]
 743   ""
 744   "@
 745    dvf%?d\\t%0, %1, %2
 746    rdf%?d\\t%0, %2, %1"
 747 [(set_attr "type" "fdivd")])
 748
 749 (define_insn ""
 750   [(set (match_operand:DF 0 "s_register_operand" "=f")
 751         (div:DF (float_extend:DF
 752                  (match_operand:SF 1 "s_register_operand" "f"))
 753                 (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 754   ""
 755   "dvf%?d\\t%0, %1, %2"
 756 [(set_attr "type" "fdivd")])
 757
 758 (define_insn ""
 759   [(set (match_operand:DF 0 "s_register_operand" "=f")
 760         (div:DF (match_operand:DF 1 "fpu_rhs_operand" "fG")
 761                 (float_extend:DF
 762                  (match_operand:SF 2 "s_register_operand" "f"))))]
 763   ""
 764   "rdf%?d\\t%0, %2, %1"
 765 [(set_attr "type" "fdivd")])
 766
 767 (define_insn ""
 768   [(set (match_operand:DF 0 "s_register_operand" "=f")
 769         (div:DF (float_extend:DF
 770                  (match_operand:SF 1 "s_register_operand" "f"))
 771                 (float_extend:DF
 772                  (match_operand:SF 2 "s_register_operand" "f"))))]
 773   ""
 774   "dvf%?d\\t%0, %1, %2"
 775 [(set_attr "type" "fdivd")])
 776
 777 (define_insn "divxf3"
 778   [(set (match_operand:XF 0 "s_register_operand" "=f,f")
 779         (div:XF (match_operand:XF 1 "fpu_rhs_operand" "f,G")
 780                 (match_operand:XF 2 "fpu_rhs_operand" "fG,f")))]
 781   "ENABLE_XF_PATTERNS"
 782   "@
 783    dvf%?e\\t%0, %1, %2
 784    rdf%?e\\t%0, %2, %1"
 785 [(set_attr "type" "fdivx")])
 786 \f
 787 ;; Modulo insns
 788
 789 (define_insn "modsf3"
 790   [(set (match_operand:SF 0 "s_register_operand" "=f")
 791         (mod:SF (match_operand:SF 1 "s_register_operand" "f")
 792                 (match_operand:SF 2 "fpu_rhs_operand" "fG")))]
 793   ""
 794   "rmf%?s\\t%0, %1, %2"
 795 [(set_attr "type" "fdivs")])
 796
 797 (define_insn "moddf3"
 798   [(set (match_operand:DF 0 "s_register_operand" "=f")
 799         (mod:DF (match_operand:DF 1 "s_register_operand" "f")
 800                 (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 801   ""
 802   "rmf%?d\\t%0, %1, %2"
 803 [(set_attr "type" "fdivd")])
 804
 805 (define_insn ""
 806   [(set (match_operand:DF 0 "s_register_operand" "=f")
 807         (mod:DF (float_extend:DF
 808                  (match_operand:SF 1 "s_register_operand" "f"))
 809                 (match_operand:DF 2 "fpu_rhs_operand" "fG")))]
 810   ""
 811   "rmf%?d\\t%0, %1, %2"
 812 [(set_attr "type" "fdivd")])
 813
 814 (define_insn ""
 815   [(set (match_operand:DF 0 "s_register_operand" "=f")
 816         (mod:DF (match_operand:DF 1 "s_register_operand" "f")
 817                 (float_extend:DF
 818                  (match_operand:SF 2 "s_register_operand" "f"))))]
 819   ""
 820   "rmf%?d\\t%0, %1, %2"
 821 [(set_attr "type" "fdivd")])
 822
 823 (define_insn ""
 824   [(set (match_operand:DF 0 "s_register_operand" "=f")
 825         (mod:DF (float_extend:DF
 826                  (match_operand:SF 1 "s_register_operand" "f"))
 827                 (float_extend:DF
 828                  (match_operand:SF 2 "s_register_operand" "f"))))]
 829   ""
 830   "rmf%?d\\t%0, %1, %2"
 831 [(set_attr "type" "fdivd")])
 832
 833 (define_insn "modxf3"
 834   [(set (match_operand:XF 0 "s_register_operand" "=f")
 835         (mod:XF (match_operand:XF 1 "s_register_operand" "f")
 836                 (match_operand:XF 2 "fpu_rhs_operand" "fG")))]
 837   "ENABLE_XF_PATTERNS"
 838   "rmf%?e\\t%0, %1, %2"
 839 [(set_attr "type" "fdivx")])
 840 \f
 841 ;; Boolean and,ior,xor insns
 842
 843 (define_insn "anddi3"
 844   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 845         (and:DI (match_operand:DI 1 "s_register_operand" "%0,0")
 846                 (match_operand:DI 2 "s_register_operand" "r,0")))]
 847   ""
 848   "and%?\\t%0, %1, %2\;and%?\\t%R0, %R1, %R2"
 849 [(set_attr "length" "8")])
 850
 851 (define_insn ""
 852   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 853         (and:DI (zero_extend:DI
 854                  (match_operand:SI 2 "s_register_operand" "r,r"))
 855                 (match_operand:DI 1 "s_register_operand" "?r,0")))]
 856   ""
 857   "and%?\\t%0, %1, %2\;mov%?\\t%R0, #0"
 858 [(set_attr "length" "8")])
 859
 860 (define_insn ""
 861   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 862         (and:DI (sign_extend:DI
 863                  (match_operand:SI 2 "s_register_operand" "r,r"))
 864                 (match_operand:DI 1 "s_register_operand" "?r,0")))]
 865   ""
 866   "and%?\\t%0, %1, %2\;and%?\\t%R0, %R1, %2, asr #31"
 867 [(set_attr "length" "8")])
 868
 869 (define_expand "andsi3"
 870   [(set (match_operand:SI 0 "s_register_operand" "")
 871         (and:SI (match_operand:SI 1 "s_register_operand" "")
 872                 (match_operand:SI 2 "reg_or_int_operand" "")))]
 873   ""
 874   "
 875   if (GET_CODE (operands[2]) == CONST_INT)
 876     {
 877       arm_split_constant (AND, SImode, INTVAL (operands[2]), operands[0],
 878                           operands[1],
 879                           (reload_in_progress || reload_completed
 880                            ? 0 : preserve_subexpressions_p ()));
 881       DONE;
 882     }
 883 ")
 884
 885 (define_insn ""
 886   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
 887         (and:SI (match_operand:SI 1 "s_register_operand" "r,r,r")
 888                 (match_operand:SI 2 "reg_or_int_operand" "rI,K,?n")))]
 889   ""
 890   "@
 891    and%?\\t%0, %1, %2
 892    bic%?\\t%0, %1, #%B2
 893    #"
 894 [(set_attr "length" "4,4,16")])
 895
 896 (define_split
 897   [(set (match_operand:SI 0 "s_register_operand" "")
 898         (and:SI (match_operand:SI 1 "s_register_operand" "")
 899                 (match_operand:SI 2 "const_int_operand" "")))]
 900   "! (const_ok_for_arm (INTVAL (operands[2]))
 901       || const_ok_for_arm (~ INTVAL (operands[2])))"
 902   [(clobber (const_int 0))]
 903   "
 904   arm_split_constant  (AND, SImode, INTVAL (operands[2]), operands[0],
 905                        operands[1], 0);
 906   DONE;
 907 ")
 908
 909 (define_insn ""
 910   [(set (reg:CC_NOOV 24)
 911         (compare:CC_NOOV
 912          (and:SI (match_operand:SI 1 "s_register_operand" "r,r")
 913                  (match_operand:SI 2 "arm_not_operand" "rI,K"))
 914          (const_int 0)))
 915    (set (match_operand:SI 0 "s_register_operand" "=r,r")
 916         (and:SI (match_dup 1) (match_dup 2)))]
 917   ""
 918   "@
 919    and%?s\\t%0, %1, %2
 920    bic%?s\\t%0, %1, #%B2"
 921 [(set_attr "conds" "set")])
 922
 923 (define_insn ""
 924   [(set (reg:CC_NOOV 24)
 925         (compare:CC_NOOV
 926          (and:SI (match_operand:SI 0 "s_register_operand" "r,r")
 927                  (match_operand:SI 1 "arm_not_operand" "rI,K"))
 928          (const_int 0)))
 929    (clobber (match_scratch:SI 3 "=X,r"))]
 930   ""
 931   "@
 932    tst%?\\t%0, %1
 933    bic%?s\\t%3, %0, #%B1"
 934 [(set_attr "conds" "set")])
 935
 936 (define_insn ""
 937   [(set (reg:CC_NOOV 24)
 938         (compare:CC_NOOV (zero_extract:SI
 939                           (match_operand:SI 0 "s_register_operand" "r")
 940                           (match_operand:SI 1 "immediate_operand" "n")
 941                           (match_operand:SI 2 "immediate_operand" "n"))
 942                          (const_int 0)))]
 943   "INTVAL (operands[2]) >= 0 && INTVAL (operands[2]) < 32
 944    && INTVAL (operands[1]) > 0
 945    && INTVAL (operands[1]) + (INTVAL (operands[2]) & 1) <= 8
 946    && INTVAL (operands[1]) + INTVAL (operands[2]) <= 32"
 947   "*
 948 {
 949   unsigned int mask = 0;
 950   int cnt = INTVAL (operands[1]);
 951
 952   while (cnt--)
 953     mask = (mask << 1) | 1;
 954   operands[1] = GEN_INT (mask << INTVAL (operands[2]));
 955   output_asm_insn (\"tst%?\\t%0, %1\", operands);
 956   return \"\";
 957 }
 958 "
 959 [(set_attr "conds" "set")])
 960
 961 (define_insn ""
 962   [(set (reg:CC_NOOV 24)
 963         (compare:CC_NOOV (zero_extract:SI
 964                           (match_operand:QI 0 "memory_operand" "m")
 965                           (match_operand 1 "immediate_operand" "n")
 966                           (match_operand 2 "immediate_operand" "n"))
 967                          (const_int 0)))
 968    (clobber (match_scratch:QI 3 "=r"))]
 969   "INTVAL (operands[2]) >= 0 && INTVAL (operands[2]) < 8
 970    && INTVAL (operands[1]) > 0 && INTVAL (operands[1]) <= 8"
 971   "*
 972 {
 973   unsigned int mask = 0;
 974   int cnt = INTVAL (operands[1]);
 975
 976   while (cnt--)
 977     mask = (mask << 1) | 1;
 978   operands[1] = GEN_INT (mask << INTVAL (operands[2]));
 979   output_asm_insn (\"ldr%?b\\t%3, %0\", operands);
 980   output_asm_insn (\"tst%?\\t%3, %1\", operands);
 981   return \"\";
 982 }
 983 "
 984 [(set_attr "conds" "set")
 985  (set_attr "length" "8")])
 986
 987 ;; constants for op 2 will never be given to these patterns.
 988 (define_insn ""
 989   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 990         (and:DI (not:DI (match_operand:DI 2 "s_register_operand" "r,0"))
 991                 (match_operand:DI 1 "s_register_operand" "0,r")))]
 992   ""
 993   "bic%?\\t%0, %1, %2\;bic%?\\t%R0, %R1, %R2"
 994 [(set_attr "length" "8")])
 995
 996 (define_insn ""
 997   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
 998         (and:DI (not:DI (zero_extend:DI
 999                          (match_operand:SI 2 "s_register_operand" "r,r")))
1000                 (match_operand:DI 1 "s_register_operand" "0,?r")))]
1001   ""
1002   "@
1003    bic%?\\t%0, %1, %2
1004    bic%?\\t%0, %1, %2\;mov%?\\t%R0, %R1"
1005 [(set_attr "length" "4,8")])
1006
1007 (define_insn ""
1008   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1009         (and:DI (not:DI (sign_extend:DI
1010                          (match_operand:SI 2 "s_register_operand" "r,r")))
1011                 (match_operand:DI 1 "s_register_operand" "?r,0")))]
1012   ""
1013   "bic%?\\t%0, %1, %2\;bic%?\\t%R0, %R1, %2, asr #31"
1014 [(set_attr "length" "8")])
1015
1016 (define_insn ""
1017   [(set (match_operand:SI 0 "s_register_operand" "=r")
1018         (and:SI (not:SI (match_operand:SI 2 "s_register_operand" "r"))
1019                 (match_operand:SI 1 "s_register_operand" "r")))]
1020   ""
1021   "bic%?\\t%0, %1, %2")
1022
1023 (define_insn ""
1024   [(set (reg:CC_NOOV 24)
1025         (compare:CC_NOOV
1026          (and:SI (not:SI (match_operand:SI 2 "s_register_operand" "r"))
1027                  (match_operand:SI 1 "s_register_operand" "r"))
1028          (const_int 0)))
1029    (set (match_operand:SI 0 "s_register_operand" "=r")
1030         (and:SI (not:SI (match_dup 2)) (match_dup 1)))]
1031   ""
1032   "bic%?s\\t%0, %1, %2"
1033 [(set_attr "conds" "set")])
1034
1035 (define_insn ""
1036   [(set (reg:CC_NOOV 24)
1037         (compare:CC_NOOV
1038          (and:SI (not:SI (match_operand:SI 2 "s_register_operand" "r"))
1039                  (match_operand:SI 1 "s_register_operand" "r"))
1040          (const_int 0)))
1041    (clobber (match_scratch:SI 0 "=r"))]
1042   ""
1043   "bic%?s\\t%0, %1, %2"
1044 [(set_attr "conds" "set")])
1045
1046 (define_insn "iordi3"
1047   [(set (match_operand:DI 0 "s_register_operand" "=&r")
1048         (ior:DI (match_operand:DI 1 "s_register_operand" "%0")
1049                 (match_operand:DI 2 "s_register_operand" "r")))]
1050   ""
1051   "orr%?\\t%0, %1, %2\;orr%?\\t%R0, %R1, %R2"
1052 [(set_attr "length" "8")])
1053
1054 (define_insn ""
1055   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1056         (ior:DI (zero_extend:DI
1057                  (match_operand:SI 2 "s_register_operand" "r,r"))
1058                 (match_operand:DI 1 "s_register_operand" "0,?r")))]
1059   ""
1060   "@
1061    orr%?\\t%0, %1, %2
1062    orr%?\\t%0, %1, %2\;mov%?\\t%R0, %R1"
1063 [(set_attr "length" "4,8")])
1064
1065 (define_insn ""
1066   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1067         (ior:DI (sign_extend:DI
1068                  (match_operand:SI 2 "s_register_operand" "r,r"))
1069                 (match_operand:DI 1 "s_register_operand" "?r,0")))]
1070   ""
1071   "orr%?\\t%0, %1, %2\;orr%?\\t%R0, %R1, %2, asr #31"
1072 [(set_attr "length" "8")])
1073
1074 (define_expand "iorsi3"
1075   [(set (match_operand:SI 0 "s_register_operand" "")
1076         (ior:SI (match_operand:SI 1 "s_register_operand" "")
1077                 (match_operand:SI 2 "reg_or_int_operand" "")))]
1078   ""
1079   "
1080   if (GET_CODE (operands[2]) == CONST_INT)
1081     {
1082       arm_split_constant (IOR, SImode, INTVAL (operands[2]), operands[0],
1083                           operands[1],
1084                           (reload_in_progress || reload_completed
1085                            ? 0 : preserve_subexpressions_p ()));
1086       DONE;
1087     }
1088 ")
1089
1090 (define_insn ""
1091   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
1092         (ior:SI (match_operand:SI 1 "s_register_operand" "r,r")
1093                 (match_operand:SI 2 "reg_or_int_operand" "rI,?n")))]
1094   ""
1095   "@
1096    orr%?\\t%0, %1, %2
1097    #"
1098 [(set_attr "length" "4,16")])
1099
1100 (define_split
1101   [(set (match_operand:SI 0 "s_register_operand" "")
1102         (ior:SI (match_operand:SI 1 "s_register_operand" "")
1103                 (match_operand:SI 2 "const_int_operand" "")))]
1104   "! const_ok_for_arm (INTVAL (operands[2]))"
1105   [(clobber (const_int 0))]
1106   "
1107   arm_split_constant (IOR, SImode, INTVAL (operands[2]), operands[0],
1108                       operands[1], 0);
1109   DONE;
1110 ")
1111
1112 (define_insn ""
1113   [(set (reg:CC_NOOV 24)
1114         (compare:CC_NOOV (ior:SI (match_operand:SI 1 "s_register_operand" "%r")
1115                                  (match_operand:SI 2 "arm_rhs_operand" "rI"))
1116                          (const_int 0)))
1117    (set (match_operand:SI 0 "s_register_operand" "=r")
1118         (ior:SI (match_dup 1) (match_dup 2)))]
1119   ""
1120   "orr%?s\\t%0, %1, %2"
1121 [(set_attr "conds" "set")])
1122
1123 (define_insn ""
1124   [(set (reg:CC_NOOV 24)
1125         (compare:CC_NOOV (ior:SI (match_operand:SI 1 "s_register_operand" "%r")
1126                                  (match_operand:SI 2 "arm_rhs_operand" "rI"))
1127                          (const_int 0)))
1128    (clobber (match_scratch:SI 0 "=r"))]
1129   ""
1130   "orr%?s\\t%0, %1, %2"
1131 [(set_attr "conds" "set")])
1132
1133 (define_insn "xordi3"
1134   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1135         (xor:DI (match_operand:DI 1 "s_register_operand" "%0,0")
1136                 (match_operand:DI 2 "s_register_operand" "r,0")))]
1137   ""
1138   "eor%?\\t%0, %1, %2\;eor%?\\t%R0, %R1, %R2"
1139 [(set_attr "length" "8")])
1140
1141 (define_insn ""
1142   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1143         (xor:DI (zero_extend:DI
1144                  (match_operand:SI 2 "s_register_operand" "r,r"))
1145                 (match_operand:DI 1 "s_register_operand" "0,?r")))]
1146   ""
1147   "@
1148    eor%?\\t%0, %1, %2
1149    eor%?\\t%0, %1, %2\;mov%?\\t%R0, %R1"
1150 [(set_attr "length" "4,8")])
1151
1152 (define_insn ""
1153   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1154         (xor:DI (sign_extend:DI
1155                  (match_operand:SI 2 "s_register_operand" "r,r"))
1156                 (match_operand:DI 1 "s_register_operand" "?r,0")))]
1157   ""
1158   "eor%?\\t%0, %1, %2\;eor%?\\t%R0, %R1, %2, asr #31"
1159 [(set_attr "length" "8")])
1160
1161 (define_insn "xorsi3"
1162   [(set (match_operand:SI 0 "s_register_operand" "=r")
1163         (xor:SI (match_operand:SI 1 "s_register_operand" "r")
1164                 (match_operand:SI 2 "arm_rhs_operand" "rI")))]
1165   ""
1166   "eor%?\\t%0, %1, %2")
1167
1168 (define_insn ""
1169   [(set (reg:CC_NOOV 24)
1170         (compare:CC_NOOV (xor:SI (match_operand:SI 1 "s_register_operand" "r")
1171                                  (match_operand:SI 2 "arm_rhs_operand" "rI"))
1172                          (const_int 0)))
1173    (set (match_operand:SI 0 "s_register_operand" "=r")
1174         (xor:SI (match_dup 1) (match_dup 2)))]
1175   ""
1176   "eor%?s\\t%0, %1, %2"
1177 [(set_attr "conds" "set")])
1178
1179 (define_insn ""
1180   [(set (reg:CC_NOOV 24)
1181         (compare:CC_NOOV (xor:SI (match_operand:SI 0 "s_register_operand" "r")
1182                                  (match_operand:SI 1 "arm_rhs_operand" "rI"))
1183                          (const_int 0)))]
1184   ""
1185   "teq%?\\t%0, %1"
1186 [(set_attr "conds" "set")])
1187
1188 ;; by splitting (IOR (AND (NOT A) (NOT B)) C) as D = AND (IOR A B) (NOT C),
1189 ;; (NOT D) we can sometimes merge the final NOT into one of the following
1190 ;; insns
1191
1192 (define_split
1193   [(set (match_operand:SI 0 "s_register_operand" "=r")
1194         (ior:SI (and:SI (not:SI (match_operand:SI 1 "s_register_operand" "r"))
1195                         (not:SI (match_operand:SI 2 "arm_rhs_operand" "rI")))
1196                 (match_operand:SI 3 "arm_rhs_operand" "rI")))
1197    (clobber (match_operand:SI 4 "s_register_operand" "=r"))]
1198   ""
1199   [(set (match_dup 4) (and:SI (ior:SI (match_dup 1) (match_dup 2))
1200                               (not:SI (match_dup 3))))
1201    (set (match_dup 0) (not:SI (match_dup 4)))]
1202   ""
1203 )
1204
1205 (define_insn ""
1206   [(set (match_operand:SI 0 "s_register_operand" "=&r,&r,&r")
1207         (and:SI (ior:SI (match_operand:SI 1 "s_register_operand" "r,r,0")
1208                         (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI"))
1209                 (not:SI (match_operand:SI 3 "arm_rhs_operand" "rI,rI,rI"))))]
1210   ""
1211   "orr%?\\t%0, %1, %2\;bic%?\\t%0, %0, %3"
1212 [(set_attr "length" "8")])
1213
1214 \f
1215
1216 ;; Minimum and maximum insns
1217
1218 (define_insn "smaxsi3"
1219   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
1220         (smax:SI (match_operand:SI 1 "s_register_operand" "0,r,?r")
1221                  (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))
1222    (clobber (reg:CC 24))]
1223   ""
1224   "@
1225    cmp\\t%1, %2\;movlt\\t%0, %2
1226    cmp\\t%1, %2\;movge\\t%0, %1
1227    cmp\\t%1, %2\;movge\\t%0, %1\;movlt\\t%0, %2"
1228 [(set_attr "conds" "clob")
1229  (set_attr "length" "8,8,12")])
1230
1231 (define_insn "sminsi3"
1232   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
1233         (smin:SI (match_operand:SI 1 "s_register_operand" "0,r,?r")
1234                  (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))
1235    (clobber (reg:CC 24))]
1236   ""
1237   "@
1238    cmp\\t%1, %2\;movge\\t%0, %2
1239    cmp\\t%1, %2\;movlt\\t%0, %1
1240    cmp\\t%1, %2\;movlt\\t%0, %1\;movge\\t%0, %2"
1241 [(set_attr "conds" "clob")
1242  (set_attr "length" "8,8,12")])
1243
1244 (define_insn "umaxsi3"
1245   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
1246         (umax:SI (match_operand:SI 1 "s_register_operand" "0,r,?r")
1247                  (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))
1248    (clobber (reg:CC 24))]
1249   ""
1250   "@
1251    cmp\\t%1, %2\;movcc\\t%0, %2
1252    cmp\\t%1, %2\;movcs\\t%0, %1
1253    cmp\\t%1, %2\;movcs\\t%0, %1\;movcc\\t%0, %2"
1254 [(set_attr "conds" "clob")
1255  (set_attr "length" "8,8,12")])
1256
1257 (define_insn "uminsi3"
1258   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
1259         (umin:SI (match_operand:SI 1 "s_register_operand" "0,r,?r")
1260                  (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))
1261    (clobber (reg:CC 24))]
1262   ""
1263   "@
1264    cmp\\t%1, %2\;movcs\\t%0, %2
1265    cmp\\t%1, %2\;movcc\\t%0, %1
1266    cmp\\t%1, %2\;movcc\\t%0, %1\;movcs\\t%0, %2"
1267 [(set_attr "conds" "clob")
1268  (set_attr "length" "8,8,12")])
1269
1270 (define_insn ""
1271   [(set (match_operand:SI 0 "memory_operand" "=m")
1272         (match_operator:SI 3 "minmax_operator"
1273          [(match_operand:SI 1 "s_register_operand" "r")
1274           (match_operand:SI 2 "s_register_operand" "r")]))
1275    (clobber (reg:CC 24))]
1276   ""
1277   "*
1278   operands[3] = gen_rtx (minmax_code (operands[3]), SImode, operands[1],
1279                          operands[2]);
1280   output_asm_insn (\"cmp\\t%1, %2\", operands);
1281   output_asm_insn (\"str%d3\\t%1, %0\", operands);
1282   output_asm_insn (\"str%D3\\t%2, %0\", operands);
1283   return \"\";
1284 "
1285 [(set_attr "conds" "clob")
1286  (set_attr "length" "12")
1287  (set_attr "type" "store1")])
1288
1289 (define_insn ""
1290   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
1291         (match_operator:SI 4 "shiftable_operator"
1292          [(match_operator:SI 5 "minmax_operator"
1293            [(match_operand:SI 2 "s_register_operand" "r,r")
1294             (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])
1295           (match_operand:SI 1 "s_register_operand" "0,?r")]))
1296    (clobber (reg:CC 24))]
1297   ""
1298   "*
1299 {
1300   enum rtx_code code = GET_CODE (operands[4]);
1301
1302   operands[5] = gen_rtx (minmax_code (operands[5]), SImode, operands[2],
1303                          operands[3]);
1304   output_asm_insn (\"cmp\\t%2, %3\", operands);
1305   output_asm_insn (\"%i4%d5\\t%0, %1, %2\", operands);
1306   if (which_alternative != 0 || operands[3] != const0_rtx
1307       || (code != PLUS && code != MINUS && code != IOR && code != XOR))
1308     output_asm_insn (\"%i4%D5\\t%0, %1, %3\", operands);
1309   return \"\";
1310 }
1311 "
1312 [(set_attr "conds" "clob")
1313  (set_attr "length" "12")])
1314
1315 \f
1316 ;; Shift and rotation insns
1317
1318 (define_expand "ashlsi3"
1319   [(set (match_operand:SI 0 "s_register_operand" "")
1320         (ashift:SI (match_operand:SI 1 "s_register_operand" "")
1321                    (match_operand:SI 2 "arm_rhs_operand" "")))]
1322   ""
1323   "
1324   if (GET_CODE (operands[2]) == CONST_INT
1325       && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1326     {
1327       emit_insn (gen_movsi (operands[0], const0_rtx));
1328       DONE;
1329     }
1330 ")
1331
1332 (define_expand "ashrsi3"
1333   [(set (match_operand:SI 0 "s_register_operand" "")
1334         (ashiftrt:SI (match_operand:SI 1 "s_register_operand" "")
1335                      (match_operand:SI 2 "arm_rhs_operand" "")))]
1336   ""
1337   "
1338   if (GET_CODE (operands[2]) == CONST_INT
1339       && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1340     operands[2] = GEN_INT (31);
1341 ")
1342
1343 (define_expand "lshrsi3"
1344   [(set (match_operand:SI 0 "s_register_operand" "")
1345         (lshiftrt:SI (match_operand:SI 1 "s_register_operand" "")
1346                      (match_operand:SI 2 "arm_rhs_operand" "")))]
1347   ""
1348   "
1349   if (GET_CODE (operands[2]) == CONST_INT
1350       && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1351     {
1352       emit_insn (gen_movsi (operands[0], const0_rtx));
1353       DONE;
1354     }
1355 ")
1356
1357 (define_expand "rotlsi3"
1358   [(set (match_operand:SI 0 "s_register_operand" "")
1359         (rotatert:SI (match_operand:SI 1 "s_register_operand" "")
1360                      (match_operand:SI 2 "reg_or_int_operand" "")))]
1361   ""
1362   "
1363   if (GET_CODE (operands[2]) == CONST_INT)
1364     operands[2] = GEN_INT ((32 - INTVAL (operands[2])) % 32);
1365   else
1366     {
1367       rtx reg = gen_reg_rtx (SImode);
1368       emit_insn (gen_subsi3 (reg, GEN_INT (32), operands[2]));
1369       operands[2] = reg;
1370     }
1371 ")
1372
1373 (define_expand "rotrsi3"
1374   [(set (match_operand:SI 0 "s_register_operand" "")
1375         (rotatert:SI (match_operand:SI 1 "s_register_operand" "")
1376                      (match_operand:SI 2 "arm_rhs_operand" "")))]
1377   ""
1378   "
1379   if (GET_CODE (operands[2]) == CONST_INT
1380       && ((unsigned HOST_WIDE_INT) INTVAL (operands[2])) > 31)
1381     operands[2] = GEN_INT (INTVAL (operands[2]) % 32);
1382 ")
1383
1384 (define_insn ""
1385   [(set (match_operand:SI 0 "s_register_operand" "=r")
1386         (match_operator:SI 3 "shift_operator"
1387          [(match_operand:SI 1 "s_register_operand" "r")
1388           (match_operand:SI 2 "reg_or_int_operand" "rM")]))]
1389   ""
1390   "mov%?\\t%0, %1%S3")
1391
1392 (define_insn ""
1393   [(set (reg:CC_NOOV 24)
1394         (compare:CC_NOOV (match_operator:SI 3 "shift_operator"
1395                           [(match_operand:SI 1 "s_register_operand" "r")
1396                            (match_operand:SI 2 "arm_rhs_operand" "rM")])
1397                          (const_int 0)))
1398    (set (match_operand:SI 0 "s_register_operand" "=r")
1399         (match_op_dup 3 [(match_dup 1) (match_dup 2)]))]
1400   ""
1401   "mov%?s\\t%0, %1%S3"
1402 [(set_attr "conds" "set")])
1403
1404 (define_insn ""
1405   [(set (reg:CC_NOOV 24)
1406         (compare:CC_NOOV (match_operator:SI 3 "shift_operator"
1407                           [(match_operand:SI 1 "s_register_operand" "r")
1408                            (match_operand:SI 2 "arm_rhs_operand" "rM")])
1409                          (const_int 0)))
1410    (clobber (match_scratch:SI 0 "=r"))]
1411   ""
1412   "mov%?s\\t%0, %1%S3"
1413 [(set_attr "conds" "set")])
1414
1415 (define_insn ""
1416   [(set (match_operand:SI 0 "s_register_operand" "=r")
1417         (not:SI (match_operator:SI 3 "shift_operator"
1418                  [(match_operand:SI 1 "s_register_operand" "r")
1419                   (match_operand:SI 2 "arm_rhs_operand" "rM")])))]
1420   ""
1421   "mvn%?\\t%0, %1%S3")
1422
1423 (define_insn ""
1424   [(set (reg:CC_NOOV 24)
1425         (compare:CC_NOOV (not:SI (match_operator:SI 3 "shift_operator"
1426                           [(match_operand:SI 1 "s_register_operand" "r")
1427                            (match_operand:SI 2 "arm_rhs_operand" "rM")]))
1428                          (const_int 0)))
1429    (set (match_operand:SI 0 "s_register_operand" "=r")
1430         (not:SI (match_op_dup 3 [(match_dup 1) (match_dup 2)])))]
1431   ""
1432   "mvn%?s\\t%0, %1%S3"
1433 [(set_attr "conds" "set")])
1434
1435 (define_insn ""
1436   [(set (reg:CC_NOOV 24)
1437         (compare:CC_NOOV (not:SI (match_operator:SI 3 "shift_operator"
1438                           [(match_operand:SI 1 "s_register_operand" "r")
1439                            (match_operand:SI 2 "arm_rhs_operand" "rM")]))
1440                          (const_int 0)))
1441    (clobber (match_scratch:SI 0 "=r"))]
1442   ""
1443   "mvn%?s\\t%0, %1%S3"
1444 [(set_attr "conds" "set")])
1445
1446 \f
1447 ;; Unary arithmetic insns
1448
1449 (define_insn "negdi2"
1450   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1451         (neg:DI (match_operand:DI 1 "s_register_operand" "?r,0")))]
1452   ""
1453   "rsbs\\t%0, %1, #0\;rsc\\t%R0, %R1, #0"
1454 [(set_attr "conds" "clob")
1455  (set_attr "length" "8")])
1456
1457 (define_insn "negsi2"
1458   [(set (match_operand:SI 0 "s_register_operand" "=r")
1459         (neg:SI (match_operand:SI 1 "s_register_operand" "r")))]
1460   ""
1461   "rsb%?\\t%0, %1, #0")
1462
1463 (define_insn "negsf2"
1464   [(set (match_operand:SF 0 "s_register_operand" "=f")
1465         (neg:SF (match_operand:SF 1 "s_register_operand" "f")))]
1466   ""
1467   "mnf%?s\\t%0, %1"
1468 [(set_attr "type" "ffarith")])
1469
1470 (define_insn "negdf2"
1471   [(set (match_operand:DF 0 "s_register_operand" "=f")
1472         (neg:DF (match_operand:DF 1 "s_register_operand" "f")))]
1473   ""
1474   "mnf%?d\\t%0, %1"
1475 [(set_attr "type" "ffarith")])
1476
1477 (define_insn ""
1478   [(set (match_operand:DF 0 "s_register_operand" "=f")
1479         (neg:DF (float_extend:DF
1480                  (match_operand:SF 1 "s_register_operand" "f"))))]
1481   ""
1482   "mnf%?d\\t%0, %1"
1483 [(set_attr "type" "ffarith")])
1484
1485 (define_insn "negxf2"
1486   [(set (match_operand:XF 0 "s_register_operand" "=f")
1487         (neg:XF (match_operand:XF 1 "s_register_operand" "f")))]
1488   "ENABLE_XF_PATTERNS"
1489   "mnf%?e\\t%0, %1"
1490 [(set_attr "type" "ffarith")])
1491
1492 ;; abssi2 doesn't really clobber the condition codes if a different register
1493 ;; is being set.  To keep things simple, assume during rtl manipulations that
1494 ;; it does, but tell the final scan operator the truth.  Similarly for
1495 ;; (neg (abs...))
1496
1497 (define_insn "abssi2"
1498   [(set (match_operand:SI 0 "s_register_operand" "=r,&r")
1499         (abs:SI (match_operand:SI 1 "s_register_operand" "0,r")))
1500    (clobber (reg 24))]
1501   ""
1502   "@
1503    cmp\\t%0, #0\;rsblt\\t%0, %0, #0
1504    eor%?\\t%0, %1, %1, asr #31\;sub%?\\t%0, %0, %1, asr #31"
1505 [(set_attr "conds" "clob,*")
1506  (set_attr "length" "8")])
1507
1508 (define_insn ""
1509   [(set (match_operand:SI 0 "s_register_operand" "=r,&r")
1510         (neg:SI (abs:SI (match_operand:SI 1 "s_register_operand" "0,r"))))
1511    (clobber (reg 24))]
1512   ""
1513   "@
1514    cmp\\t%0, #0\;rsbgt\\t%0, %0, #0
1515    eor%?\\t%0, %1, %1, asr #31\;rsb%?\\t%0, %0, %1, asr #31"
1516 [(set_attr "conds" "clob,*")
1517  (set_attr "length" "8")])
1518
1519 (define_insn "abssf2"
1520   [(set (match_operand:SF 0 "s_register_operand" "=f")
1521          (abs:SF (match_operand:SF 1 "s_register_operand" "f")))]
1522   ""
1523   "abs%?s\\t%0, %1"
1524 [(set_attr "type" "ffarith")])
1525
1526 (define_insn "absdf2"
1527   [(set (match_operand:DF 0 "s_register_operand" "=f")
1528         (abs:DF (match_operand:DF 1 "s_register_operand" "f")))]
1529   ""
1530   "abs%?d\\t%0, %1"
1531 [(set_attr "type" "ffarith")])
1532
1533 (define_insn ""
1534   [(set (match_operand:DF 0 "s_register_operand" "=f")
1535         (abs:DF (float_extend:DF
1536                  (match_operand:SF 1 "s_register_operand" "f"))))]
1537   ""
1538   "abs%?d\\t%0, %1"
1539 [(set_attr "type" "ffarith")])
1540
1541 (define_insn "absxf2"
1542   [(set (match_operand:XF 0 "s_register_operand" "=f")
1543         (abs:XF (match_operand:XF 1 "s_register_operand" "f")))]
1544   "ENABLE_XF_PATTERNS"
1545   "abs%?e\\t%0, %1"
1546 [(set_attr "type" "ffarith")])
1547
1548 (define_insn "sqrtsf2"
1549   [(set (match_operand:SF 0 "s_register_operand" "=f")
1550         (sqrt:SF (match_operand:SF 1 "s_register_operand" "f")))]
1551   ""
1552   "sqt%?s\\t%0, %1"
1553 [(set_attr "type" "float_em")])
1554
1555 (define_insn "sqrtdf2"
1556   [(set (match_operand:DF 0 "s_register_operand" "=f")
1557         (sqrt:DF (match_operand:DF 1 "s_register_operand" "f")))]
1558   ""
1559   "sqt%?d\\t%0, %1"
1560 [(set_attr "type" "float_em")])
1561
1562 (define_insn ""
1563   [(set (match_operand:DF 0 "s_register_operand" "=f")
1564         (sqrt:DF (float_extend:DF
1565                   (match_operand:SF 1 "s_register_operand" "f"))))]
1566   ""
1567   "sqt%?d\\t%0, %1"
1568 [(set_attr "type" "float_em")])
1569
1570 (define_insn "sqrtxf2"
1571   [(set (match_operand:XF 0 "s_register_operand" "=f")
1572         (sqrt:XF (match_operand:XF 1 "s_register_operand" "f")))]
1573   "ENABLE_XF_PATTERNS"
1574   "sqt%?e\\t%0, %1"
1575 [(set_attr "type" "float_em")])
1576
1577 (define_insn "sinsf2"
1578   [(set (match_operand:SF 0 "s_register_operand" "=f")
1579         (unspec:SF [(match_operand:SF 1 "s_register_operand" "f")] 0))]
1580   ""
1581   "sin%?s\\t%0, %1"
1582 [(set_attr "type" "float_em")])
1583
1584 (define_insn "sindf2"
1585   [(set (match_operand:DF 0 "s_register_operand" "=f")
1586         (unspec:DF [(match_operand:DF 1 "s_register_operand" "f")] 0))]
1587   ""
1588   "sin%?d\\t%0, %1"
1589 [(set_attr "type" "float_em")])
1590
1591 (define_insn ""
1592   [(set (match_operand:DF 0 "s_register_operand" "=f")
1593         (unspec:DF [(float_extend:DF
1594                      (match_operand:SF 1 "s_register_operand" "f"))] 0))]
1595   ""
1596   "sin%?d\\t%0, %1"
1597 [(set_attr "type" "float_em")])
1598
1599 (define_insn "sinxf2"
1600   [(set (match_operand:XF 0 "s_register_operand" "=f")
1601         (unspec:XF [(match_operand:XF 1 "s_register_operand" "f")] 0))]
1602   "ENABLE_XF_PATTERNS"
1603   "sin%?e\\t%0, %1"
1604 [(set_attr "type" "float_em")])
1605
1606 (define_insn "cossf2"
1607   [(set (match_operand:SF 0 "s_register_operand" "=f")
1608         (unspec:SF [(match_operand:SF 1 "s_register_operand" "f")] 1))]
1609   ""
1610   "cos%?s\\t%0, %1"
1611 [(set_attr "type" "float_em")])
1612
1613 (define_insn "cosdf2"
1614   [(set (match_operand:DF 0 "s_register_operand" "=f")
1615         (unspec:DF [(match_operand:DF 1 "s_register_operand" "f")] 1))]
1616   ""
1617   "cos%?d\\t%0, %1"
1618 [(set_attr "type" "float_em")])
1619
1620 (define_insn ""
1621   [(set (match_operand:DF 0 "s_register_operand" "=f")
1622         (unspec:DF [(float_extend:DF
1623                      (match_operand:SF 1 "s_register_operand" "f"))] 1))]
1624   ""
1625   "cos%?d\\t%0, %1"
1626 [(set_attr "type" "float_em")])
1627
1628 (define_insn "cosxf2"
1629   [(set (match_operand:XF 0 "s_register_operand" "=f")
1630         (unspec:XF [(match_operand:XF 1 "s_register_operand" "f")] 1))]
1631   "ENABLE_XF_PATTERNS"
1632   "cos%?e\\t%0, %1"
1633 [(set_attr "type" "float_em")])
1634
1635 (define_insn "one_cmpldi2"
1636   [(set (match_operand:DI 0 "s_register_operand" "=&r,&r")
1637         (not:DI (match_operand:DI 1 "s_register_operand" "?r,0")))]
1638   ""
1639   "mvn%?\\t%0, %1\;mvn%?\\t%R0, %R1"
1640 [(set_attr "length" "8")])
1641
1642 (define_insn "one_cmplsi2"
1643   [(set (match_operand:SI 0 "s_register_operand" "=r")
1644         (not:SI (match_operand:SI 1 "s_register_operand" "r")))]
1645   ""
1646   "mvn%?\\t%0, %1")
1647
1648 (define_insn ""
1649   [(set (reg:CC_NOOV 24)
1650         (compare:CC_NOOV (not:SI (match_operand:SI 1 "s_register_operand" "r"))
1651                          (const_int 0)))
1652    (set (match_operand:SI 0 "s_register_operand" "=r")
1653         (not:SI (match_dup 1)))]
1654   ""
1655   "mvn%?s\\t%0, %1"
1656 [(set_attr "conds" "set")])
1657
1658 (define_insn ""
1659   [(set (reg:CC_NOOV 24)
1660         (compare:CC_NOOV (not:SI (match_operand:SI 1 "s_register_operand" "r"))
1661                          (const_int 0)))
1662    (clobber (match_scratch:SI 0 "=r"))]
1663   ""
1664   "mvn%?s\\t%0, %1"
1665 [(set_attr "conds" "set")])
1666 \f
1667 ;; Fixed <--> Floating conversion insns
1668
1669 (define_insn "floatsisf2"
1670   [(set (match_operand:SF 0 "s_register_operand" "=f")
1671         (float:SF (match_operand:SI 1 "s_register_operand" "r")))]
1672   ""
1673   "flt%?s\\t%0, %1"
1674 [(set_attr "type" "r_2_f")])
1675
1676 (define_insn "floatsidf2"
1677   [(set (match_operand:DF 0 "s_register_operand" "=f")
1678         (float:DF (match_operand:SI 1 "s_register_operand" "r")))]
1679   ""
1680   "flt%?d\\t%0, %1"
1681 [(set_attr "type" "r_2_f")])
1682
1683 (define_insn "floatsixf2"
1684   [(set (match_operand:XF 0 "s_register_operand" "=f")
1685         (float:XF (match_operand:SI 1 "s_register_operand" "r")))]
1686   "ENABLE_XF_PATTERNS"
1687   "flt%?e\\t%0, %1"
1688 [(set_attr "type" "r_2_f")])
1689
1690 (define_insn "fix_truncsfsi2"
1691   [(set (match_operand:SI 0 "s_register_operand" "=r")
1692         (fix:SI (match_operand:SF 1 "s_register_operand" "f")))]
1693   ""
1694   "fix%?z\\t%0, %1"
1695 [(set_attr "type" "f_2_r")])
1696
1697 (define_insn "fix_truncdfsi2"
1698   [(set (match_operand:SI 0 "s_register_operand" "=r")
1699         (fix:SI (match_operand:DF 1 "s_register_operand" "f")))]
1700   ""
1701   "fix%?z\\t%0, %1"
1702 [(set_attr "type" "f_2_r")])
1703
1704 (define_insn "fix_truncxfsi2"
1705   [(set (match_operand:SI 0 "s_register_operand" "=r")
1706         (fix:SI (match_operand:XF 1 "s_register_operand" "f")))]
1707   "ENABLE_XF_PATTERNS"
1708   "fix%?z\\t%0, %1"
1709 [(set_attr "type" "f_2_r")])
1710
1711 ;; Truncation insns
1712
1713 (define_insn "truncdfsf2"
1714   [(set (match_operand:SF 0 "s_register_operand" "=f")
1715         (float_truncate:SF
1716          (match_operand:DF 1 "s_register_operand" "f")))]
1717   ""
1718   "mvf%?s\\t%0, %1"
1719 [(set_attr "type" "ffarith")])
1720
1721 (define_insn "truncxfsf2"
1722   [(set (match_operand:SF 0 "s_register_operand" "=f")
1723         (float_truncate:SF
1724          (match_operand:XF 1 "s_register_operand" "f")))]
1725   "ENABLE_XF_PATTERNS"
1726   "mvf%?s\\t%0, %1"
1727 [(set_attr "type" "ffarith")])
1728
1729 (define_insn "truncxfdf2"
1730   [(set (match_operand:DF 0 "s_register_operand" "=f")
1731         (float_truncate:DF
1732          (match_operand:XF 1 "s_register_operand" "f")))]
1733   "ENABLE_XF_PATTERNS"
1734   "mvf%?d\\t%0, %1"
1735 [(set_attr "type" "ffarith")])
1736 \f
1737 ;; Zero and sign extension instructions.
1738
1739 (define_insn "zero_extendsidi2"
1740   [(set (match_operand:DI 0 "s_register_operand" "=r")
1741         (zero_extend:DI (match_operand:SI 1 "s_register_operand" "r")))]
1742   ""
1743   "*
1744   if (REGNO (operands[1]) != REGNO (operands[0]))
1745     output_asm_insn (\"mov%?\\t%0, %1\", operands);
1746   return \"mov%?\\t%R0, #0\";
1747 "
1748 [(set_attr "length" "8")])
1749
1750 (define_insn "zero_extendqidi2"
1751   [(set (match_operand:DI 0 "s_register_operand" "=r,r")
1752         (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
1753   ""
1754   "@
1755    and%?\\t%0, %1, #255\;mov%?\\t%R0, #0
1756    ldr%?b\\t%0, %1\;mov%?\\t%R0, #0"
1757 [(set_attr "length" "8")
1758  (set_attr "type" "*,load")])
1759
1760 (define_insn "extendsidi2"
1761   [(set (match_operand:DI 0 "s_register_operand" "=r")
1762         (sign_extend:DI (match_operand:SI 1 "s_register_operand" "r")))]
1763   ""
1764   "*
1765   if (REGNO (operands[1]) != REGNO (operands[0]))
1766     output_asm_insn (\"mov%?\\t%0, %1\", operands);
1767   return \"mov%?\\t%R0, %0, asr #31\";
1768 "
1769 [(set_attr "length" "8")])
1770
1771 (define_expand "zero_extendhisi2"
1772   [(set (match_dup 2) (ashift:SI (match_operand:HI 1 "nonimmediate_operand" "")
1773                                  (const_int 16)))
1774    (set (match_operand:SI 0 "s_register_operand" "")
1775         (lshiftrt:SI (match_dup 2) (const_int 16)))]
1776   ""
1777   "
1778 {
1779   if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM)
1780     {
1781       emit_insn (gen_movhi_bytes (operands[0], operands[1]));
1782       DONE;
1783     }
1784   if (! s_register_operand (operands[1], HImode))
1785     operands[1] = copy_to_mode_reg (HImode, operands[1]);
1786   operands[1] = gen_lowpart (SImode, operands[1]);
1787   operands[2] = gen_reg_rtx (SImode);
1788 }")
1789
1790 (define_expand "zero_extendqisi2"
1791   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
1792         (zero_extend:SI
1793          (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
1794   ""
1795   "
1796   if (GET_CODE (operands[1]) != MEM)
1797     {
1798       emit_insn (gen_andsi3 (operands[0], gen_lowpart (SImode, operands[1]),
1799                              GEN_INT (255)));
1800       DONE;
1801     }
1802 ")
1803
1804 (define_insn ""
1805   [(set (match_operand:SI 0 "s_register_operand" "=r")
1806         (zero_extend:SI (match_operand:QI 1 "memory_operand" "m")))]
1807   ""
1808   "ldr%?b\\t%0, %1\\t%@ zero_extendqisi2"
1809 [(set_attr "type" "load")])
1810
1811 (define_split
1812   [(set (match_operand:SI 0 "s_register_operand" "")
1813         (zero_extend:SI (subreg:QI (match_operand:SI 1 "" "") 0)))
1814    (clobber (match_operand:SI 2 "s_register_operand" ""))]
1815   "GET_CODE (operands[1]) != MEM"
1816   [(set (match_dup 2) (match_dup 1))
1817    (set (match_dup 0) (and:SI (match_dup 2) (const_int 255)))]
1818   "")
1819
1820 (define_insn ""
1821   [(set (reg:CC_NOOV 24)
1822         (compare:CC_NOOV (match_operand:QI 0 "s_register_operand" "r")
1823                          (const_int 0)))]
1824   ""
1825   "tst\\t%0, #255"
1826 [(set_attr "conds" "set")])
1827
1828 (define_expand "extendhisi2"
1829   [(set (match_dup 2)
1830         (ashift:SI (match_operand:HI 1 "nonimmediate_operand" "")
1831                    (const_int 16)))
1832    (set (match_operand:SI 0 "s_register_operand" "")
1833         (ashiftrt:SI (match_dup 2)
1834                      (const_int 16)))]
1835   ""
1836   "
1837 {
1838   if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM)
1839     {
1840       emit_insn (gen_extendhisi2_mem (operands[0], operands[1]));
1841       DONE;
1842     }
1843   if (! s_register_operand (operands[1], HImode))
1844     operands[1] = copy_to_mode_reg (HImode, operands[1]);
1845   operands[1] = gen_lowpart (SImode, operands[1]);
1846   operands[2] = gen_reg_rtx (SImode);
1847 }")
1848
1849 (define_expand "extendhisi2_mem"
1850   [(set (match_dup 2) (zero_extend:SI (mem:QI (match_operand:HI 1 "" ""))))
1851    (set (match_dup 3)
1852         (zero_extend:SI (mem:QI (plus:SI (match_dup 1) (const_int 1)))))
1853    (set (match_dup 6) (ashift:SI (match_dup 4) (const_int 24)))
1854    (set (match_operand:SI 0 "" "")
1855         (ior:SI (ashiftrt:SI (match_dup 6) (const_int 16)) (match_dup 5)))]
1856   ""
1857   "
1858   operands[0] = gen_lowpart (SImode, operands[0]);
1859   operands[1] = copy_to_mode_reg (SImode, XEXP (operands[1], 0));
1860   operands[2] = gen_reg_rtx (SImode);
1861   operands[3] = gen_reg_rtx (SImode);
1862   operands[6] = gen_reg_rtx (SImode);
1863
1864   if (BYTES_BIG_ENDIAN)
1865     {
1866       operands[4] = operands[2];
1867       operands[5] = operands[3];
1868     }
1869   else
1870     {
1871       operands[4] = operands[3];
1872       operands[5] = operands[2];
1873     }
1874 ")
1875
1876 (define_expand "extendqihi2"
1877   [(set (match_dup 2)
1878         (ashift:SI (match_operand:QI 1 "s_register_operand" "")
1879                    (const_int 24)))
1880    (set (match_operand:HI 0 "s_register_operand" "")
1881         (ashiftrt:SI (match_dup 2)
1882                      (const_int 24)))]
1883   ""
1884   "
1885 { operands[0] = gen_lowpart (SImode, operands[0]);
1886   operands[1] = gen_lowpart (SImode, operands[1]);
1887   operands[2] = gen_reg_rtx (SImode); }")
1888
1889 (define_expand "extendqisi2"
1890   [(set (match_dup 2)
1891         (ashift:SI (match_operand:QI 1 "s_register_operand" "")
1892                    (const_int 24)))
1893    (set (match_operand:SI 0 "s_register_operand" "")
1894         (ashiftrt:SI (match_dup 2)
1895                      (const_int 24)))]
1896   ""
1897   "
1898 { operands[1] = gen_lowpart (SImode, operands[1]);
1899   operands[2] = gen_reg_rtx (SImode); }")
1900
1901 (define_insn "extendsfdf2"
1902   [(set (match_operand:DF 0 "s_register_operand" "=f")
1903         (float_extend:DF (match_operand:SF 1 "s_register_operand" "f")))]
1904   ""
1905   "mvf%?d\\t%0, %1"
1906 [(set_attr "type" "ffarith")])
1907
1908 (define_insn "extendsfxf2"
1909   [(set (match_operand:XF 0 "s_register_operand" "=f")
1910         (float_extend:XF (match_operand:SF 1 "s_register_operand" "f")))]
1911   "ENABLE_XF_PATTERNS"
1912   "mvf%?e\\t%0, %1"
1913 [(set_attr "type" "ffarith")])
1914
1915 (define_insn "extenddfxf2"
1916   [(set (match_operand:XF 0 "s_register_operand" "=f")
1917         (float_extend:XF (match_operand:DF 1 "s_register_operand" "f")))]
1918   "ENABLE_XF_PATTERNS"
1919   "mvf%?e\\t%0, %1"
1920 [(set_attr "type" "ffarith")])
1921
1922 \f
1923 ;; Move insns (including loads and stores)
1924
1925 ;; XXX Just some ideas about movti.
1926 ;; I don't think these are a good idea on the arm, there just aren't enough
1927 ;; registers
1928 ;;(define_expand "loadti"
1929 ;;  [(set (match_operand:TI 0 "s_register_operand" "")
1930 ;;      (mem:TI (match_operand:SI 1 "address_operand" "")))]
1931 ;;  "" "")
1932
1933 ;;(define_expand "storeti"
1934 ;;  [(set (mem:TI (match_operand:TI 0 "address_operand" ""))
1935 ;;      (match_operand:TI 1 "s_register_operand" ""))]
1936 ;;  "" "")
1937
1938 ;;(define_expand "movti"
1939 ;;  [(set (match_operand:TI 0 "general_operand" "")
1940 ;;      (match_operand:TI 1 "general_operand" ""))]
1941 ;;  ""
1942 ;;  "
1943 ;;{
1944 ;;  rtx insn;
1945 ;;
1946 ;;  if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
1947 ;;    operands[1] = copy_to_reg (operands[1]);
1948 ;;  if (GET_CODE (operands[0]) == MEM)
1949 ;;    insn = gen_storeti (XEXP (operands[0], 0), operands[1]);
1950 ;;  else if (GET_CODE (operands[1]) == MEM)
1951 ;;    insn = gen_loadti (operands[0], XEXP (operands[1], 0));
1952 ;;  else
1953 ;;    FAIL;
1954 ;;
1955 ;;  emit_insn (insn);
1956 ;;  DONE;
1957 ;;}")
1958
1959 ;; Recognise garbage generated above.
1960
1961 ;;(define_insn ""
1962 ;;  [(set (match_operand:TI 0 "general_operand" "=r,r,r,<,>,m")
1963 ;;      (match_operand:TI 1 "general_operand" "<,>,m,r,r,r"))]
1964 ;;  ""
1965 ;;  "*
1966 ;;  {
1967 ;;    register mem = (which_alternative < 3);
1968 ;;    register char *template;
1969 ;;
1970 ;;    operands[mem] = XEXP (operands[mem], 0);
1971 ;;    switch (which_alternative)
1972 ;;      {
1973 ;;      case 0: template = \"ldmdb\\t%1!, %M0\"; break;
1974 ;;      case 1: template = \"ldmia\\t%1!, %M0\"; break;
1975 ;;      case 2: template = \"ldmia\\t%1, %M0\"; break;
1976 ;;      case 3: template = \"stmdb\\t%0!, %M1\"; break;
1977 ;;      case 4: template = \"stmia\\t%0!, %M1\"; break;
1978 ;;      case 5: template = \"stmia\\t%0, %M1\"; break;
1979 ;;      }
1980 ;;    output_asm_insn (template, operands);
1981 ;;    return \"\";
1982 ;;  }")
1983
1984
1985 (define_insn "movdi"
1986   [(set (match_operand:DI 0 "di_operand" "=r,r,r,o<>,r")
1987         (match_operand:DI 1 "di_operand" "rIK,n,o<>,r,F"))]
1988   ""
1989   "*
1990   return (output_move_double (operands));
1991 "
1992 [(set_attr "length" "8,32,8,8,32")
1993  (set_attr "type" "*,*,load,store2,*")])
1994
1995 (define_expand "movsi"
1996   [(set (match_operand:SI 0 "general_operand" "")
1997         (match_operand:SI 1 "general_operand" ""))]
1998   ""
1999   "
2000   /* Everything except mem = const or mem = mem can be done easily */
2001   if (GET_CODE (operands[0]) == MEM)
2002     operands[1] = force_reg (SImode, operands[1]);
2003   if (GET_CODE (operands[1]) == CONST_INT
2004       && !(const_ok_for_arm (INTVAL (operands[1]))
2005            || const_ok_for_arm (~INTVAL (operands[1]))))
2006     {
2007       arm_split_constant (SET, SImode, INTVAL (operands[1]), operands[0],
2008                           NULL_RTX,
2009                           (reload_in_progress || reload_completed ? 0
2010                            : preserve_subexpressions_p ()));
2011       DONE;
2012     }
2013 ")
2014
2015 (define_insn ""
2016   [(set (match_operand:SI 0 "general_operand" "=r,r,r,r,m,r,r")
2017         (match_operand:SI 1 "general_operand"  "R,m,K,rI,r,S,?n"))]
2018   "(register_operand (operands[0], SImode)
2019     && (GET_CODE (operands[1]) != SYMBOL_REF
2020         || CONSTANT_ADDRESS_P (operands[1])))
2021    || register_operand (operands[1], SImode)"
2022   "*
2023   switch (which_alternative)
2024     {
2025     case 0:
2026       /* NB Calling get_attr_length may cause the insn to be re-extracted... */
2027       if (get_attr_length (insn) == 8)
2028         {
2029           /* ... so modify the operands here.  */
2030           operands[1] = XEXP (operands[1], 0);
2031           output_asm_insn (\"sub%?\\t%0, %|pc, #(8 + . - %a1) & ~4095\",
2032                            operands);
2033           output_asm_insn (\"ldr%?\\t%0, [%0, #- ((4 + . - %a1) & 4095)]\",
2034                            operands);
2035         }
2036       else
2037         {
2038           /* ... and here.  */
2039           operands[1] = XEXP (operands[1], 0);
2040           output_asm_insn (\"ldr%?\\t%0, [%|pc, %1 - . - 8]\", operands);
2041         }
2042       return \"\";
2043
2044     case 1:
2045       if (GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
2046           &&  CONSTANT_POOL_ADDRESS_P (XEXP (operands[1], 0)))
2047         abort ();
2048       return \"ldr%?\\t%0, %1\";
2049
2050     case 3:
2051       return \"mov%?\\t%0, %1\";
2052     case 2:
2053       return \"mvn%?\\t%0, #%B1\";
2054     case 4:
2055       return \"str%?\\t%1, %0\";
2056     case 5:
2057       return output_load_symbol (insn, operands);
2058     case 6:
2059       return \"#\";
2060     }
2061 "
2062 [(set (attr "length")
2063       (cond [(eq_attr "alternative" "0")
2064              (if_then_else
2065               (gt (minus
2066                    (pc)
2067                    (symbol_ref "const_pool_offset (XEXP (operands[1], 0))"))
2068                   (const_int 4087))
2069               (const_int 8)
2070               (const_int 4))
2071              (ior (eq_attr "alternative" "5")
2072                   (eq_attr "alternative" "6")) (const_int 16)]
2073             (const_int 4)))
2074  (set_attr "type" "load,load,*,*,store1,*,*")])
2075
2076 (define_split
2077   [(set (match_operand:SI 0 "s_register_operand" "")
2078         (match_operand:SI 1 "const_int_operand" ""))]
2079   "! (const_ok_for_arm (INTVAL (operands[1]))
2080       || const_ok_for_arm (~INTVAL (operands[1])))"
2081   [(clobber (const_int 0))]
2082   "
2083   arm_split_constant (SET, SImode, INTVAL (operands[1]), operands[0],
2084                       NULL_RTX, 0);
2085   DONE;
2086 ")
2087
2088 ;; If copying one reg to another we can set the condition codes according to
2089 ;; its value.  Such a move is common after a return from subroutine and the
2090 ;; result is being tested against zero.
2091
2092 (define_insn ""
2093   [(set (reg:CC 24) (compare (match_operand:SI 1 "s_register_operand" "0,r")
2094                              (const_int 0)))
2095    (set (match_operand:SI 0 "s_register_operand" "=r,r") (match_dup 1))]
2096   ""
2097   "@
2098    cmp%?\\t%0, #0
2099    sub%?s\\t%0, %1, #0"
2100 [(set_attr "conds" "set")])
2101
2102 ;; Subroutine to store a half word from a register into memory.
2103 ;; Operand 0 is the source register (HImode)
2104 ;; Operand 1 is the destination address in a register (SImode)
2105
2106 ;; In both this routine and the next, we must be careful not to spill
2107 ;; a memory address of reg+large_const into a seperate PLUS insn, since this
2108 ;; can generate unrecognizable rtl.
2109
2110 (define_expand "storehi"
2111   [;; store the low byte
2112    (set (mem:QI (match_operand:SI 1 "" "")) (match_dup 3))
2113    ;; extract the high byte
2114    (set (match_dup 2)
2115         (ashiftrt:SI (match_operand 0 "" "") (const_int 8)))
2116    ;; store the high byte
2117    (set (mem:QI (match_dup 4))
2118         (subreg:QI (match_dup 2) 0))]   ;explicit subreg safe
2119   ""
2120   "
2121 {
2122   enum rtx_code code = GET_CODE (operands[1]);
2123
2124   if ((code == PLUS || code == MINUS)
2125       && (GET_CODE (XEXP (operands[1], 1)) == REG
2126           || GET_CODE (XEXP (operands[1], 0)) != REG))
2127     operands[1] = force_reg (SImode, operands[1]);
2128   operands[4] = plus_constant (operands[1], 1);
2129   operands[3] = gen_lowpart (QImode, operands[0]);
2130   operands[0] = gen_lowpart (SImode, operands[0]);
2131   operands[2] = gen_reg_rtx (SImode);
2132 }
2133 ")
2134
2135 (define_expand "storehi_bigend"
2136   [(set (mem:QI (match_dup 4)) (match_dup 3))
2137    (set (match_dup 2)
2138         (ashiftrt:SI (match_operand 0 "" "") (const_int 8)))
2139    (set (mem:QI (match_operand 1 "" ""))
2140         (subreg:QI (match_dup 2) 0))]
2141   ""
2142   "
2143 {
2144   enum rtx_code code = GET_CODE (operands[1]);
2145   if ((code == PLUS || code == MINUS)
2146       && (GET_CODE (XEXP (operands[1], 1)) == REG
2147           || GET_CODE (XEXP (operands[1], 0)) != REG))
2148     operands[1] = force_reg (SImode, operands[1]);
2149
2150   operands[4] = plus_constant (operands[1], 1);
2151   operands[3] = gen_lowpart (QImode, operands[0]);
2152   operands[0] = gen_lowpart (SImode, operands[0]);
2153   operands[2] = gen_reg_rtx (SImode);
2154 }
2155 ")
2156
2157 ;; Subroutine to store a half word integer constant into memory.
2158 (define_expand "storeinthi"
2159   [(set (mem:QI (match_operand:SI 0 "" ""))
2160         (subreg:QI (match_operand 1 "" "") 0))
2161    (set (mem:QI (match_dup 3)) (subreg:QI (match_dup 2) 0))]
2162   ""
2163   "
2164 {
2165   HOST_WIDE_INT value = INTVAL (operands[1]);
2166   enum rtx_code code = GET_CODE (operands[0]);
2167
2168   if ((code == PLUS || code == MINUS)
2169       && (GET_CODE (XEXP (operands[0], 1)) == REG
2170           || GET_CODE (XEXP (operands[0], 0)) != REG))
2171   operands[0] = force_reg (SImode, operands[0]);
2172
2173   operands[1] = gen_reg_rtx (SImode);
2174   if (BYTES_BIG_ENDIAN)
2175     {
2176       emit_insn (gen_movsi (operands[1], GEN_INT ((value >> 8) & 255)));
2177       if ((value & 255) == ((value >> 8) & 255))
2178         operands[2] = operands[1];
2179       else
2180         {
2181           operands[2] = gen_reg_rtx (SImode);
2182           emit_insn (gen_movsi (operands[2], GEN_INT (value & 255)));
2183         }
2184     }
2185   else
2186     {
2187       emit_insn (gen_movsi (operands[1], GEN_INT (value & 255)));
2188       if ((value & 255) == ((value >> 8) & 255))
2189         operands[2] = operands[1];
2190       else
2191         {
2192           operands[2] = gen_reg_rtx (SImode);
2193           emit_insn (gen_movsi (operands[2], GEN_INT ((value >> 8) & 255)));
2194         }
2195     }
2196
2197   operands[3] = plus_constant (operands[0], 1);
2198 }
2199 ")
2200
2201 (define_expand "movhi"
2202   [(set (match_operand:HI 0 "general_operand" "")
2203         (match_operand:HI 1 "general_operand" ""))]
2204   ""
2205   "
2206 {
2207   rtx insn;
2208
2209   if (! (reload_in_progress || reload_completed))
2210     {
2211       if (GET_CODE (operands[0]) == MEM)
2212         {
2213           if (GET_CODE (operands[1]) == CONST_INT)
2214             emit_insn (gen_storeinthi (XEXP (operands[0], 0), operands[1]));
2215           else
2216             {
2217               if (GET_CODE (operands[1]) == MEM)
2218                 operands[1] = force_reg (HImode, operands[1]);
2219               if (BYTES_BIG_ENDIAN)
2220                 emit_insn (gen_storehi_bigend (operands[1],
2221                                                XEXP (operands[0], 0)));
2222               else
2223                 emit_insn (gen_storehi (operands[1], XEXP (operands[0], 0)));
2224             }
2225           DONE;
2226         }
2227       /* Sign extend a constant, and keep it in an SImode reg.  */
2228       else if (GET_CODE (operands[1]) == CONST_INT)
2229         {
2230           rtx reg = gen_reg_rtx (SImode);
2231           HOST_WIDE_INT val = INTVAL (operands[1]) & 0xffff;
2232
2233           /* If the constant is already valid, leave it alone.  */
2234           if (! const_ok_for_arm (val))
2235             {
2236               /* If setting all the top bits will make the constant
2237                  loadable in a single instruction, then set them.
2238                  Otherwise, sign extend the number.  */
2239
2240               if (const_ok_for_arm (~ (val | ~0xffff)))
2241                 val |= ~0xffff;
2242               else if (val & 0x8000)
2243                 val |= ~0xffff;
2244             }
2245
2246           emit_insn (gen_movsi (reg, GEN_INT (val)));
2247           operands[1] = gen_rtx (SUBREG, HImode, reg, 0);
2248         }
2249       else if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM)
2250         {
2251           rtx reg = gen_reg_rtx (SImode);
2252           emit_insn (gen_movhi_bytes (reg, operands[1]));
2253           operands[1] = gen_lowpart (HImode, reg);
2254         }
2255       else if (BYTES_BIG_ENDIAN && GET_CODE (operands[1]) == MEM)
2256         {
2257           emit_insn (gen_movhi_bigend (operands[0], operands[1]));
2258           DONE;
2259         }
2260     }
2261 }
2262 ")
2263
2264 (define_expand "movhi_bytes"
2265   [(set (match_dup 2) (zero_extend:SI (mem:QI (match_operand:HI 1 "" ""))))
2266    (set (match_dup 3)
2267         (zero_extend:SI (mem:QI (plus:SI (match_dup 1) (const_int 1)))))
2268    (set (match_operand:SI 0 "" "")
2269          (ior:SI (ashift:SI (match_dup 4) (const_int 8)) (match_dup 5)))]
2270   ""
2271   "
2272   operands[0] = gen_lowpart (SImode, operands[0]);
2273   operands[1] = copy_to_mode_reg (SImode, XEXP (operands[1], 0));
2274   operands[2] = gen_reg_rtx (SImode);
2275   operands[3] = gen_reg_rtx (SImode);
2276
2277   if (BYTES_BIG_ENDIAN)
2278     {
2279       operands[4] = operands[2];
2280       operands[5] = operands[3];
2281     }
2282   else
2283     {
2284       operands[4] = operands[3];
2285       operands[5] = operands[2];
2286     }
2287 ")
2288
2289 (define_expand "movhi_bigend"
2290   [(set (match_dup 2)
2291         (rotate:SI (subreg:SI (match_operand:HI 1 "memory_operand" "") 0)
2292                    (const_int 16)))
2293    (set (match_dup 3)
2294         (ashiftrt:SI (match_dup 2) (const_int 16)))
2295    (set (match_operand:HI 0 "s_register_operand" "")
2296         (subreg:HI (match_dup 3) 0))]
2297   ""
2298   "
2299   operands[2] = gen_reg_rtx (SImode);
2300   operands[3] = gen_reg_rtx (SImode);
2301 ")
2302
2303 ;; Pattern to recognise insn generated default case above
2304
2305 (define_insn ""
2306   [(set (match_operand:HI 0 "general_operand" "=r,r,r")
2307         (match_operand:HI 1 "general_operand"  "rI,K,m"))]
2308   "! BYTES_BIG_ENDIAN
2309    && ! TARGET_SHORT_BY_BYTES
2310    && (GET_CODE (operands[1]) != CONST_INT
2311        || const_ok_for_arm (INTVAL (operands[1]))
2312        || const_ok_for_arm (~INTVAL (operands[1])))"
2313   "@
2314    mov%?\\t%0, %1\\t%@ movhi
2315    mvn%?\\t%0, #%B1\\t%@ movhi
2316    ldr%?\\t%0, %1\\t%@ movhi"
2317 [(set_attr "type" "*,*,load")])
2318
2319 (define_insn ""
2320   [(set (match_operand:HI 0 "s_register_operand" "=r,r,r")
2321         (match_operand:HI 1 "general_operand"  "rI,K,m"))]
2322   "BYTES_BIG_ENDIAN
2323    && ! TARGET_SHORT_BY_BYTES
2324    && (GET_CODE (operands[1]) != CONST_INT
2325        || const_ok_for_arm (INTVAL (operands[1]))
2326        || const_ok_for_arm (~INTVAL (operands[1])))"
2327   "@
2328    mov%?\\t%0, %1\\t%@ movhi
2329    mvn%?\\t%0, #%B1\\t%@ movhi
2330    ldr%?\\t%0, %1\\t%@ movhi_bigend\;mov%?\\t%0, %0, asr #16"
2331 [(set_attr "type" "*,*,load")
2332  (set_attr "length" "4,4,8")])
2333
2334 (define_insn ""
2335   [(set (match_operand:SI 0 "s_register_operand" "=r")
2336         (rotate:SI (subreg:SI (match_operand:HI 1 "memory_operand" "m") 0)
2337                    (const_int 16)))]
2338   "BYTES_BIG_ENDIAN
2339    && ! TARGET_SHORT_BY_BYTES"
2340   "ldr%?\\t%0, %1\\t%@ movhi_bigend"
2341 [(set_attr "type" "load")])
2342
2343 (define_insn ""
2344   [(set (match_operand:HI 0 "s_register_operand" "=r,r")
2345         (match_operand:HI 1 "arm_rhs_operand"  "rI,K"))]
2346   "TARGET_SHORT_BY_BYTES"
2347   "@
2348    mov%?\\t%0, %1\\t%@ movhi
2349    mvn%?\\t%0, #%B1\\t%@ movhi")
2350
2351
2352 (define_expand "reload_outhi"
2353   [(parallel [(match_operand:HI 0 "reload_memory_operand" "=o")
2354               (match_operand:HI 1 "s_register_operand" "r")
2355               (match_operand:SI 2 "s_register_operand" "=&r")])]
2356   ""
2357   "
2358   arm_reload_out_hi (operands);
2359   DONE;
2360 ")
2361
2362 (define_expand "reload_inhi"
2363   [(parallel [(match_operand:HI 0 "s_register_operand" "=r")
2364               (match_operand:HI 1 "reload_memory_operand" "o")
2365               (match_operand:SI 2 "s_register_operand" "=&r")])]
2366   "TARGET_SHORT_BY_BYTES"
2367   "
2368   arm_reload_in_hi (operands);
2369   DONE;
2370 ")
2371
2372 (define_expand "movqi"
2373   [(set (match_operand:QI 0 "general_operand" "")
2374         (match_operand:QI 1 "general_operand" ""))]
2375   ""
2376   "
2377   /* Everything except mem = const or mem = mem can be done easily */
2378
2379   if (!(reload_in_progress || reload_completed))
2380     {
2381       if (GET_CODE (operands[1]) == CONST_INT)
2382         {
2383           rtx reg = gen_reg_rtx (SImode);
2384
2385           emit_insn (gen_movsi (reg, operands[1]));
2386           operands[1] = gen_rtx (SUBREG, QImode, reg, 0);
2387         }
2388       if (GET_CODE (operands[0]) == MEM)
2389         operands[1] = force_reg (QImode, operands[1]);
2390     }
2391 ")
2392
2393
2394 (define_insn ""
2395   [(set (match_operand:QI 0 "general_operand" "=r,r,r,m")
2396         (match_operand:QI 1 "general_operand" "rI,K,m,r"))]
2397   "register_operand (operands[0], QImode)
2398    || register_operand (operands[1], QImode)"
2399   "@
2400    mov%?\\t%0, %1
2401    mvn%?\\t%0, #%B1
2402    ldr%?b\\t%0, %1
2403    str%?b\\t%1, %0"
2404 [(set_attr "type" "*,*,load,store1")])
2405
2406 (define_expand "movsf"
2407   [(set (match_operand:SF 0 "general_operand" "")
2408         (match_operand:SF 1 "general_operand" ""))]
2409   ""
2410   "
2411   if (GET_CODE (operands[1]) == CONST_DOUBLE
2412       && ((GET_CODE (operands[0]) == REG
2413            && REGNO (operands[0]) < 16)
2414           || ! (const_double_rtx_ok_for_fpu (operands[1])
2415                 || neg_const_double_rtx_ok_for_fpu (operands[1]))))
2416     {
2417       extern int optimize;
2418       rtx mem = force_const_mem (SFmode, operands[1]);
2419       rtx addr;
2420
2421       if (reload_in_progress || reload_completed)
2422         addr = gen_rtx (REG, SImode, REGNO (operands[0]));
2423       else
2424         addr = gen_reg_rtx (SImode);
2425       if (optimize == 0)
2426         {
2427           rtx ptr = force_const_mem (SImode, XEXP (mem, 0));
2428           emit_insn (gen_movsi (addr, ptr));
2429         }
2430       else
2431         emit_insn (gen_movsi (addr, XEXP (mem, 0)));
2432       operands[1] = gen_rtx (MEM, SFmode, addr);
2433     }
2434   if (GET_CODE (operands[0]) == MEM)
2435     operands[1] = force_reg (SFmode, operands[1]);
2436 ")
2437
2438 (define_insn ""
2439   [(set (match_operand:SF 0 "general_operand" "=f,f,f,m,f,r,r,r,m")
2440         (match_operand:SF 1 "general_operand" "fG,H,m,f,r,f,r,m,r"))]
2441   "GET_CODE (operands[0]) != MEM || register_operand (operands[1], SFmode)"
2442   "@
2443    mvf%?s\\t%0, %1
2444    mnf%?s\\t%0, #%N1
2445    ldf%?s\\t%0, %1
2446    stf%?s\\t%1, %0
2447    str%?\\t%1, [%|sp, #-4]!\;ldf%?s\\t%0, [%|sp], #4
2448    stf%?s\\t%1, [%|sp, #-4]!\;ldr%?\\t%0, [%|sp], #4
2449    mov%?\\t%0, %1
2450    ldr%?\\t%0, %1\\t%@ float
2451    str%?\\t%1, %0\\t%@ float"
2452 [(set_attr "length" "4,4,4,4,8,8,4,4,4")
2453  (set_attr "type"
2454          "ffarith,ffarith,f_load,f_store,r_mem_f,f_mem_r,*,load,store1")])
2455
2456 (define_expand "movdf"
2457   [(set (match_operand:DF 0 "general_operand" "")
2458         (match_operand:DF 1 "general_operand" ""))]
2459   ""
2460   "
2461   if (GET_CODE (operands[1]) == CONST_DOUBLE
2462       && ((GET_CODE (operands[0]) == REG
2463            && REGNO (operands[0]) < 16)
2464           || ! (const_double_rtx_ok_for_fpu (operands[1])
2465                 || neg_const_double_rtx_ok_for_fpu (operands[1]))))
2466     {
2467       extern int optimize;
2468       rtx mem = force_const_mem (DFmode, operands[1]);
2469       rtx addr;
2470
2471       if (reload_in_progress || reload_completed)
2472         addr = gen_rtx (REG, SImode, REGNO (operands[0]));
2473       else
2474         addr = gen_reg_rtx (SImode);
2475       if (optimize == 0)
2476         {
2477           rtx ptr = force_const_mem (SImode, XEXP (mem, 0));
2478           emit_insn (gen_movsi (addr, ptr));
2479         }
2480       else
2481         emit_insn (gen_movsi (addr, XEXP (mem, 0)));
2482       operands[1] = gen_rtx (MEM, DFmode, addr);
2483     }
2484   if (GET_CODE (operands[0]) == MEM)
2485     operands[1] = force_reg (DFmode, operands[1]);
2486 ")
2487
2488 ;; Reloading a df mode value stored in integer regs to memory can require a
2489 ;; scratch reg.
2490 (define_expand "reload_outdf"
2491   [(match_operand:DF 0 "reload_memory_operand" "=o")
2492    (match_operand:DF 1 "s_register_operand" "r")
2493    (match_operand:SI 2 "s_register_operand" "=&r")]
2494   ""
2495   "
2496   if (GET_CODE (XEXP (operands[0], 0)) == REG)
2497     operands[2] = XEXP (operands[0], 0);
2498   else
2499     emit_insn (gen_addsi3 (operands[2], XEXP (XEXP (operands[0], 0), 0),
2500                            XEXP (XEXP (operands[0], 0), 1)));
2501   emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (MEM, DFmode, operands[2]),
2502                       operands[1]));
2503   DONE;
2504 ")
2505
2506 (define_insn ""
2507   [(set (match_operand:DF 0 "general_operand" "=r,Q#m,r,f,f,f,f,m,!f,!r,r")
2508         (match_operand:DF 1 "general_operand"
2509                 "Q,r,?o,?f,!G,!H,m,f,r,f,??r"))]
2510   "GET_CODE (operands[0]) != MEM || register_operand (operands[1], DFmode)"
2511   "*
2512 {
2513   rtx ops[3];
2514
2515   switch (which_alternative)
2516     {
2517     case 0:
2518       return \"ldm%?ia\\t%m1, {%0, %R0}\\t%@ double\";
2519
2520     case 1:
2521       return \"stm%?ia\\t%m0, {%1, %R1}\\t%@ double\";
2522
2523     case 2:
2524       ops[0] = operands[0];
2525       ops[1] = XEXP (XEXP (operands[1], 0), 0);
2526       ops[2] = XEXP (XEXP (operands[1], 0), 1);
2527       if (!INTVAL (ops[2]) || const_ok_for_arm (INTVAL (ops[2])))
2528         output_asm_insn (\"add%?\\t%0, %1, %2\", ops);
2529       else
2530         output_asm_insn (\"sub%?\\t%0, %1, #%n2\", ops);
2531       return \"ldm%?ia\\t%0, {%0, %R0}\\t%@ double\";
2532
2533     case 3:
2534     case 4:
2535       return \"mvf%?d\\t%0, %1\";
2536
2537     case 5: return \"mnf%?d\\t%0, #%N1\";
2538     case 6: return \"ldf%?d\\t%0, %1\";
2539     case 7: return \"stf%?d\\t%1, %0\";
2540     case 8: return output_mov_double_fpu_from_arm (operands);
2541     case 9: return output_mov_double_arm_from_fpu (operands);
2542     case 10: return output_move_double (operands);
2543     }
2544 }
2545 "
2546 [(set_attr "length" "4,4,8,4,4,4,4,4,8,8,8")
2547  (set_attr "type"
2548 "load,store2,load,ffarith,ffarith,ffarith,f_load,f_store,r_mem_f,f_mem_r,*")])
2549
2550 (define_expand "movxf"
2551   [(set (match_operand:XF 0 "general_operand" "")
2552         (match_operand:XF 1 "general_operand" ""))]
2553   "ENABLE_XF_PATTERNS"
2554   "")
2555
2556 ;; Even when the XFmode patterns aren't enabled, we enable this after
2557 ;; reloading so that we can push floating point registers in the prologue.
2558
2559 (define_insn ""
2560   [(set (match_operand:XF 0 "general_operand" "=f,f,f,m,f,r,r")
2561         (match_operand:XF 1 "general_operand" "fG,H,m,f,r,f,r"))]
2562   "ENABLE_XF_PATTERNS || reload_completed"
2563   "*
2564   switch (which_alternative)
2565     {
2566     case 0: return \"mvf%?e\\t%0, %1\";
2567     case 1: return \"mnf%?e\\t%0, #%N1\";
2568     case 2: return \"ldf%?e\\t%0, %1\";
2569     case 3: return \"stf%?e\\t%1, %0\";
2570     case 4: return output_mov_long_double_fpu_from_arm (operands);
2571     case 5: return output_mov_long_double_arm_from_fpu (operands);
2572     case 6: return output_mov_long_double_arm_from_arm (operands);
2573     }
2574 "
2575 [(set_attr "length" "4,4,4,4,8,8,12")
2576  (set_attr "type" "ffarith,ffarith,f_load,f_store,r_mem_f,f_mem_r,*")])
2577 \f
2578
2579 ;; load- and store-multiple insns
2580 ;; The arm can load/store any set of registers, provided that they are in
2581 ;; ascending order; but that is beyond GCC so stick with what it knows.
2582
2583 (define_expand "load_multiple"
2584   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
2585                           (match_operand:SI 1 "" ""))
2586                      (use (match_operand:SI 2 "" ""))])]
2587   ""
2588   "
2589   /* Support only fixed point registers */
2590   if (GET_CODE (operands[2]) != CONST_INT
2591       || INTVAL (operands[2]) > 14
2592       || INTVAL (operands[2]) < 2
2593       || GET_CODE (operands[1]) != MEM
2594       || GET_CODE (operands[0]) != REG
2595       || REGNO (operands[0]) > 14
2596       || REGNO (operands[0]) + INTVAL (operands[2]) > 15)
2597     FAIL;
2598
2599   operands[3]
2600             = arm_gen_load_multiple (REGNO (operands[0]), INTVAL (operands[2]),
2601                                      force_reg (SImode, XEXP (operands[1], 0)),
2602                                      TRUE, FALSE);
2603 ")
2604
2605 ;; Load multiple with write-back
2606
2607 (define_insn ""
2608   [(match_parallel 0 "load_multiple_operation"
2609                    [(set (match_operand:SI 1 "s_register_operand" "+r")
2610                          (plus:SI (match_dup 1)
2611                                   (match_operand:SI 2 "immediate_operand" "n")))
2612                     (set (match_operand:SI 3 "s_register_operand" "=r")
2613                          (mem:SI (match_dup 1)))])]
2614   "(INTVAL (operands[2])  == 4 * (XVECLEN (operands[0], 0) - 2))"
2615   "*
2616 {
2617   rtx ops[3];
2618   int count = XVECLEN (operands[0], 0);
2619
2620   ops[0] = XEXP (SET_SRC (XVECEXP (operands[0], 0, 0)), 0);
2621   ops[1] = SET_DEST (XVECEXP (operands[0], 0, 1));
2622   ops[2] = SET_DEST (XVECEXP (operands[0], 0, count - 2));
2623
2624   output_asm_insn (\"ldm%?ia\\t%0!, {%1-%2}\\t%@ load multiple\", ops);
2625   return \"\";
2626 }
2627 "
2628 [(set_attr "type" "load")])
2629
2630 ;; Ordinary load multiple
2631
2632 (define_insn ""
2633   [(match_parallel 0 "load_multiple_operation"
2634                    [(set (match_operand:SI 1 "s_register_operand" "=r")
2635                          (match_operand:SI 2 "indirect_operand" "Q"))])]
2636   ""
2637   "*
2638 {
2639   rtx ops[3];
2640   int count = XVECLEN (operands[0], 0);
2641
2642   ops[0] = XEXP (SET_SRC (XVECEXP (operands[0], 0, 0)), 0);
2643   ops[1] = SET_DEST (XVECEXP (operands[0], 0, 0));
2644   ops[2] = SET_DEST (XVECEXP (operands[0], 0, count - 1));
2645
2646   output_asm_insn (\"ldm%?ia\\t%0, {%1-%2}\\t%@ load multiple\", ops);
2647   return \"\";
2648 }
2649 "
2650 [(set_attr "type" "load")])
2651
2652 (define_expand "store_multiple"
2653   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
2654                           (match_operand:SI 1 "" ""))
2655                      (use (match_operand:SI 2 "" ""))])]
2656   ""
2657   "
2658   /* Support only fixed point registers */
2659   if (GET_CODE (operands[2]) != CONST_INT
2660       || INTVAL (operands[2]) > 14
2661       || INTVAL (operands[2]) < 2
2662       || GET_CODE (operands[1]) != REG
2663       || GET_CODE (operands[0]) != MEM
2664       || REGNO (operands[1]) > 14
2665       || REGNO (operands[1]) + INTVAL (operands[2]) > 15)
2666     FAIL;
2667
2668   operands[3]
2669            = arm_gen_store_multiple (REGNO (operands[1]), INTVAL (operands[2]),
2670                                      force_reg (SImode, XEXP (operands[0], 0)),
2671                                      TRUE, FALSE);
2672 ")
2673
2674 ;; Store multiple with write-back
2675
2676 (define_insn ""
2677   [(match_parallel 0 "store_multiple_operation"
2678                    [(set (match_operand:SI 1 "s_register_operand" "+r")
2679                          (plus:SI (match_dup 1)
2680                                   (match_operand:SI 2 "immediate_operand" "n")))
2681                     (set (mem:SI (match_dup 1))
2682                          (match_operand:SI 3 "s_register_operand" "r"))])]
2683   "(INTVAL (operands[2]) == 4 * (XVECLEN (operands[0], 0) - 2))"
2684   "*
2685 {
2686   rtx ops[3];
2687   int count = XVECLEN (operands[0], 0);
2688
2689   ops[0] = XEXP (SET_SRC (XVECEXP (operands[0], 0, 0)), 0);
2690   ops[1] = SET_SRC (XVECEXP (operands[0], 0, 1));
2691   ops[2] = SET_SRC (XVECEXP (operands[0], 0, count - 2));
2692
2693   output_asm_insn (\"stm%?ia\\t%0!, {%1-%2}\\t%@ str multiple\", ops);
2694   return \"\";
2695 }
2696 "
2697 [(set (attr "type")
2698       (cond [(eq (symbol_ref "XVECLEN (operands[0],0)") (const_int 4))
2699                 (const_string "store2")
2700              (eq (symbol_ref "XVECLEN (operands[0],0)") (const_int 5))
2701                 (const_string "store3")]
2702           (const_string "store4")))])
2703
2704 ;; Ordinary store multiple
2705
2706 (define_insn ""
2707   [(match_parallel 0 "store_multiple_operation"
2708                    [(set (match_operand:SI 2 "indirect_operand" "=Q")
2709                          (match_operand:SI 1 "s_register_operand" "r"))])]
2710   ""
2711   "*
2712 {
2713   rtx ops[3];
2714   int count = XVECLEN (operands[0], 0);
2715
2716   ops[0] = XEXP (SET_DEST (XVECEXP (operands[0], 0, 0)), 0);
2717   ops[1] = SET_SRC (XVECEXP (operands[0], 0, 0));
2718   ops[2] = SET_SRC (XVECEXP (operands[0], 0, count - 1));
2719
2720   output_asm_insn (\"stm%?ia\\t%0, {%1-%2}\\t%@ str multiple\", ops);
2721   return \"\";
2722 }
2723 "
2724 [(set (attr "type")
2725       (cond [(eq (symbol_ref "XVECLEN (operands[0],0)") (const_int 3))
2726                 (const_string "store2")
2727              (eq (symbol_ref "XVECLEN (operands[0],0)") (const_int 4))
2728                 (const_string "store3")]
2729           (const_string "store4")))])
2730
2731 ;; Move a block of memory if it is word aligned and MORE than 2 words long.
2732 ;; We could let this apply for blocks of less than this, but it clobbers so
2733 ;; many registers that there is then probably a better way.
2734
2735 (define_expand "movstrqi"
2736   [(match_operand:BLK 0 "general_operand" "")
2737    (match_operand:BLK 1 "general_operand" "")
2738    (match_operand:SI 2 "const_int_operand" "")
2739    (match_operand:SI 3 "const_int_operand" "")]
2740   ""
2741   "
2742   if (arm_gen_movstrqi (operands))
2743     DONE;
2744   FAIL;
2745 ")
2746 \f
2747
2748 ;; Comparison and test insns
2749
2750 (define_expand "cmpsi"
2751   [(set (reg:CC 24)
2752         (compare:CC (match_operand:SI 0 "s_register_operand" "")
2753                     (match_operand:SI 1 "arm_add_operand" "")))]
2754   ""
2755   "
2756 {
2757   arm_compare_op0 = operands[0];
2758   arm_compare_op1 = operands[1];
2759   arm_compare_fp = 0;
2760   DONE;
2761 }
2762 ")
2763
2764 (define_expand "cmpsf"
2765   [(set (reg:CC 24)
2766         (compare:CC (match_operand:SF 0 "s_register_operand" "")
2767                     (match_operand:SF 1 "fpu_rhs_operand" "")))]
2768   ""
2769   "
2770 {
2771   arm_compare_op0 = operands[0];
2772   arm_compare_op1 = operands[1];
2773   arm_compare_fp = 1;
2774   DONE;
2775 }
2776 ")
2777
2778 (define_expand "cmpdf"
2779   [(set (reg:CC 24)
2780         (compare:CC (match_operand:DF 0 "s_register_operand" "")
2781                     (match_operand:DF 1 "fpu_rhs_operand" "")))]
2782   ""
2783   "
2784 {
2785   arm_compare_op0 = operands[0];
2786   arm_compare_op1 = operands[1];
2787   arm_compare_fp = 1;
2788   DONE;
2789 }
2790 ")
2791
2792 (define_expand "cmpxf"
2793   [(set (reg:CC 24)
2794         (compare:CC (match_operand:XF 0 "s_register_operand" "")
2795                     (match_operand:XF 1 "fpu_rhs_operand" "")))]
2796   "ENABLE_XF_PATTERNS"
2797   "
2798 {
2799   arm_compare_op0 = operands[0];
2800   arm_compare_op1 = operands[1];
2801   arm_compare_fp = 1;
2802   DONE;
2803 }
2804 ")
2805
2806 (define_insn ""
2807   [(set (match_operand 0 "cc_register" "")
2808         (compare (match_operand:SI 1 "s_register_operand" "r,r")
2809                  (match_operand:SI 2 "arm_add_operand" "rI,L")))]
2810   ""
2811   "@
2812    cmp%?\\t%1, %2
2813    cmn%?\\t%1, #%n2"
2814 [(set_attr "conds" "set")])
2815
2816 (define_insn ""
2817   [(set (match_operand 0 "cc_register" "")
2818         (compare (match_operand:SI 1 "s_register_operand" "r")
2819                  (neg:SI (match_operand:SI 2 "s_register_operand" "r"))))]
2820   ""
2821   "cmn%?\\t%1, %2"
2822 [(set_attr "conds" "set")])
2823
2824 (define_insn ""
2825   [(set (match_operand 0 "cc_register" "")
2826         (compare (match_operand:SI 1 "s_register_operand" "r")
2827                  (match_operator:SI 2 "shift_operator"
2828                   [(match_operand:SI 3 "s_register_operand" "r")
2829                    (match_operand:SI 4 "arm_rhs_operand" "rM")])))]
2830   ""
2831   "cmp%?\\t%1, %3%S2"
2832 [(set_attr "conds" "set")])
2833
2834 (define_insn ""
2835   [(set (match_operand 0 "cc_register" "")
2836         (compare (match_operand:SI 1 "s_register_operand" "r")
2837                  (neg:SI (match_operator:SI 2 "shift_operator"
2838                           [(match_operand:SI 3 "s_register_operand" "r")
2839                            (match_operand:SI 4 "arm_rhs_operand" "rM")]))))]
2840   ""
2841   "cmn%?\\t%1, %3%S2"
2842 [(set_attr "conds" "set")])
2843
2844 (define_insn ""
2845   [(set (reg:CCFP 24)
2846         (compare:CCFP (match_operand:SF 0 "s_register_operand" "f,f")
2847                       (match_operand:SF 1 "fpu_add_operand" "fG,H")))]
2848   ""
2849   "@
2850    cmf%?\\t%0, %1
2851    cnf%?\\t%0, #%N1"
2852 [(set_attr "conds" "set")
2853  (set_attr "type" "f_2_r")])
2854
2855 (define_insn ""
2856   [(set (reg:CCFP 24)
2857         (compare:CCFP (match_operand:DF 0 "s_register_operand" "f,f")
2858                       (match_operand:DF 1 "fpu_add_operand" "fG,H")))]
2859   ""
2860   "@
2861    cmf%?\\t%0, %1
2862    cnf%?\\t%0, #%N1"
2863 [(set_attr "conds" "set")
2864  (set_attr "type" "f_2_r")])
2865
2866 (define_insn ""
2867   [(set (reg:CCFP 24)
2868         (compare:CCFP (float_extend:DF
2869                        (match_operand:SF 0 "s_register_operand" "f,f"))
2870                       (match_operand:DF 1 "fpu_add_operand" "fG,H")))]
2871   ""
2872   "@
2873    cmf%?\\t%0, %1
2874    cnf%?\\t%0, #%N1"
2875 [(set_attr "conds" "set")
2876  (set_attr "type" "f_2_r")])
2877
2878 (define_insn ""
2879   [(set (reg:CCFP 24)
2880         (compare:CCFP (match_operand:DF 0 "s_register_operand" "f")
2881                       (float_extend:DF
2882                        (match_operand:SF 1 "s_register_operand" "f"))))]
2883   ""
2884   "cmf%?\\t%0, %1"
2885 [(set_attr "conds" "set")
2886  (set_attr "type" "f_2_r")])
2887
2888 (define_insn ""
2889   [(set (reg:CCFP 24)
2890         (compare:CCFP (match_operand:XF 0 "s_register_operand" "f,f")
2891                       (match_operand:XF 1 "fpu_add_operand" "fG,H")))]
2892   "ENABLE_XF_PATTERNS"
2893   "@
2894    cmf%?\\t%0, %1
2895    cnf%?\\t%0, #%N1"
2896 [(set_attr "conds" "set")
2897  (set_attr "type" "f_2_r")])
2898
2899 (define_insn ""
2900   [(set (reg:CCFPE 24)
2901         (compare:CCFPE (match_operand:SF 0 "s_register_operand" "f,f")
2902                        (match_operand:SF 1 "fpu_add_operand" "fG,H")))]
2903   ""
2904   "@
2905    cmf%?e\\t%0, %1
2906    cnf%?e\\t%0, #%N1"
2907 [(set_attr "conds" "set")
2908  (set_attr "type" "f_2_r")])
2909
2910 (define_insn ""
2911   [(set (reg:CCFPE 24)
2912         (compare:CCFPE (match_operand:DF 0 "s_register_operand" "f,f")
2913                        (match_operand:DF 1 "fpu_add_operand" "fG,H")))]
2914   ""
2915   "@
2916    cmf%?e\\t%0, %1
2917    cnf%?e\\t%0, #%N1"
2918 [(set_attr "conds" "set")
2919  (set_attr "type" "f_2_r")])
2920
2921 (define_insn ""
2922   [(set (reg:CCFPE 24)
2923         (compare:CCFPE (float_extend:DF
2924                         (match_operand:SF 0 "s_register_operand" "f,f"))
2925                        (match_operand:DF 1 "fpu_add_operand" "fG,H")))]
2926   ""
2927   "@
2928    cmf%?e\\t%0, %1
2929    cnf%?e\\t%0, #%N1"
2930 [(set_attr "conds" "set")
2931  (set_attr "type" "f_2_r")])
2932
2933 (define_insn ""
2934   [(set (reg:CCFPE 24)
2935         (compare:CCFPE (match_operand:DF 0 "s_register_operand" "f")
2936                        (float_extend:DF
2937                         (match_operand:SF 1 "s_register_operand" "f"))))]
2938   ""
2939   "cmf%?e\\t%0, %1"
2940 [(set_attr "conds" "set")
2941  (set_attr "type" "f_2_r")])
2942
2943 (define_insn ""
2944   [(set (reg:CCFPE 24)
2945         (compare:CCFPE (match_operand:XF 0 "s_register_operand" "f,f")
2946                        (match_operand:XF 1 "fpu_add_operand" "fG,H")))]
2947   "ENABLE_XF_PATTERNS"
2948   "@
2949    cmf%?e\\t%0, %1
2950    cnf%?e\\t%0, #%N1"
2951 [(set_attr "conds" "set")
2952  (set_attr "type" "f_2_r")])
2953
2954 ; This insn allows redundant compares to be removed by cse, nothing should
2955 ; ever appear in the output file since (set (reg x) (reg x)) is a no-op that
2956 ; is deleted later on. The match_dup will match the mode here, so that
2957 ; mode changes of the condition codes aren't lost by this even though we don't
2958 ; specify what they are.
2959
2960 (define_insn ""
2961   [(set (match_operand 0 "cc_register" "") (match_dup 0))]
2962   ""
2963   "\\t%@ deleted compare"
2964 [(set_attr "conds" "set")
2965  (set_attr "length" "0")])
2966
2967 \f
2968 ;; Conditional branch insns
2969
2970 (define_expand "beq"
2971   [(set (pc)
2972         (if_then_else (eq (match_dup 1) (const_int 0))
2973                       (label_ref (match_operand 0 "" ""))
2974                       (pc)))]
2975   ""
2976   "
2977 {
2978   operands[1] = gen_compare_reg (EQ, arm_compare_op0, arm_compare_op1,
2979                                  arm_compare_fp);
2980 }
2981 ")
2982
2983 (define_expand "bne"
2984   [(set (pc)
2985         (if_then_else (ne (match_dup 1) (const_int 0))
2986                       (label_ref (match_operand 0 "" ""))
2987                       (pc)))]
2988   ""
2989   "
2990 {
2991   operands[1] = gen_compare_reg (NE, arm_compare_op0, arm_compare_op1,
2992                                  arm_compare_fp);
2993 }
2994 ")
2995
2996 (define_expand "bgt"
2997   [(set (pc)
2998         (if_then_else (gt (match_dup 1) (const_int 0))
2999                       (label_ref (match_operand 0 "" ""))
3000                       (pc)))]
3001   ""
3002   "
3003 {
3004   operands[1] = gen_compare_reg (GT, arm_compare_op0, arm_compare_op1,
3005                                  arm_compare_fp);
3006 }
3007 ")
3008
3009 (define_expand "ble"
3010   [(set (pc)
3011         (if_then_else (le (match_dup 1) (const_int 0))
3012                       (label_ref (match_operand 0 "" ""))
3013                       (pc)))]
3014   ""
3015   "
3016 {
3017   operands[1] = gen_compare_reg (LE, arm_compare_op0, arm_compare_op1,
3018                                  arm_compare_fp);
3019 }
3020 ")
3021
3022 (define_expand "bge"
3023   [(set (pc)
3024         (if_then_else (ge (match_dup 1) (const_int 0))
3025                       (label_ref (match_operand 0 "" ""))
3026                       (pc)))]
3027   ""
3028   "
3029 {
3030   operands[1] = gen_compare_reg (GE, arm_compare_op0, arm_compare_op1,
3031                                  arm_compare_fp);
3032 }
3033 ")
3034
3035 (define_expand "blt"
3036   [(set (pc)
3037         (if_then_else (lt (match_dup 1) (const_int 0))
3038                       (label_ref (match_operand 0 "" ""))
3039                       (pc)))]
3040   ""
3041   "
3042 {
3043   operands[1] = gen_compare_reg (LT, arm_compare_op0, arm_compare_op1,
3044                                  arm_compare_fp);
3045 }
3046 ")
3047
3048 (define_expand "bgtu"
3049   [(set (pc)
3050         (if_then_else (gtu (match_dup 1) (const_int 0))
3051                       (label_ref (match_operand 0 "" ""))
3052                       (pc)))]
3053   ""
3054   "
3055 {
3056   operands[1] = gen_compare_reg (GTU, arm_compare_op0, arm_compare_op1,
3057                                  arm_compare_fp);
3058 }
3059 ")
3060
3061 (define_expand "bleu"
3062   [(set (pc)
3063         (if_then_else (leu (match_dup 1) (const_int 0))
3064                       (label_ref (match_operand 0 "" ""))
3065                       (pc)))]
3066   ""
3067   "
3068 {
3069   operands[1] = gen_compare_reg (LEU, arm_compare_op0, arm_compare_op1,
3070                                  arm_compare_fp);
3071 }
3072 ")
3073
3074 (define_expand "bgeu"
3075   [(set (pc)
3076         (if_then_else (geu (match_dup 1) (const_int 0))
3077                       (label_ref (match_operand 0 "" ""))
3078                       (pc)))]
3079   ""
3080   "
3081 {
3082   operands[1] = gen_compare_reg (GEU, arm_compare_op0, arm_compare_op1,
3083                                  arm_compare_fp);
3084 }
3085 ")
3086
3087 (define_expand "bltu"
3088   [(set (pc)
3089         (if_then_else (ltu (match_dup 1) (const_int 0))
3090                       (label_ref (match_operand 0 "" ""))
3091                       (pc)))]
3092   ""
3093   "
3094 {
3095   operands[1] = gen_compare_reg (LTU, arm_compare_op0, arm_compare_op1,
3096                                  arm_compare_fp);
3097 }
3098 ")
3099
3100 ;; patterns to match conditional branch insns
3101
3102 (define_insn ""
3103   [(set (pc)
3104         (if_then_else (match_operator 1 "comparison_operator"
3105                                         [(reg 24) (const_int 0)])
3106                       (label_ref (match_operand 0 "" ""))
3107                       (pc)))]
3108   ""
3109   "*
3110 {
3111   extern int arm_ccfsm_state;
3112
3113   if (arm_ccfsm_state == 1 || arm_ccfsm_state == 2)
3114   {
3115     arm_ccfsm_state += 2;
3116     return \"\";
3117   }
3118   return \"b%d1\\t%l0\";
3119 }"
3120 [(set_attr "conds" "use")])
3121
3122 (define_insn ""
3123   [(set (pc)
3124         (if_then_else (match_operator 1 "comparison_operator"
3125                                         [(reg 24) (const_int 0)])
3126                       (pc)
3127                       (label_ref (match_operand 0 "" ""))))]
3128   "REVERSIBLE_CC_MODE (GET_MODE (XEXP (operands[1], 0)))"
3129   "*
3130 {
3131   extern int arm_ccfsm_state;
3132
3133   if (arm_ccfsm_state == 1 || arm_ccfsm_state == 2)
3134   {
3135     arm_ccfsm_state += 2;
3136     return \"\";
3137   }
3138   return \"b%D1\\t%l0\";
3139 }"
3140 [(set_attr "conds" "use")])
3141 \f
3142
3143 ; scc insns
3144
3145 (define_expand "seq"
3146   [(set (match_operand:SI 0 "s_register_operand" "=r")
3147         (eq:SI (match_dup 1) (const_int 0)))]
3148   ""
3149   "
3150 {
3151   operands[1] = gen_compare_reg (EQ, arm_compare_op0, arm_compare_op1,
3152                                  arm_compare_fp);
3153 }
3154 ")
3155
3156 (define_expand "sne"
3157   [(set (match_operand:SI 0 "s_register_operand" "=r")
3158         (ne:SI (match_dup 1) (const_int 0)))]
3159   ""
3160   "
3161 {
3162   operands[1] = gen_compare_reg (NE, arm_compare_op0, arm_compare_op1,
3163                                  arm_compare_fp);
3164 }
3165 ")
3166
3167 (define_expand "sgt"
3168   [(set (match_operand:SI 0 "s_register_operand" "=r")
3169         (gt:SI (match_dup 1) (const_int 0)))]
3170   ""
3171   "
3172 {
3173   operands[1] = gen_compare_reg (GT, arm_compare_op0, arm_compare_op1,
3174                                  arm_compare_fp);
3175 }
3176 ")
3177
3178 (define_expand "sle"
3179   [(set (match_operand:SI 0 "s_register_operand" "=r")
3180         (le:SI (match_dup 1) (const_int 0)))]
3181   ""
3182   "
3183 {
3184   operands[1] = gen_compare_reg (LE, arm_compare_op0, arm_compare_op1,
3185                                  arm_compare_fp);
3186 }
3187 ")
3188
3189 (define_expand "sge"
3190   [(set (match_operand:SI 0 "s_register_operand" "=r")
3191         (ge:SI (match_dup 1) (const_int 0)))]
3192   ""
3193   "
3194 {
3195   operands[1] = gen_compare_reg (GE, arm_compare_op0, arm_compare_op1,
3196                                  arm_compare_fp);
3197 }
3198 ")
3199
3200 (define_expand "slt"
3201   [(set (match_operand:SI 0 "s_register_operand" "=r")
3202         (lt:SI (match_dup 1) (const_int 0)))]
3203   ""
3204   "
3205 {
3206   operands[1] = gen_compare_reg (LT, arm_compare_op0, arm_compare_op1,
3207                                  arm_compare_fp);
3208 }
3209 ")
3210
3211 (define_expand "sgtu"
3212   [(set (match_operand:SI 0 "s_register_operand" "=r")
3213         (gtu:SI (match_dup 1) (const_int 0)))]
3214   ""
3215   "
3216 {
3217   operands[1] = gen_compare_reg (GTU, arm_compare_op0, arm_compare_op1,
3218                                  arm_compare_fp);
3219 }
3220 ")
3221
3222 (define_expand "sleu"
3223   [(set (match_operand:SI 0 "s_register_operand" "=r")
3224         (leu:SI (match_dup 1) (const_int 0)))]
3225   ""
3226   "
3227 {
3228   operands[1] = gen_compare_reg (LEU, arm_compare_op0, arm_compare_op1,
3229                                  arm_compare_fp);
3230 }
3231 ")
3232
3233 (define_expand "sgeu"
3234   [(set (match_operand:SI 0 "s_register_operand" "=r")
3235         (geu:SI (match_dup 1) (const_int 0)))]
3236   ""
3237   "
3238 {
3239   operands[1] = gen_compare_reg (GEU, arm_compare_op0, arm_compare_op1,
3240                                  arm_compare_fp);
3241 }
3242 ")
3243
3244 (define_expand "sltu"
3245   [(set (match_operand:SI 0 "s_register_operand" "=r")
3246         (ltu:SI (match_dup 1) (const_int 0)))]
3247   ""
3248   "
3249 {
3250   operands[1] = gen_compare_reg (LTU, arm_compare_op0, arm_compare_op1,
3251                                  arm_compare_fp);
3252 }
3253 ")
3254
3255 (define_insn ""
3256   [(set (match_operand:SI 0 "s_register_operand" "=r")
3257         (match_operator:SI 1 "comparison_operator" [(reg 24) (const_int 0)]))]
3258   ""
3259   "mov%D1\\t%0, #0\;mov%d1\\t%0, #1"
3260 [(set_attr "conds" "use")
3261  (set_attr "length" "8")])
3262
3263 (define_insn ""
3264   [(set (match_operand:SI 0 "s_register_operand" "=r")
3265         (neg:SI (match_operator:SI 1 "comparison_operator"
3266                  [(reg 24) (const_int 0)])))]
3267   ""
3268   "mov%D1\\t%0, #0\;mvn%d1\\t%0, #0"
3269 [(set_attr "conds" "use")
3270  (set_attr "length" "8")])
3271
3272 (define_insn ""
3273   [(set (match_operand:SI 0 "s_register_operand" "=r")
3274         (not:SI (match_operator:SI 1 "comparison_operator"
3275                  [(reg 24) (const_int 0)])))]
3276   ""
3277   "mov%D1\\t%0, #0\;mvn%d1\\t%0, #1"
3278 [(set_attr "conds" "use")
3279  (set_attr "length" "8")])
3280
3281 \f
3282 ;; Jump and linkage insns
3283
3284 (define_insn "jump"
3285   [(set (pc)
3286         (label_ref (match_operand 0 "" "")))]
3287   ""
3288   "*
3289 {
3290   extern int arm_ccfsm_state;
3291
3292   if (arm_ccfsm_state == 1 || arm_ccfsm_state == 2)
3293   {
3294     arm_ccfsm_state += 2;
3295     return \"\";
3296   }
3297   return \"b%?\\t%l0\";
3298 }")
3299
3300 (define_expand "call"
3301   [(parallel [(call (match_operand 0 "memory_operand" "")
3302                     (match_operand 1 "general_operand" ""))
3303               (clobber (reg:SI 14))])]
3304   ""
3305   "")
3306
3307 (define_insn ""
3308   [(call (mem:SI (match_operand:SI 0 "s_register_operand" "r"))
3309          (match_operand 1 "" "g"))
3310    (clobber (reg:SI 14))]
3311   ""
3312   "*
3313   return output_call (operands);
3314 "
3315 [(set (attr "conds")
3316       (if_then_else (eq_attr "cpu" "arm6")
3317                     (const_string "clob")
3318                     (const_string "nocond")))
3319 ;; length is worst case, normally it is only two
3320  (set_attr "length" "12")
3321  (set_attr "type" "call")])
3322
3323 (define_insn ""
3324   [(call (mem:SI (match_operand 0 "memory_operand" "m"))
3325          (match_operand 1 "general_operand" "g"))
3326    (clobber (reg:SI 14))]
3327   ""
3328   "*
3329   return output_call_mem (operands);
3330 "
3331 [(set (attr "conds")
3332       (if_then_else (eq_attr "cpu" "arm6")
3333                     (const_string "clob")
3334                     (const_string "nocond")))
3335  (set_attr "length" "12")
3336  (set_attr "type" "call")])
3337
3338 (define_expand "call_value"
3339   [(parallel [(set (match_operand 0 "" "=rf")
3340                    (call (match_operand 1 "memory_operand" "m")
3341                          (match_operand 2 "general_operand" "g")))
3342               (clobber (reg:SI 14))])]
3343   ""
3344   "")
3345
3346 (define_insn ""
3347   [(set (match_operand 0 "" "=rf")
3348         (call (mem:SI (match_operand:SI 1 "s_register_operand" "r"))
3349               (match_operand 2 "general_operand" "g")))
3350    (clobber (reg:SI 14))]
3351   ""
3352   "*
3353   return output_call (&operands[1]);
3354 "
3355 [(set (attr "conds")
3356       (if_then_else (eq_attr "cpu" "arm6")
3357                     (const_string "clob")
3358                     (const_string "nocond")))
3359  (set_attr "length" "12")
3360  (set_attr "type" "call")])
3361
3362 (define_insn ""
3363   [(set (match_operand 0 "" "=rf")
3364         (call (mem:SI (match_operand 1 "memory_operand" "m"))
3365         (match_operand 2 "general_operand" "g")))
3366    (clobber (reg:SI 14))]
3367   "! CONSTANT_ADDRESS_P (XEXP (operands[1], 0))"
3368   "*
3369   return output_call_mem (&operands[1]);
3370 "
3371 [(set (attr "conds")
3372       (if_then_else (eq_attr "cpu" "arm6")
3373                     (const_string "clob")
3374                     (const_string "nocond")))
3375  (set_attr "length" "12")
3376  (set_attr "type" "call")])
3377
3378 ;; Allow calls to SYMBOL_REFs specially as they are not valid general addresses
3379 ;; The 'a' causes the operand to be treated as an address, i.e. no '#' output.
3380
3381 (define_insn ""
3382   [(call (mem:SI (match_operand:SI 0 "" "i"))
3383          (match_operand:SI 1 "general_operand" "g"))
3384    (clobber (reg:SI 14))]
3385   "GET_CODE (operands[0]) == SYMBOL_REF"
3386   "bl%?\\t%a0"
3387 [(set (attr "conds")
3388       (if_then_else (eq_attr "cpu" "arm6")
3389                     (const_string "clob")
3390                     (const_string "nocond")))
3391  (set_attr "type" "call")])
3392
3393 (define_insn ""
3394   [(set (match_operand 0 "s_register_operand" "=rf")
3395         (call (mem:SI (match_operand:SI 1 "" "i"))
3396         (match_operand:SI 2 "general_operand" "g")))
3397    (clobber (reg:SI 14))]
3398   "GET_CODE(operands[1]) == SYMBOL_REF"
3399   "bl%?\\t%a1"
3400 [(set (attr "conds")
3401       (if_then_else (eq_attr "cpu" "arm6")
3402                     (const_string "clob")
3403                     (const_string "nocond")))
3404  (set_attr "type" "call")])
3405
3406 ;; Often the return insn will be the same as loading from memory, so set attr
3407 (define_insn "return"
3408   [(return)]
3409   "USE_RETURN_INSN"
3410   "*
3411 {
3412   extern int arm_ccfsm_state;
3413
3414   if (arm_ccfsm_state == 2)
3415   {
3416     arm_ccfsm_state += 2;
3417     return \"\";
3418   }
3419   return output_return_instruction (NULL, TRUE);
3420 }"
3421 [(set_attr "type" "load")])
3422
3423 (define_insn ""
3424   [(set (pc)
3425         (if_then_else (match_operator 0 "comparison_operator"
3426                        [(reg 24) (const_int 0)])
3427                       (return)
3428                       (pc)))]
3429   "USE_RETURN_INSN"
3430   "*
3431 {
3432   extern int arm_ccfsm_state;
3433
3434   if (arm_ccfsm_state == 2)
3435   {
3436     arm_ccfsm_state += 2;
3437     return \"\";
3438   }
3439   return output_return_instruction (operands[0], TRUE);
3440 }"
3441 [(set_attr "conds" "use")
3442  (set_attr "type" "load")])
3443
3444 (define_insn ""
3445   [(set (pc)
3446         (if_then_else (match_operator 0 "comparison_operator"
3447                        [(reg 24) (const_int 0)])
3448                       (pc)
3449                       (return)))]
3450   "USE_RETURN_INSN"
3451   "*
3452 {
3453   extern int arm_ccfsm_state;
3454
3455   if (arm_ccfsm_state == 2)
3456   {
3457     arm_ccfsm_state += 2;
3458     return \"\";
3459   }
3460   return output_return_instruction
3461         (gen_rtx (reverse_condition (GET_CODE (operands[0])),
3462                   GET_MODE (operands[0]), XEXP (operands[0], 0),
3463                   XEXP (operands[0], 1)),
3464          TRUE);
3465 }"
3466 [(set_attr "conds" "use")
3467  (set_attr "type" "load")])
3468
3469 ;; Call subroutine returning any type.
3470
3471 (define_expand "untyped_call"
3472   [(parallel [(call (match_operand 0 "" "")
3473                     (const_int 0))
3474               (match_operand 1 "" "")
3475               (match_operand 2 "" "")])]
3476   ""
3477   "
3478 {
3479   int i;
3480
3481   emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx));
3482
3483   for (i = 0; i < XVECLEN (operands[2], 0); i++)
3484     {
3485       rtx set = XVECEXP (operands[2], 0, i);
3486       emit_move_insn (SET_DEST (set), SET_SRC (set));
3487     }
3488
3489   /* The optimizer does not know that the call sets the function value
3490      registers we stored in the result block.  We avoid problems by
3491      claiming that all hard registers are used and clobbered at this
3492      point.  */
3493   emit_insn (gen_blockage ());
3494
3495   DONE;
3496 }")
3497
3498 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
3499 ;; all of memory.  This blocks insns from being moved across this point.
3500
3501 (define_insn "blockage"
3502   [(unspec_volatile [(const_int 0)] 0)]
3503   ""
3504   ""
3505 [(set_attr "length" "0")
3506  (set_attr "type" "block")])
3507
3508 (define_insn "tablejump"
3509   [(set (pc)
3510         (match_operand:SI 0 "s_register_operand" "r"))
3511    (use (label_ref (match_operand 1 "" "")))]
3512   ""
3513   "mov%?\\t%|pc, %0\\t%@ table jump, label %l1")
3514
3515 (define_insn ""
3516   [(set (pc)
3517         (match_operand:SI 0 "memory_operand" "m"))
3518    (use (label_ref (match_operand 1 "" "")))]
3519   ""
3520   "ldr%?\\t%|pc, %0\\t%@ table jump, label %l1"
3521 [(set_attr "type" "load")])
3522
3523 (define_insn "indirect_jump"
3524   [(set (pc)
3525         (match_operand:SI 0 "s_register_operand" "r"))]
3526   ""
3527   "mov%?\\t%|pc, %0\\t%@ indirect jump")
3528
3529 (define_insn ""
3530   [(set (pc)
3531         (match_operand:SI 0 "memory_operand" "m"))]
3532   ""
3533   "ldr%?\\t%|pc, %0\\t%@ indirect jump"
3534 [(set_attr "type" "load")])
3535 \f
3536 ;; Misc insns
3537
3538 (define_insn "nop"
3539   [(const_int 0)]
3540   ""
3541   "mov%?\\tr0, r0\\t%@ nop")
3542 \f
3543 ;; Patterns to allow combination of arithmetic, cond code and shifts
3544
3545 (define_insn ""
3546   [(set (match_operand:SI 0 "s_register_operand" "=r")
3547         (match_operator:SI 1 "shiftable_operator"
3548           [(match_operator:SI 3 "shift_operator"
3549              [(match_operand:SI 4 "s_register_operand" "r")
3550               (match_operand:SI 5 "reg_or_int_operand" "rI")])
3551            (match_operand:SI 2 "s_register_operand" "r")]))]
3552   ""
3553   "%i1%?\\t%0, %2, %4%S3")
3554
3555 (define_insn ""
3556   [(set (reg:CC_NOOV 24)
3557         (compare:CC_NOOV (match_operator:SI 1 "shiftable_operator"
3558                           [(match_operator:SI 3 "shift_operator"
3559                             [(match_operand:SI 4 "s_register_operand" "r")
3560                              (match_operand:SI 5 "reg_or_int_operand" "rI")])
3561                            (match_operand:SI 2 "s_register_operand" "r")])
3562                          (const_int 0)))
3563    (set (match_operand:SI 0 "s_register_operand" "=r")
3564         (match_op_dup 1 [(match_op_dup 3 [(match_dup 4) (match_dup 5)])
3565                          (match_dup 2)]))]
3566   ""
3567   "%i1%?s\\t%0, %2, %4%S3"
3568 [(set_attr "conds" "set")])
3569
3570 (define_insn ""
3571   [(set (reg:CC_NOOV 24)
3572         (compare:CC_NOOV (match_operator:SI 1 "shiftable_operator"
3573                           [(match_operator:SI 3 "shift_operator"
3574                             [(match_operand:SI 4 "s_register_operand" "r")
3575                              (match_operand:SI 5 "reg_or_int_operand" "rI")])
3576                            (match_operand:SI 2 "s_register_operand" "r")])
3577                          (const_int 0)))
3578    (clobber (match_scratch:SI 0 "=r"))]
3579   ""
3580   "%i1%?s\\t%0, %2, %4%S3"
3581 [(set_attr "conds" "set")])
3582
3583 (define_insn ""
3584   [(set (match_operand:SI 0 "s_register_operand" "=r")
3585         (minus:SI (match_operand:SI 1 "s_register_operand" "r")
3586                   (match_operator:SI 2 "shift_operator"
3587                    [(match_operand:SI 3 "s_register_operand" "r")
3588                     (match_operand:SI 4 "reg_or_int_operand" "rM")])))]
3589   ""
3590   "sub%?\\t%0, %1, %3%S2")
3591
3592 (define_insn ""
3593   [(set (reg:CC_NOOV 24)
3594         (compare:CC_NOOV
3595          (minus:SI (match_operand:SI 1 "s_register_operand" "r")
3596                    (match_operator:SI 2 "shift_operator"
3597                     [(match_operand:SI 3 "s_register_operand" "r")
3598                      (match_operand:SI 4 "reg_or_int_operand" "rM")]))
3599          (const_int 0)))
3600    (set (match_operand:SI 0 "s_register_operand" "=r")
3601         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
3602                                                  (match_dup 4)])))]
3603   ""
3604   "sub%?s\\t%0, %1, %3%S2"
3605 [(set_attr "conds" "set")])
3606
3607 (define_insn ""
3608   [(set (reg:CC_NOOV 24)
3609         (compare:CC_NOOV
3610          (minus:SI (match_operand:SI 1 "s_register_operand" "r")
3611                    (match_operator:SI 2 "shift_operator"
3612                     [(match_operand:SI 3 "s_register_operand" "r")
3613                      (match_operand:SI 4 "reg_or_int_operand" "rM")]))
3614          (const_int 0)))
3615    (clobber (match_scratch:SI 0 "=r"))]
3616   ""
3617   "sub%?s\\t%0, %1, %3%S2"
3618 [(set_attr "conds" "set")])
3619
3620 ;; These variants of the above insns can occur if the first operand is the
3621 ;; frame pointer and we eliminate that.  This is a kludge, but there doesn't
3622 ;; seem to be a way around it.  Most of the predicates have to be null
3623 ;; because the format can be generated part way through reload, so
3624 ;; if we don't match it as soon as it becomes available, reload doesn't know
3625 ;; how to reload pseudos that haven't got hard registers; the constraints will
3626 ;; sort everything out.
3627
3628 (define_insn ""
3629   [(set (match_operand:SI 0 "" "=&r")
3630         (plus:SI (plus:SI (match_operator:SI 5 "shift_operator"
3631                            [(match_operand:SI 3 "" "r")
3632                             (match_operand:SI 4 "" "rM")])
3633                           (match_operand:SI 2 "" "r"))
3634                  (match_operand:SI 1 "const_int_operand" "n")))]
3635   "reload_in_progress"
3636   "*
3637   output_asm_insn (\"add%?\\t%0, %2, %3%S5\", operands);
3638   operands[2] = operands[1];
3639   operands[1] = operands[0];
3640   return output_add_immediate (operands);
3641 "
3642 ; we have no idea how long the add_immediate is, it could be up to 4.
3643 [(set_attr "length" "20")])
3644
3645 (define_insn ""
3646   [(set (reg:CC_NOOV 24)
3647         (compare:CC_NOOV (plus:SI
3648                           (plus:SI
3649                            (match_operator:SI 5 "shift_operator"
3650                             [(match_operand:SI 3 "" "r")
3651                              (match_operand:SI 4 "" "rM")])
3652                            (match_operand:SI 1 "" "r"))
3653                           (match_operand:SI 2 "const_int_operand" "n"))
3654                          (const_int 0)))
3655    (set (match_operand:SI 0 "" "=&r")
3656         (plus:SI (plus:SI (match_op_dup 5 [(match_dup 3) (match_dup 4)])
3657                           (match_dup 1))
3658                  (match_dup 2)))]
3659   "reload_in_progress"
3660   "*
3661   output_add_immediate (operands);
3662   return \"add%?s\\t%0, %0, %3%S5\";
3663 "
3664 [(set_attr "conds" "set")
3665  (set_attr "length" "20")])
3666
3667 (define_insn ""
3668   [(set (reg:CC_NOOV 24)
3669         (compare:CC_NOOV (plus:SI
3670                           (plus:SI
3671                            (match_operator:SI 5 "shift_operator"
3672                             [(match_operand:SI 3 "" "r")
3673                              (match_operand:SI 4 "" "rM")])
3674                            (match_operand:SI 1 "" "r"))
3675                           (match_operand:SI 2 "const_int_operand" "n"))
3676                          (const_int 0)))
3677    (clobber (match_scratch:SI 0 "=&r"))]
3678   "reload_in_progress"
3679   "*
3680   output_add_immediate (operands);
3681   return \"add%?s\\t%0, %0, %3%S5\";
3682 "
3683 [(set_attr "conds" "set")
3684  (set_attr "length" "20")])
3685
3686 ;; These are similar, but are needed when the mla pattern contains the
3687 ;; eliminated register as operand 3.
3688
3689 (define_insn ""
3690   [(set (match_operand:SI 0 "" "=&r,&r")
3691         (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "" "%0,r")
3692                                    (match_operand:SI 2 "" "r,r"))
3693                           (match_operand:SI 3 "" "r,r"))
3694                  (match_operand:SI 4 "const_int_operand" "n,n")))]
3695   "reload_in_progress"
3696   "*
3697   output_asm_insn (\"mla%?\\t%0, %2, %1, %3\", operands);
3698   operands[2] = operands[4];
3699   operands[1] = operands[0];
3700   return output_add_immediate (operands);
3701 "
3702 [(set_attr "length" "20")])
3703
3704 (define_insn ""
3705   [(set (reg:CC_NOOV 24)
3706         (compare:CC_NOOV (plus:SI (plus:SI (mult:SI
3707                                             (match_operand:SI 3 "" "r")
3708                                             (match_operand:SI 4 "" "r"))
3709                                            (match_operand:SI 1 "" "r"))
3710                                   (match_operand:SI 2 "const_int_operand" "n"))
3711                          (const_int 0)))
3712    (set (match_operand:SI 0 "" "=&r")
3713         (plus:SI (plus:SI (mult:SI (match_dup 3) (match_dup 4)) (match_dup 1))
3714                  (match_dup 2)))]
3715   "reload_in_progress"
3716   "*
3717   output_add_immediate (operands);
3718   output_asm_insn (\"mla%?s\\t%0, %3, %4, %0\", operands);
3719   return \"\";
3720 "
3721 [(set_attr "length" "20")
3722  (set_attr "conds" "set")])
3723
3724 (define_insn ""
3725   [(set (reg:CC_NOOV 24)
3726         (compare:CC_NOOV (plus:SI (plus:SI (mult:SI
3727                                             (match_operand:SI 3 "" "r")
3728                                             (match_operand:SI 4 "" "r"))
3729                                            (match_operand:SI 1 "" "r"))
3730                                   (match_operand:SI 2 "const_int_operand" "n"))
3731                          (const_int 0)))
3732    (clobber (match_scratch:SI 0 "=&r"))]
3733   "reload_in_progress"
3734   "*
3735   output_add_immediate (operands);
3736   return \"mla%?s\\t%0, %3, %4, %0\";
3737 "
3738 [(set_attr "length" "20")
3739  (set_attr "conds" "set")])
3740
3741
3742 \f
3743
3744 (define_insn ""
3745   [(set (match_operand:SI 0 "s_register_operand" "=r")
3746         (and:SI (match_operator 1 "comparison_operator"
3747                  [(match_operand 3 "reversible_cc_register" "") (const_int 0)])
3748                 (match_operand:SI 2 "s_register_operand" "r")))]
3749   ""
3750   "mov%D1\\t%0, #0\;and%d1\\t%0, %2, #1"
3751 [(set_attr "conds" "use")
3752  (set_attr "length" "8")])
3753
3754 (define_insn ""
3755   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
3756         (ior:SI (match_operator 2 "comparison_operator"
3757                  [(reg 24) (const_int 0)])
3758                 (match_operand:SI 1 "s_register_operand" "0,?r")))]
3759   ""
3760   "@
3761    orr%d2\\t%0, %1, #1
3762    mov%D2\\t%0, %1\;orr%d2\\t%0, %1, #1"
3763 [(set_attr "conds" "use")
3764  (set_attr "length" "4,8")])
3765
3766 (define_insn ""
3767   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
3768         (match_operator 1 "comparison_operator"
3769          [(match_operand:SI 2 "s_register_operand" "r,r")
3770           (match_operand:SI 3 "arm_add_operand" "rI,L")]))
3771    (clobber (reg 24))]
3772   ""
3773   "*
3774   if (GET_CODE (operands[1]) == LT && operands[3] == const0_rtx)
3775     return \"mov\\t%0, %2, lsr #31\";
3776
3777   if (GET_CODE (operands[1]) == GE && operands[3] == const0_rtx)
3778     return \"mvn\\t%0, %2\;mov\\t%0, %0, lsr #31\";
3779
3780   if (GET_CODE (operands[1]) == NE)
3781     {
3782       if (which_alternative == 1)
3783         return \"adds\\t%0, %2, #%n3\;movne\\t%0, #1\";
3784       return \"subs\\t%0, %2, %3\;movne\\t%0, #1\";
3785     }
3786   if (which_alternative == 1)
3787     output_asm_insn (\"cmn\\t%2, #%n3\", operands);
3788   else
3789     output_asm_insn (\"cmp\\t%2, %3\", operands);
3790   return \"mov%D1\\t%0, #0\;mov%d1\\t%0, #1\";
3791 "
3792 [(set_attr "conds" "clob")
3793  (set_attr "length" "12")])
3794
3795 (define_insn ""
3796   [(set (match_operand:SI 0 "s_register_operand" "=&r")
3797         (ior:SI (match_operator 1 "comparison_operator"
3798                  [(match_operand:SI 2 "s_register_operand" "r")
3799                   (match_operand:SI 3 "arm_rhs_operand" "rI")])
3800                 (match_operator 4 "comparison_operator"
3801                  [(match_operand:SI 5 "s_register_operand" "r")
3802                   (match_operand:SI 6 "arm_rhs_operand" "rI")])))
3803    (clobber (reg 24))]
3804   ""
3805   "*
3806 {
3807   int dominant = comparison_dominates_p (GET_CODE (operands[4]),
3808                                          GET_CODE (operands[1]));
3809
3810   output_asm_insn (dominant ? \"cmp\\t%5, %6\" : \"cmp\\t%2, %3\",
3811                    operands);
3812   output_asm_insn (\"mov\\t%0, #0\", operands);
3813   if (GET_CODE (operands[1]) == GET_CODE (operands[4])
3814       || comparison_dominates_p (GET_CODE (operands[1]),
3815                                  GET_CODE (operands[4]))
3816       || dominant)
3817     output_asm_insn (dominant ? \"cmp%D4\\t%2, %3\" : \"cmp%D1\\t%5,%6\",
3818                      operands);
3819   else
3820     output_asm_insn (\"mov%d1\\t%0, #1\;cmp\\t%5, %6\", operands);
3821   return dominant ? \"mov%d1\\t%0, #1\" : \"mov%d4\\t%0, #1\";
3822 }
3823 "
3824 [(set_attr "conds" "clob")
3825 ; worst case length
3826  (set_attr "length" "20")])
3827
3828 (define_split
3829   [(set (pc)
3830         (if_then_else
3831          (match_operator 5 "equality_operator"
3832           [(ior:SI (match_operator 6 "comparison_operator"
3833                     [(match_operand:SI 0 "s_register_operand" "")
3834                      (match_operand:SI 1 "arm_add_operand" "")])
3835                    (match_operator 7 "comparison_operator"
3836                     [(match_operand:SI 2 "s_register_operand" "")
3837                      (match_operand:SI 3 "arm_add_operand" "")]))
3838           (const_int 0)])
3839          (label_ref (match_operand 4 "" ""))
3840          (pc)))
3841    (clobber (reg 24))]
3842   "(GET_CODE (operands[6]) == GET_CODE (operands[7])
3843     || comparison_dominates_p (GET_CODE (operands[6]), GET_CODE (operands[7]))
3844     || comparison_dominates_p (GET_CODE (operands[7]), GET_CODE (operands[6])))"
3845   [(set (reg:CC 24)
3846         (compare:CC (ior:CC (match_op_dup 6
3847                              [(match_dup 0) (match_dup 1)])
3848                             (match_op_dup 7
3849                              [(match_dup 2) (match_dup 3)]))
3850                     (const_int 0)))
3851    (set (pc)
3852         (if_then_else (match_op_dup 5 [(reg:CC 24) (const_int 0)])
3853                       (label_ref (match_dup 4))
3854                       (pc)))]
3855   "
3856 {
3857   enum rtx_code code = comparison_dominates_p (GET_CODE (operands[6]),
3858                                                GET_CODE (operands[7]))
3859                        ? GET_CODE (operands[7]) : GET_CODE (operands[6]);
3860
3861   if (GET_CODE (operands[5]) == NE)
3862     operands[5] = gen_rtx (code, CCmode,
3863                            XEXP (operands[5], 0), XEXP (operands[5], 1));
3864   else
3865     operands[5] = gen_rtx (reverse_condition (code), CCmode,
3866                            XEXP (operands[5], 0), XEXP (operands[5], 1));
3867 }
3868 ")
3869
3870 ;; Don't match these patterns if we can use a conditional compare, since they
3871 ;; tell the final prescan branch elimator code that full branch inlining
3872 ;; can't be done.
3873
3874 (define_insn ""
3875   [(set (pc)
3876         (if_then_else
3877          (ne (ior:SI (match_operator 5 "comparison_operator"
3878                       [(match_operand:SI 0 "s_register_operand" "r,r,r,r")
3879                        (match_operand:SI 1 "arm_add_operand" "rI,L,rI,L")])
3880                      (match_operator 6 "comparison_operator"
3881                       [(match_operand:SI 2 "s_register_operand" "r,r,r,r")
3882                        (match_operand:SI 3 "arm_rhs_operand" "rI,rI,L,L")]))
3883              (const_int 0))
3884          (label_ref (match_operand 4 "" ""))
3885          (pc)))
3886    (clobber (reg 24))]
3887   "!(GET_CODE (operands[5]) == GET_CODE (operands[6])
3888      || comparison_dominates_p (GET_CODE (operands[5]), GET_CODE (operands[6]))
3889      || comparison_dominates_p (GET_CODE (operands[6]), GET_CODE (operands[5])))"
3890   "*
3891 {
3892   extern int arm_ccfsm_state;
3893
3894   if (which_alternative & 1)
3895     output_asm_insn (\"cmn\\t%0, #%n1\;b%d5\\t%l4\", operands);
3896   else
3897     output_asm_insn (\"cmp\\t%0, %1\;b%d5\\t%l4\", operands);
3898
3899   if (which_alternative >= 2)
3900     output_asm_insn (\"cmn\\t%2, #%n3\", operands);
3901   else
3902     output_asm_insn (\"cmp\\t%2, %3\", operands);
3903
3904   if (arm_ccfsm_state == 1 || arm_ccfsm_state == 2)
3905   {
3906     arm_ccfsm_state += 2;
3907     return \"\";
3908   }
3909   return \"b%d6\\t%l4\";
3910 }"
3911 [(set_attr "conds" "jump_clob")
3912  (set_attr "length" "16")])
3913
3914 (define_insn ""
3915   [(set (reg:CC 24)
3916         (compare:CC
3917          (ior:CC (match_operator 4 "comparison_operator"
3918                   [(match_operand:SI 0 "s_register_operand" "r,r,r,r")
3919                    (match_operand:SI 1 "arm_add_operand" "rI,L,rI,L")])
3920                  (match_operator 5 "comparison_operator"
3921                   [(match_operand:SI 2 "s_register_operand" "r,r,r,r")
3922                    (match_operand:SI 3 "arm_add_operand" "rI,rI,L,L")]))
3923          (const_int 0)))]
3924   "(GET_CODE (operands[4]) == GET_CODE (operands[5])
3925     || comparison_dominates_p (GET_CODE (operands[4]), GET_CODE (operands[5]))
3926     || comparison_dominates_p (GET_CODE (operands[5]), GET_CODE (operands[4])))"
3927   "*
3928   if (comparison_dominates_p (GET_CODE (operands[5]), GET_CODE (operands[4])))
3929     {
3930       if (which_alternative >= 2)
3931         output_asm_insn (\"cmn\\t%2, #%n3\", operands);
3932       else
3933         output_asm_insn (\"cmp\\t%2, %3\", operands);
3934
3935       if (which_alternative & 1)
3936         return \"cmn%D5\\t%0, #%n1\";
3937       return \"cmp%D5\\t%0, %1\";
3938     }
3939
3940   if (which_alternative & 1)
3941     output_asm_insn (\"cmn\\t%0, #%n1\", operands);
3942   else
3943     output_asm_insn (\"cmp\\t%0, %1\", operands);
3944
3945   if (which_alternative >= 2)
3946     return \"cmn%D4\\t%2, #%n3\";
3947   return \"cmp%D4\\t%2, %3\";
3948 "
3949 [(set_attr "conds" "set")
3950  (set_attr "length" "8")])
3951
3952 (define_insn ""
3953   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
3954         (if_then_else (match_operator 3 "equality_operator"
3955                        [(match_operator 4 "comparison_operator"
3956                          [(reg 24) (const_int 0)])
3957                         (const_int 0)])
3958                       (match_operand:SI 1 "arm_rhs_operand" "0,rI,?rI")
3959                       (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))]
3960   ""
3961   "*
3962   if (GET_CODE (operands[3]) == NE)
3963     {
3964       if (which_alternative != 1)
3965         output_asm_insn (\"mov%D4\\t%0, %2\", operands);
3966       if (which_alternative != 0)
3967         output_asm_insn (\"mov%d4\\t%0, %1\", operands);
3968       return \"\";
3969     }
3970   if (which_alternative != 0)
3971     output_asm_insn (\"mov%D4\\t%0, %1\", operands);
3972   if (which_alternative != 1)
3973     output_asm_insn (\"mov%d4\\t%0, %2\", operands);
3974   return \"\";
3975 "
3976 [(set_attr "conds" "use")
3977  (set_attr "length" "4,4,8")])
3978
3979 (define_insn ""
3980   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
3981         (match_operator:SI 5 "shiftable_operator"
3982          [(match_operator:SI 4 "comparison_operator"
3983            [(match_operand:SI 2 "s_register_operand" "r,r")
3984             (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])
3985           (match_operand:SI 1 "s_register_operand" "0,?r")]))
3986    (clobber (reg 24))]
3987   ""
3988   "*
3989   if (GET_CODE (operands[4]) == LT && operands[3] == const0_rtx)
3990     return \"%i5\\t%0, %1, %2, lsr #31\";
3991
3992   output_asm_insn (\"cmp\\t%2, %3\", operands);
3993   if (GET_CODE (operands[5]) == AND)
3994     output_asm_insn (\"mov%D4\\t%0, #0\", operands);
3995   else if (which_alternative != 0)
3996     output_asm_insn (\"mov%D4\\t%0, %1\", operands);
3997   return \"%i5%d4\\t%0, %1, #1\";
3998 "
3999 [(set_attr "conds" "clob")
4000  (set_attr "length" "12")])
4001
4002 (define_insn ""
4003   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4004         (minus:SI (match_operand:SI 1 "s_register_operand" "0,?r")
4005                   (match_operator:SI 4 "comparison_operator"
4006                    [(match_operand:SI 2 "s_register_operand" "r,r")
4007                     (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])))
4008    (clobber (reg 24))]
4009   ""
4010   "*
4011   output_asm_insn (\"cmp\\t%2, %3\", operands);
4012   if (which_alternative != 0)
4013     output_asm_insn (\"mov%D4\\t%0, %1\", operands);
4014   return \"sub%d4\\t%0, %1, #1\";
4015 "
4016 [(set_attr "conds" "clob")
4017  (set_attr "length" "8,12")])
4018
4019 (define_insn ""
4020   [(set (match_operand:SI 0 "s_register_operand" "=&r")
4021         (and:SI (match_operator 1 "comparison_operator"
4022                  [(match_operand:SI 2 "s_register_operand" "r")
4023                   (match_operand:SI 3 "arm_rhs_operand" "rI")])
4024                 (match_operator 4 "comparison_operator"
4025                  [(match_operand:SI 5 "s_register_operand" "r")
4026                   (match_operand:SI 6 "arm_rhs_operand" "rI")])))
4027    (clobber (reg 24))]
4028   ""
4029   "*
4030 {
4031   int dominant =
4032         comparison_dominates_p (reverse_condition (GET_CODE (operands[1])),
4033                                 reverse_condition (GET_CODE (operands[4])))
4034         ? 1
4035         : comparison_dominates_p (reverse_condition (GET_CODE (operands[4])),
4036                                   reverse_condition (GET_CODE (operands[1])))
4037         ? 2 : 0;
4038   output_asm_insn (dominant == 2 ? \"cmp\\t%5, %6\" : \"cmp\\t%2, %3\",
4039                        operands);
4040   output_asm_insn (\"mov\\t%0, #1\", operands);
4041   if (GET_CODE (operands[1]) == GET_CODE (operands[4]) || dominant)
4042     {
4043       output_asm_insn (dominant == 2 ? \"cmp%d4\\t%2, %3\"
4044                            : \"cmp%d1\\t%5, %6\", operands);
4045     }
4046   else
4047     {
4048       output_asm_insn (\"mov%D1\\t%0, #0\", operands);
4049       output_asm_insn (\"cmp\\t%5, %6\", operands);
4050     }
4051   return dominant == 2 ? \"mov%D1\\t%0, #0\" : \"mov%D4\\t%0, #0\";
4052 }
4053 "
4054 [(set_attr "conds" "clob")
4055  (set_attr "length" "20")])
4056
4057 (define_split
4058   [(set (pc)
4059         (if_then_else (match_operator 1 "equality_operator"
4060                        [(and:SI (match_operator 2 "comparison_operator"
4061                                  [(match_operand:SI 3 "s_register_operand" "")
4062                                   (match_operand:SI 4 "arm_add_operand" "")])
4063                                 (match_operator 0 "comparison_operator"
4064                                  [(match_operand:SI 5 "s_register_operand" "")
4065                                   (match_operand:SI 6 "arm_add_operand" "")]))
4066                         (const_int 0)])
4067                       (label_ref (match_operand 7 "" ""))
4068                       (pc)))
4069    (clobber (reg 24))]
4070   "(GET_CODE (operands[2]) == GET_CODE (operands[0])
4071     || comparison_dominates_p (reverse_condition (GET_CODE (operands[2])),
4072                                reverse_condition (GET_CODE (operands[0])))
4073     || comparison_dominates_p (reverse_condition (GET_CODE (operands[0])),
4074                                reverse_condition (GET_CODE (operands[2]))))"
4075   [(set (reg:CC 24)
4076         (compare:CC (ior:CC (match_op_dup 2
4077                              [(match_dup 3) (match_dup 4)])
4078                             (match_op_dup 0
4079                              [(match_dup 5) (match_dup 6)]))
4080                     (const_int 0)))
4081    (set (pc)
4082         (if_then_else (match_op_dup 1 [(reg:CC 24) (const_int 0)])
4083                       (label_ref (match_dup 7))
4084                       (pc)))]
4085   "
4086 {
4087   /* Use DeMorgans law to convert this into an IOR of the inverse conditions
4088      This is safe since we only do it for integer comparisons. */
4089   enum rtx_code code =
4090         comparison_dominates_p (reverse_condition (GET_CODE (operands[2])),
4091                                 reverse_condition (GET_CODE (operands[0])))
4092         ? GET_CODE (operands[0]) : GET_CODE (operands[2]);
4093
4094   operands[2] = gen_rtx (reverse_condition (GET_CODE (operands[2])),
4095                          GET_MODE (operands[2]), operands[3], operands[4]);
4096   operands[0] = gen_rtx (reverse_condition (GET_CODE (operands[0])),
4097                          GET_MODE (operands[0]), operands[5], operands[6]);
4098   if (GET_CODE (operands[1]) == NE)
4099     operands[1] = gen_rtx (code, CCmode,
4100                            XEXP (operands[1], 0), XEXP (operands[1], 1));
4101   else
4102     operands[1] = gen_rtx (reverse_condition (code), CCmode,
4103                            XEXP (operands[1], 0), XEXP (operands[1], 1));
4104 }
4105 ")
4106
4107 ;; Don't match these patterns if we can use a conditional compare, since they
4108 ;; tell the final prescan branch elimator code that full branch inlining
4109 ;; can't be done.
4110
4111 (define_insn ""
4112   [(set (pc)
4113         (if_then_else
4114          (eq (and:SI (match_operator 1 "comparison_operator"
4115                       [(match_operand:SI 2 "s_register_operand" "r,r,r,r")
4116                        (match_operand:SI 3 "arm_add_operand" "rI,L,rI,L")])
4117                      (match_operator 4 "comparison_operator"
4118                       [(match_operand:SI 5 "s_register_operand" "r,r,r,r")
4119                        (match_operand:SI 6 "arm_rhs_operand" "rI,rI,L,L")]))
4120              (const_int 0))
4121          (label_ref (match_operand 0 "" ""))
4122          (pc)))
4123    (clobber (reg 24))]
4124   "!(GET_CODE (operands[1]) == GET_CODE (operands[4])
4125      || comparison_dominates_p (reverse_condition (GET_CODE (operands[1])),
4126                                 reverse_condition (GET_CODE (operands[4])))
4127      || comparison_dominates_p (reverse_condition (GET_CODE (operands[4])),
4128                                 reverse_condition (GET_CODE (operands[1]))))"
4129   "*
4130 {
4131   extern int arm_ccfsm_state;
4132
4133   if (which_alternative & 1)
4134     output_asm_insn (\"cmn\\t%2, #%n3\;b%D1\\t%l0\", operands);
4135   else
4136     output_asm_insn (\"cmp\\t%2, %3\;b%D1\\t%l0\", operands);
4137
4138   if (which_alternative >= 2)
4139     output_asm_insn (\"cmn\\t%5, #%n6\", operands);
4140   else
4141     output_asm_insn (\"cmp\\t%5, %6\", operands);
4142
4143   if (arm_ccfsm_state == 1 || arm_ccfsm_state == 2)
4144   {
4145     arm_ccfsm_state += 2;
4146     return \"\";
4147   }
4148   return \"b%D4\\t%l0\";
4149 }"
4150 [(set_attr "conds" "jump_clob")
4151  (set_attr "length" "16")])
4152
4153 (define_insn ""
4154   [(set (match_operand:SI 0 "s_register_operand" "=r")
4155         (neg:SI (match_operator 3 "comparison_operator"
4156                  [(match_operand:SI 1 "s_register_operand" "r")
4157                   (match_operand:SI 2 "arm_rhs_operand" "rI")])))
4158    (clobber (reg 24))]
4159   ""
4160   "*
4161   if (GET_CODE (operands[3]) == LT && operands[3] == const0_rtx)
4162     return \"mov\\t%0, %1, asr #31\";
4163
4164   if (GET_CODE (operands[3]) == NE)
4165     return \"subs\\t%0, %1, %2\;mvnne\\t%0, #0\";
4166
4167   if (GET_CODE (operands[3]) == GT)
4168     return \"subs\\t%0, %1, %2\;mvnne\\t%0, %0, asr #31\";
4169
4170   output_asm_insn (\"cmp\\t%1, %2\", operands);
4171   output_asm_insn (\"mov%D3\\t%0, #0\", operands);
4172   return \"mvn%d3\\t%0, #0\";
4173 "
4174 [(set_attr "conds" "clob")
4175  (set_attr "length" "12")])
4176
4177 (define_insn "movcond"
4178   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r")
4179         (if_then_else:SI
4180          (match_operator 5 "comparison_operator"
4181           [(match_operand:SI 3 "s_register_operand" "r,r,r")
4182            (match_operand:SI 4 "arm_add_operand" "rIL,rIL,rIL")])
4183          (match_operand:SI 1 "arm_rhs_operand" "0,rI,?rI")
4184          (match_operand:SI 2 "arm_rhs_operand" "rI,0,rI")))
4185    (clobber (reg 24))]
4186   ""
4187   "*
4188   if (GET_CODE (operands[5]) == LT
4189       && (operands[4] == const0_rtx))
4190     {
4191       if (which_alternative != 1 && GET_CODE (operands[1]) == REG)
4192         {
4193           if (operands[2] == const0_rtx)
4194             return \"and\\t%0, %1, %3, asr #31\";
4195           return \"ands\\t%0, %1, %3, asr #32\;movcc\\t%0, %2\";
4196         }
4197       else if (which_alternative != 0 && GET_CODE (operands[2]) == REG)
4198         {
4199           if (operands[1] == const0_rtx)
4200             return \"bic\\t%0, %2, %3, asr #31\";
4201           return \"bics\\t%0, %2, %3, asr #32\;movcs\\t%0, %1\";
4202         }
4203       /* The only case that falls through to here is when both ops 1 & 2
4204          are constants */
4205     }
4206
4207   if (GET_CODE (operands[5]) == GE
4208       && (operands[4] == const0_rtx))
4209     {
4210       if (which_alternative != 1 && GET_CODE (operands[1]) == REG)
4211         {
4212           if (operands[2] == const0_rtx)
4213             return \"bic\\t%0, %1, %3, asr #31\";
4214           return \"bics\\t%0, %1, %3, asr #32\;movcs\\t%0, %2\";
4215         }
4216       else if (which_alternative != 0 && GET_CODE (operands[2]) == REG)
4217         {
4218           if (operands[1] == const0_rtx)
4219             return \"and\\t%0, %2, %3, asr #31\";
4220           return \"ands\\t%0, %2, %3, asr #32\;movcc\\t%0, %1\";
4221         }
4222       /* The only case that falls through to here is when both ops 1 & 2
4223          are constants */
4224     }
4225   if (GET_CODE (operands[4]) == CONST_INT
4226       && !const_ok_for_arm (INTVAL (operands[4])))
4227     output_asm_insn (\"cmn\\t%3, #%n4\", operands);
4228   else
4229     output_asm_insn (\"cmp\\t%3, %4\", operands);
4230   if (which_alternative != 0)
4231     output_asm_insn (\"mov%d5\\t%0, %1\", operands);
4232   if (which_alternative != 1)
4233     output_asm_insn (\"mov%D5\\t%0, %2\", operands);
4234   return \"\";
4235 "
4236 [(set_attr "conds" "clob")
4237  (set_attr "length" "8,8,12")])
4238
4239 (define_insn ""
4240   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4241         (if_then_else:SI (match_operator 9 "comparison_operator"
4242                           [(match_operand:SI 5 "s_register_operand" "r,r")
4243                            (match_operand:SI 6 "arm_add_operand" "rI,L")])
4244                          (match_operator:SI 8 "shiftable_operator"
4245                           [(match_operand:SI 1 "s_register_operand" "r,r")
4246                            (match_operand:SI 2 "arm_rhs_operand" "rI,rI")])
4247                          (match_operator:SI 7 "shiftable_operator"
4248                           [(match_operand:SI 3 "s_register_operand" "r,r")
4249                            (match_operand:SI 4 "arm_rhs_operand" "rI,rI")])))
4250    (clobber (reg 24))]
4251   ""
4252   "@
4253    cmp\\t%5, %6\;%I8%d9\\t%0, %1, %2\;%I7%D9\\t%0, %3, %4
4254    cmn\\t%5, #%n6\;%I8%d9\\t%0, %1, %2\;%I7%D9\\t%0, %3, %4"
4255 [(set_attr "conds" "clob")
4256  (set_attr "length" "12")])
4257
4258 (define_insn ""
4259   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4260         (if_then_else:SI (match_operator 6 "comparison_operator"
4261                           [(match_operand:SI 2 "s_register_operand" "r,r")
4262                            (match_operand:SI 3 "arm_add_operand" "rIL,rIL")])
4263                          (match_operator:SI 7 "shiftable_operator"
4264                           [(match_operand:SI 4 "s_register_operand" "r,r")
4265                            (match_operand:SI 5 "arm_rhs_operand" "rI,rI")])
4266                          (match_operand:SI 1 "arm_rhsm_operand" "0,?rIm")))
4267    (clobber (reg 24))]
4268   ""
4269   "*
4270   /* If we have an operation where (op x 0) is the identity operation and
4271      the condtional operator is LT or GE and we are comparing against zero and
4272      everything is in registers then we can do this in two instructions */
4273   if (operands[3] == const0_rtx
4274       && GET_CODE (operands[7]) != AND
4275       && GET_CODE (operands[5]) == REG
4276       && GET_CODE (operands[1]) == REG
4277       && REGNO (operands[1]) == REGNO (operands[4])
4278       && REGNO (operands[4]) != REGNO (operands[0]))
4279     {
4280       if (GET_CODE (operands[6]) == LT)
4281         return \"and\\t%0, %5, %2, asr #31\;%I7\\t%0, %4, %0\";
4282       else if (GET_CODE (operands[6]) == GE)
4283         return \"bic\\t%0, %5, %2, asr #31\;%I7\\t%0, %4, %0\";
4284     }
4285   if (GET_CODE (operands[3]) == CONST_INT
4286       && !const_ok_for_arm (INTVAL (operands[3])))
4287     output_asm_insn (\"cmn\\t%2, #%n3\", operands);
4288   else
4289     output_asm_insn (\"cmp\\t%2, %3\", operands);
4290   output_asm_insn (\"%I7%d6\\t%0, %4, %5\", operands);
4291   if (which_alternative != 0)
4292     {
4293       if (GET_CODE (operands[1]) == MEM)
4294         return \"ldr%D6\\t%0, %1\";
4295       else
4296         return \"mov%D6\\t%0, %1\";
4297     }
4298   return \"\";
4299 "
4300 [(set_attr "conds" "clob")
4301  (set_attr "length" "8,12")])
4302
4303 (define_insn ""
4304   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4305         (if_then_else:SI (match_operator 6 "comparison_operator"
4306                           [(match_operand:SI 4 "s_register_operand" "r,r")
4307                            (match_operand:SI 5 "arm_add_operand" "rIL,rIL")])
4308                          (match_operand:SI 1 "arm_rhsm_operand" "0,?rIm")
4309                          (match_operator:SI 7 "shiftable_operator"
4310                           [(match_operand:SI 2 "s_register_operand" "r,r")
4311                            (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])))
4312    (clobber (reg 24))]
4313   ""
4314   "*
4315   /* If we have an operation where (op x 0) is the identity operation and
4316      the condtional operator is LT or GE and we are comparing against zero and
4317      everything is in registers then we can do this in two instructions */
4318   if (operands[5] == const0_rtx
4319       && GET_CODE (operands[7]) != AND
4320       && GET_CODE (operands[3]) == REG
4321       && GET_CODE (operands[1]) == REG
4322       && REGNO (operands[1]) == REGNO (operands[2])
4323       && REGNO (operands[2]) != REGNO (operands[0]))
4324     {
4325       if (GET_CODE (operands[6]) == GE)
4326         return \"and\\t%0, %3, %4, asr #31\;%I7\\t%0, %2, %0\";
4327       else if (GET_CODE (operands[6]) == LT)
4328         return \"bic\\t%0, %3, %4, asr #31\;%I7\\t%0, %2, %0\";
4329     }
4330
4331   if (GET_CODE (operands[5]) == CONST_INT
4332       && !const_ok_for_arm (INTVAL (operands[5])))
4333     output_asm_insn (\"cmn\\t%4, #%n5\", operands);
4334   else
4335     output_asm_insn (\"cmp\\t%4, %5\", operands);
4336
4337   if (which_alternative != 0)
4338     {
4339       if (GET_CODE (operands[1]) == MEM)
4340         output_asm_insn (\"ldr%d6\\t%0, %1\", operands);
4341       else
4342         output_asm_insn (\"mov%d6\\t%0, %1\", operands);
4343     }
4344   return \"%I7%D6\\t%0, %2, %3\";
4345 "
4346 [(set_attr "conds" "clob")
4347  (set_attr "length" "8,12")])
4348
4349 (define_insn ""
4350   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4351         (if_then_else:SI (match_operator 6 "comparison_operator"
4352                           [(match_operand:SI 4 "s_register_operand" "r,r")
4353                            (match_operand:SI 5 "arm_add_operand" "rIL,rIL")])
4354                          (plus:SI
4355                           (match_operand:SI 2 "s_register_operand" "r,r")
4356                           (match_operand:SI 3 "arm_add_operand" "rL,rL"))
4357                          (match_operand:SI 1 "arm_rhsm_operand" "0,?rIm")))
4358    (clobber (reg 24))]
4359   ""
4360   "*
4361 {
4362   if (GET_CODE (operands[5]) == CONST_INT
4363       && !const_ok_for_arm (INTVAL (operands[5])))
4364     output_asm_insn (\"cmn\\t%4, #%n5\", operands);
4365   else
4366     output_asm_insn (\"cmp\\t%4, %5\", operands);
4367   if (GET_CODE (operands[3]) == CONST_INT
4368       && !const_ok_for_arm (INTVAL (operands[3])))
4369     output_asm_insn (\"sub%d6\\t%0, %2, #%n3\", operands);
4370   else
4371     output_asm_insn (\"add%d6\\t%0, %2, %3\", operands);
4372   if (which_alternative != 0)
4373     {
4374       if (GET_CODE (operands[1]) == MEM)
4375         output_asm_insn (\"ldr%D6\\t%0, %1\", operands);
4376       else
4377         output_asm_insn (\"mov%D6\\t%0, %1\", operands);
4378     }
4379   return \"\";
4380 }
4381 "
4382 [(set_attr "conds" "clob")
4383  (set_attr "length" "8,12")])
4384
4385 (define_insn ""
4386   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4387         (if_then_else:SI (match_operator 6 "comparison_operator"
4388                           [(match_operand:SI 4 "s_register_operand" "r,r")
4389                            (match_operand:SI 5 "arm_add_operand" "rIL,rIL")])
4390                          (match_operand:SI 1 "arm_rhsm_operand" "0,?rIm")
4391                          (plus:SI
4392                           (match_operand:SI 2 "s_register_operand" "r,r")
4393                           (match_operand:SI 3 "arm_add_operand" "rIL,rIL"))))
4394    (clobber (reg 24))]
4395   ""
4396   "*
4397 {
4398   if (GET_CODE (operands[5]) == CONST_INT
4399       && !const_ok_for_arm (INTVAL (operands[5])))
4400     output_asm_insn (\"cmn\\t%4, #%n5\", operands);
4401   else
4402     output_asm_insn (\"cmp\\t%4, %5\", operands);
4403   if (GET_CODE (operands[3]) == CONST_INT
4404       && !const_ok_for_arm (INTVAL (operands[3])))
4405     output_asm_insn (\"sub%D6\\t%0, %2, #%n3\", operands);
4406   else
4407     output_asm_insn (\"add%D6\\t%0, %2, %3\", operands);
4408   if (which_alternative != 0)
4409     {
4410       if (GET_CODE (operands[6]) == MEM)
4411         output_asm_insn (\"ldr%d6\\t%0, %1\", operands);
4412       else
4413         output_asm_insn (\"mov%d6\\t%0, %1\", operands);
4414     }
4415   return \"\";
4416 }
4417 "
4418 [(set_attr "conds" "clob")
4419  (set_attr "length" "8,12")])
4420
4421 (define_insn ""
4422   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4423         (if_then_else:SI (match_operator 5 "comparison_operator"
4424                           [(match_operand:SI 3 "s_register_operand" "r,r")
4425                            (match_operand:SI 4 "arm_add_operand" "rIL,rIL")])
4426                          (match_operand:SI 1 "arm_rhs_operand" "0,?rI")
4427                          (not:SI
4428                           (match_operand:SI 2 "s_register_operand" "r,r"))))
4429    (clobber (reg 24))]
4430   ""
4431   "#"
4432 [(set_attr "conds" "clob")
4433  (set_attr "length" "8,12")])
4434
4435 (define_insn ""
4436   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r")
4437         (if_then_else:SI
4438          (match_operator 5 "comparison_operator"
4439           [(match_operand:SI 3 "s_register_operand" "r,r,r,r")
4440            (match_operand:SI 4 "arm_add_operand" "rI,L,rI,L")])
4441          (not:SI
4442           (match_operand:SI 2 "s_register_operand" "r,r,r,r"))
4443          (match_operand:SI 1 "arm_rhs_operand" "0,0,?rI,?rI")))
4444    (clobber (reg 24))]
4445   ""
4446   "@
4447    cmp\\t%3, %4\;mvn%d5\\t%0, %2
4448    cmn\\t%3, #%n4\;mvn%d5\\t%0, %2
4449    cmp\\t%3, %4\;mov%D5\\t%0, %1\;mvn%d5\\t%0, %2
4450    cmn\\t%3, #%n4\;mov%D5\\t%0, %1\;mvn%d5\\t%0, %2"
4451 [(set_attr "conds" "clob")
4452  (set_attr "length" "8,8,12,12")])
4453
4454 (define_insn ""
4455   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r")
4456         (if_then_else:SI
4457          (match_operator 6 "comparison_operator"
4458           [(match_operand:SI 4 "s_register_operand" "r,r,r,r")
4459            (match_operand:SI 5 "arm_add_operand" "rI,L,rI,L")])
4460          (match_operator:SI 7 "shift_operator"
4461           [(match_operand:SI 2 "s_register_operand" "r,r,r,r")
4462            (match_operand:SI 3 "arm_rhs_operand" "rM,rM,rM,rM")])
4463          (match_operand:SI 1 "arm_rhs_operand" "0,0,?rI,?rI")))
4464    (clobber (reg 24))]
4465   ""
4466   "@
4467    cmp\\t%4, %5\;mov%d6\\t%0, %2%S7
4468    cmn\\t%4, #%n5\;mov%d6\\t%0, %2%S7
4469    cmp\\t%4, %5\;mov%D6\\t%0, %1\;mov%d6\\t%0, %2%S7
4470    cmn\\t%4, #%n5\;mov%D6\\t%0, %1\;mov%d6\\t%0, %2%S7"
4471 [(set_attr "conds" "clob")
4472  (set_attr "length" "8,8,12,12")])
4473
4474 (define_insn ""
4475   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r")
4476         (if_then_else:SI
4477          (match_operator 6 "comparison_operator"
4478           [(match_operand:SI 4 "s_register_operand" "r,r,r,r")
4479            (match_operand:SI 5 "arm_add_operand" "rI,L,rI,L")])
4480          (match_operand:SI 1 "arm_rhs_operand" "0,0,?rI,?rI")
4481          (match_operator:SI 7 "shift_operator"
4482           [(match_operand:SI 2 "s_register_operand" "r,r,r,r")
4483            (match_operand:SI 3 "arm_rhs_operand" "rM,rM,rM,rM")])))
4484    (clobber (reg 24))]
4485   ""
4486   "@
4487    cmp\\t%4, %5\;mov%D6\\t%0, %2%S7
4488    cmn\\t%4, #%n5\;mov%D6\\t%0, %2%S7
4489    cmp\\t%4, %5\;mov%d6\\t%0, %1\;mov%D6\\t%0, %2%S7
4490    cmn\\t%4, #%n5\;mov%d6\\t%0, %1\;mov%D6\\t%0, %2%S7"
4491 [(set_attr "conds" "clob")
4492  (set_attr "length" "8,8,12,12")])
4493
4494 (define_insn ""
4495   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4496         (if_then_else:SI
4497          (match_operator 7 "comparison_operator"
4498           [(match_operand:SI 5 "s_register_operand" "r,r")
4499            (match_operand:SI 6 "arm_add_operand" "rI,L")])
4500          (match_operator:SI 8 "shift_operator"
4501           [(match_operand:SI 1 "s_register_operand" "r,r")
4502            (match_operand:SI 2 "arm_rhs_operand" "rM,rM")])
4503          (match_operator:SI 9 "shift_operator"
4504           [(match_operand:SI 3 "s_register_operand" "r,r")
4505            (match_operand:SI 4 "arm_rhs_operand" "rI,rI")])))
4506    (clobber (reg 24))]
4507   ""
4508   "@
4509    cmp\\t%5, %6\;mov%d7\\t%0, %1%S8\;mov%D7\\t%0, %3%S9
4510    cmn\\t%5, #%n6\;mov%d7\\t%0, %1%S8\;mov%D7\\t%0, %3%S9"
4511 [(set_attr "conds" "clob")
4512  (set_attr "length" "12")])
4513
4514 (define_insn ""
4515   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4516         (if_then_else:SI
4517          (match_operator 6 "comparison_operator"
4518           [(match_operand:SI 4 "s_register_operand" "r,r")
4519            (match_operand:SI 5 "arm_add_operand" "rI,L")])
4520          (not:SI (match_operand:SI 1 "s_register_operand" "r,r"))
4521          (match_operator:SI 7 "shiftable_operator"
4522           [(match_operand:SI 2 "s_register_operand" "r,r")
4523            (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])))
4524    (clobber (reg 24))]
4525   ""
4526   "@
4527    cmp\\t%4, %5\;mvn%d6\\t%0, %1\;%I7%D6\\t%0, %2, %3
4528    cmn\\t%4, #%n5\;mvn%d6\\t%0, %1\;%I7%D6\\t%0, %2, %3"
4529 [(set_attr "conds" "clob")
4530  (set_attr "length" "12")])
4531
4532 (define_insn ""
4533   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
4534         (if_then_else:SI
4535          (match_operator 6 "comparison_operator"
4536           [(match_operand:SI 4 "s_register_operand" "r,r")
4537            (match_operand:SI 5 "arm_add_operand" "rI,L")])
4538          (match_operator:SI 7 "shiftable_operator"
4539           [(match_operand:SI 2 "s_register_operand" "r,r")
4540            (match_operand:SI 3 "arm_rhs_operand" "rI,rI")])
4541          (not:SI (match_operand:SI 1 "s_register_operand" "r,r"))))
4542    (clobber (reg 24))]
4543   ""
4544   "@
4545    cmp\\t%4, %5\;mvn%D6\\t%0, %1\;%I7%d6\\t%0, %2, %3
4546    cmn\\t%4, #%n5\;mvn%D6\\t%0, %1\;%I7%d6\\t%0, %2, %3"
4547 [(set_attr "conds" "clob")
4548  (set_attr "length" "12")])
4549
4550 (define_insn ""
4551   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r")
4552         (if_then_else:SI
4553          (match_operator 5 "comparison_operator"
4554           [(match_operand:SI 3 "s_register_operand" "r,r,r,r")
4555            (match_operand:SI 4 "arm_add_operand" "rI,L,rI,L")])
4556          (neg:SI (match_operand:SI 2 "s_register_operand" "r,r,r,r"))
4557          (match_operand:SI 1 "arm_rhs_operand" "0,0,?rI,?rI")))
4558    (clobber (reg:CC 24))]
4559   ""
4560   "@
4561    cmp\\t%3, %4\;rsb%d5\\t%0, %2, #0
4562    cmn\\t%3, #%n4\;rsb%d5\\t%0, %2, #0
4563    cmp\\t%3, %4\;mov%D5\\t%0, %1\;rsb%d5\\t%0, %2, #0
4564    cmn\\t%3, #%n4\;mov%D5\\t%0, %1\;rsb%d5\\t%0, %2, #0"
4565 [(set_attr "conds" "clob")
4566  (set_attr "length" "8,8,12,12")])
4567
4568 (define_insn ""
4569   [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r")
4570         (if_then_else:SI
4571          (match_operator 5 "comparison_operator"
4572           [(match_operand:SI 3 "s_register_operand" "r,r,r,r")
4573            (match_operand:SI 4 "arm_add_operand" "rI,L,rI,L")])
4574          (match_operand:SI 1 "arm_rhs_operand" "0,0,?rI,?rI")
4575          (neg:SI (match_operand:SI 2 "s_register_operand" "r,r,r,r"))))
4576    (clobber (reg:CC 24))]
4577   ""
4578   "@
4579    cmp\\t%3, %4\;rsb%D5\\t%0, %2, #0
4580    cmn\\t%3, #%n4\;rsb%D5\\t%0, %2, #0
4581    cmp\\t%3, %4\;mov%d5\\t%0, %1\;rsb%D5\\t%0, %2, #0
4582    cmn\\t%3, #%n4\;mov%d5\\t%0, %1\;rsb%D5\\t%0, %2, #0"
4583 [(set_attr "conds" "clob")
4584  (set_attr "length" "8,8,12,12")])
4585
4586 (define_insn ""
4587   [(set (match_operand:SI 0 "s_register_operand" "=r")
4588         (match_operator:SI 1 "shiftable_operator"
4589          [(match_operand:SI 2 "memory_operand" "m")
4590           (match_operand:SI 3 "memory_operand" "m")]))
4591    (clobber (match_scratch:SI 4 "=r"))]
4592   "adjacent_mem_locations (operands[2], operands[3])"
4593   "*
4594 {
4595   rtx ldm[3];
4596   rtx arith[4];
4597   int val1 = 0, val2 = 0;
4598
4599   if (REGNO (operands[0]) > REGNO (operands[4]))
4600     {
4601       ldm[1] = operands[4];
4602       ldm[2] = operands[0];
4603     }
4604   else
4605     {
4606       ldm[1] = operands[0];
4607       ldm[2] = operands[4];
4608     }
4609   if (GET_CODE (XEXP (operands[2], 0)) != REG)
4610     val1 = INTVAL (XEXP (XEXP (operands[2], 0), 1));
4611   if (GET_CODE (XEXP (operands[3], 0)) != REG)
4612     val2 = INTVAL (XEXP (XEXP (operands[3], 0), 1));
4613   arith[0] = operands[0];
4614   arith[3] = operands[1];
4615   if (val1 < val2)
4616     {
4617       arith[1] = ldm[1];
4618       arith[2] = ldm[2];
4619     }
4620   else
4621     {
4622       arith[1] = ldm[2];
4623       arith[2] = ldm[1];
4624     }
4625   if (val1 && val2)
4626     {
4627       rtx ops[3];
4628       ldm[0] = ops[0] = operands[4];
4629       ops[1] = XEXP (XEXP (operands[2], 0), 0);
4630       ops[2] = XEXP (XEXP (operands[2], 0), 1);
4631       output_add_immediate (ops);
4632       if (val1 < val2)
4633         output_asm_insn (\"ldm%?ia\\t%0, {%1, %2}\", ldm);
4634       else
4635         output_asm_insn (\"ldm%?da\\t%0, {%1, %2}\", ldm);
4636     }
4637   else if (val1)
4638     {
4639       ldm[0] = XEXP (operands[3], 0);
4640       if (val1 < val2)
4641         output_asm_insn (\"ldm%?da\\t%0, {%1, %2}\", ldm);
4642       else
4643         output_asm_insn (\"ldm%?ia\\t%0, {%1, %2}\", ldm);
4644     }
4645   else
4646     {
4647       ldm[0] = XEXP (operands[2], 0);
4648       if (val1 < val2)
4649         output_asm_insn (\"ldm%?ia\\t%0, {%1, %2}\", ldm);
4650       else
4651         output_asm_insn (\"ldm%?da\\t%0, {%1, %2}\", ldm);
4652     }
4653   output_asm_insn (\"%I3%?\\t%0, %1, %2\", arith);
4654   return \"\";
4655 }
4656 "
4657 [(set_attr "length" "12")
4658  (set_attr "type" "load")])
4659
4660 ;; the arm can support extended pre-inc instructions
4661
4662 ;; In all these cases, we use operands 0 and 1 for the register being
4663 ;; incremented because those are the operands that local-alloc will
4664 ;; tie and these are the pair most likely to be tieable (and the ones
4665 ;; that will benefit the most).
4666
4667 ;; We reject the frame pointer if it occurs anywhere in these patterns since
4668 ;; elimination will cause too many headaches.
4669
4670 (define_insn ""
4671   [(set (mem:QI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4672                          (match_operand:SI 2 "index_operand" "rJ")))
4673         (match_operand:QI 3 "s_register_operand" "r"))
4674    (set (match_operand:SI 0 "s_register_operand" "=r")
4675         (plus:SI (match_dup 1) (match_dup 2)))]
4676   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4677    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4678    && (GET_CODE (operands[2]) != REG
4679        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4680   "str%?b\\t%3, [%0, %2]!"
4681 [(set_attr "type" "store1")])
4682
4683 (define_insn ""
4684   [(set (mem:QI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4685                           (match_operand:SI 2 "s_register_operand" "r")))
4686         (match_operand:QI 3 "s_register_operand" "r"))
4687    (set (match_operand:SI 0 "s_register_operand" "=r")
4688         (minus:SI (match_dup 1) (match_dup 2)))]
4689   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4690    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4691    && (GET_CODE (operands[2]) != REG
4692        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4693   "str%?b\\t%3, [%0, -%2]!"
4694 [(set_attr "type" "store1")])
4695
4696 (define_insn ""
4697   [(set (match_operand:QI 3 "s_register_operand" "=r")
4698         (mem:QI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4699                          (match_operand:SI 2 "index_operand" "rJ"))))
4700    (set (match_operand:SI 0 "s_register_operand" "=r")
4701         (plus:SI (match_dup 1) (match_dup 2)))]
4702   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4703    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4704    && (GET_CODE (operands[2]) != REG
4705        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4706   "ldr%?b\\t%3, [%0, %2]!"
4707 [(set_attr "type" "load")])
4708
4709 (define_insn ""
4710   [(set (match_operand:QI 3 "s_register_operand" "=r")
4711         (mem:QI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4712                           (match_operand:SI 2 "s_register_operand" "r"))))
4713    (set (match_operand:SI 0 "s_register_operand" "=r")
4714         (minus:SI (match_dup 1) (match_dup 2)))]
4715   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4716    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4717    && (GET_CODE (operands[2]) != REG
4718        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4719   "ldr%?b\\t%3, [%0, -%2]!"
4720 [(set_attr "type" "load")])
4721
4722 (define_insn ""
4723   [(set (match_operand:SI 3 "s_register_operand" "=r")
4724         (zero_extend:SI
4725          (mem:QI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4726                           (match_operand:SI 2 "index_operand" "rJ")))))
4727    (set (match_operand:SI 0 "s_register_operand" "=r")
4728         (plus:SI (match_dup 1) (match_dup 2)))]
4729   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4730    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4731    && (GET_CODE (operands[2]) != REG
4732        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4733   "ldr%?b\\t%3, [%0, %2]!\\t%@ z_extendqisi"
4734 [(set_attr "type" "load")])
4735
4736 (define_insn ""
4737   [(set (match_operand:SI 3 "s_register_operand" "=r")
4738         (zero_extend:SI
4739          (mem:QI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4740                            (match_operand:SI 2 "s_register_operand" "r")))))
4741    (set (match_operand:SI 0 "s_register_operand" "=r")
4742         (minus:SI (match_dup 1) (match_dup 2)))]
4743   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4744    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4745    && (GET_CODE (operands[2]) != REG
4746        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4747   "ldr%?b\\t%3, [%0, -%2]!\\t%@ z_extendqisi"
4748 [(set_attr "type" "load")])
4749
4750 (define_insn ""
4751   [(set (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4752                          (match_operand:SI 2 "index_operand" "rJ")))
4753         (match_operand:SI 3 "s_register_operand" "r"))
4754    (set (match_operand:SI 0 "s_register_operand" "=r")
4755         (plus:SI (match_dup 1) (match_dup 2)))]
4756   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4757    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4758    && (GET_CODE (operands[2]) != REG
4759        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4760   "str%?\\t%3, [%0, %2]!"
4761 [(set_attr "type" "store1")])
4762
4763 (define_insn ""
4764   [(set (mem:SI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4765                           (match_operand:SI 2 "s_register_operand" "r")))
4766         (match_operand:SI 3 "s_register_operand" "r"))
4767    (set (match_operand:SI 0 "s_register_operand" "=r")
4768         (minus:SI (match_dup 1) (match_dup 2)))]
4769   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4770    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4771    && (GET_CODE (operands[2]) != REG
4772        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4773   "str%?\\t%3, [%0, -%2]!"
4774 [(set_attr "type" "store1")])
4775
4776 (define_insn ""
4777   [(set (match_operand:SI 3 "s_register_operand" "=r")
4778         (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4779                          (match_operand:SI 2 "index_operand" "rJ"))))
4780    (set (match_operand:SI 0 "s_register_operand" "=r")
4781         (plus:SI (match_dup 1) (match_dup 2)))]
4782   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4783    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4784    && (GET_CODE (operands[2]) != REG
4785        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4786   "ldr%?\\t%3, [%0, %2]!"
4787 [(set_attr "type" "load")])
4788
4789 (define_insn ""
4790   [(set (match_operand:SI 3 "s_register_operand" "=r")
4791         (mem:SI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4792                           (match_operand:SI 2 "s_register_operand" "r"))))
4793    (set (match_operand:SI 0 "s_register_operand" "=r")
4794         (minus:SI (match_dup 1) (match_dup 2)))]
4795   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4796    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4797    && (GET_CODE (operands[2]) != REG
4798        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4799   "ldr%?\\t%3, [%0, -%2]!"
4800 [(set_attr "type" "load")])
4801
4802 (define_insn ""
4803   [(set (match_operand:HI 3 "s_register_operand" "=r")
4804         (mem:HI (plus:SI (match_operand:SI 1 "s_register_operand" "%0")
4805                          (match_operand:SI 2 "index_operand" "rJ"))))
4806    (set (match_operand:SI 0 "s_register_operand" "=r")
4807         (plus:SI (match_dup 1) (match_dup 2)))]
4808   "(! BYTES_BIG_ENDIAN)
4809    && ! TARGET_SHORT_BY_BYTES
4810    && REGNO (operands[0]) != FRAME_POINTER_REGNUM
4811    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4812    && (GET_CODE (operands[2]) != REG
4813        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4814   "ldr%?\\t%3, [%0, %2]!\\t%@ loadhi"
4815 [(set_attr "type" "load")])
4816
4817 (define_insn ""
4818   [(set (match_operand:HI 3 "s_register_operand" "=r")
4819         (mem:HI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4820                           (match_operand:SI 2 "s_register_operand" "r"))))
4821    (set (match_operand:SI 0 "s_register_operand" "=r")
4822         (minus:SI (match_dup 1) (match_dup 2)))]
4823   "(!BYTES_BIG_ENDIAN)
4824    && ! TARGET_SHORT_BY_BYTES
4825    && REGNO (operands[0]) != FRAME_POINTER_REGNUM
4826    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4827    && (GET_CODE (operands[2]) != REG
4828        || REGNO (operands[2]) != FRAME_POINTER_REGNUM)"
4829   "ldr%?\\t%3, [%0, -%2]!\\t%@ loadhi"
4830 [(set_attr "type" "load")])
4831
4832 (define_insn ""
4833   [(set (mem:QI (plus:SI (match_operator:SI 2 "shift_operator"
4834                           [(match_operand:SI 3 "s_register_operand" "r")
4835                            (match_operand:SI 4 "const_shift_operand" "n")])
4836                          (match_operand:SI 1 "s_register_operand" "0")))
4837         (match_operand:QI 5 "s_register_operand" "r"))
4838    (set (match_operand:SI 0 "s_register_operand" "=r")
4839         (plus:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
4840                  (match_dup 1)))]
4841   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4842    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4843    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4844   "str%?b\\t%5, [%0, %3%S2]!"
4845 [(set_attr "type" "store1")])
4846
4847 (define_insn ""
4848   [(set (mem:QI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4849                           (match_operator:SI 2 "shift_operator"
4850                            [(match_operand:SI 3 "s_register_operand" "r")
4851                             (match_operand:SI 4 "const_shift_operand" "n")])))
4852         (match_operand:QI 5 "s_register_operand" "r"))
4853    (set (match_operand:SI 0 "s_register_operand" "=r")
4854         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
4855                                                  (match_dup 4)])))]
4856   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4857    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4858    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4859   "str%?b\\t%5, [%0, -%3%S2]!"
4860 [(set_attr "type" "store1")])
4861
4862 (define_insn ""
4863   [(set (match_operand:QI 5 "s_register_operand" "=r")
4864         (mem:QI (plus:SI (match_operator:SI 2 "shift_operator"
4865                           [(match_operand:SI 3 "s_register_operand" "r")
4866                            (match_operand:SI 4 "const_shift_operand" "n")])
4867                          (match_operand:SI 1 "s_register_operand" "0"))))
4868    (set (match_operand:SI 0 "s_register_operand" "=r")
4869         (plus:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
4870                  (match_dup 1)))]
4871   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4872    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4873    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4874   "ldr%?b\\t%5, [%0, %3%S2]!"
4875 [(set_attr "type" "load")])
4876
4877 (define_insn ""
4878   [(set (match_operand:QI 5 "s_register_operand" "=r")
4879         (mem:QI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4880                           (match_operator:SI 2 "shift_operator"
4881                            [(match_operand:SI 3 "s_register_operand" "r")
4882                             (match_operand:SI 4 "const_shift_operand" "n")]))))
4883    (set (match_operand:SI 0 "s_register_operand" "=r")
4884         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
4885                                                  (match_dup 4)])))]
4886   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4887    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4888    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4889   "ldr%?b\\t%5, [%0, -%3%S2]!"
4890 [(set_attr "type" "load")])
4891
4892 (define_insn ""
4893   [(set (mem:SI (plus:SI (match_operator:SI 2 "shift_operator"
4894                           [(match_operand:SI 3 "s_register_operand" "r")
4895                            (match_operand:SI 4 "const_shift_operand" "n")])
4896                          (match_operand:SI 1 "s_register_operand" "0")))
4897         (match_operand:SI 5 "s_register_operand" "r"))
4898    (set (match_operand:SI 0 "s_register_operand" "=r")
4899         (plus:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
4900                  (match_dup 1)))]
4901   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4902    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4903    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4904   "str%?\\t%5, [%0, %3%S2]!"
4905 [(set_attr "type" "store1")])
4906
4907 (define_insn ""
4908   [(set (mem:SI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4909                           (match_operator:SI 2 "shift_operator"
4910                            [(match_operand:SI 3 "s_register_operand" "r")
4911                             (match_operand:SI 4 "const_shift_operand" "n")])))
4912         (match_operand:SI 5 "s_register_operand" "r"))
4913    (set (match_operand:SI 0 "s_register_operand" "=r")
4914         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
4915                                                  (match_dup 4)])))]
4916   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4917    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4918    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4919   "str%?\\t%5, [%0, -%3%S2]!"
4920 [(set_attr "type" "store1")])
4921
4922 (define_insn ""
4923   [(set (match_operand:SI 5 "s_register_operand" "=r")
4924         (mem:SI (plus:SI (match_operator:SI 2 "shift_operator"
4925                           [(match_operand:SI 3 "s_register_operand" "r")
4926                            (match_operand:SI 4 "const_shift_operand" "n")])
4927                          (match_operand:SI 1 "s_register_operand" "0"))))
4928    (set (match_operand:SI 0 "s_register_operand" "=r")
4929         (plus:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
4930                  (match_dup 1)))]
4931   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4932    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4933    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4934   "ldr%?\\t%5, [%0, %3%S2]!"
4935 [(set_attr "type" "load")])
4936
4937 (define_insn ""
4938   [(set (match_operand:SI 5 "s_register_operand" "=r")
4939         (mem:SI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4940                           (match_operator:SI 2 "shift_operator"
4941                            [(match_operand:SI 3 "s_register_operand" "r")
4942                             (match_operand:SI 4 "const_shift_operand" "n")]))))
4943    (set (match_operand:SI 0 "s_register_operand" "=r")
4944         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
4945                                                  (match_dup 4)])))]
4946   "REGNO (operands[0]) != FRAME_POINTER_REGNUM
4947    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4948    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4949   "ldr%?\\t%5, [%0, -%3%S2]!"
4950 [(set_attr "type" "load")])
4951
4952 (define_insn ""
4953   [(set (match_operand:HI 5 "s_register_operand" "=r")
4954         (mem:HI (plus:SI (match_operator:SI 2 "shift_operator"
4955                           [(match_operand:SI 3 "s_register_operand" "r")
4956                            (match_operand:SI 4 "const_shift_operand" "n")])
4957                          (match_operand:SI 1 "s_register_operand" "0"))))
4958    (set (match_operand:SI 0 "s_register_operand" "=r")
4959         (plus:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
4960                  (match_dup 1)))]
4961   "(! BYTES_BIG_ENDIAN)
4962    && ! TARGET_SHORT_BY_BYTES
4963    && REGNO (operands[0]) != FRAME_POINTER_REGNUM
4964    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4965    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4966   "ldr%?\\t%5, [%0, %3%S2]!\\t%@ loadhi"
4967 [(set_attr "type" "load")])
4968
4969 (define_insn ""
4970   [(set (match_operand:HI 5 "s_register_operand" "=r")
4971         (mem:HI (minus:SI (match_operand:SI 1 "s_register_operand" "0")
4972                           (match_operator:SI 2 "shift_operator"
4973                            [(match_operand:SI 3 "s_register_operand" "r")
4974                             (match_operand:SI 4 "const_shift_operand" "n")]))))
4975    (set (match_operand:SI 0 "s_register_operand" "=r")
4976         (minus:SI (match_dup 1) (match_op_dup 2 [(match_dup 3)
4977                                                  (match_dup 4)])))]
4978   "(! BYTES_BIG_ENDIAN)
4979    && ! TARGET_SHORT_BY_BYTES
4980    && REGNO (operands[0]) != FRAME_POINTER_REGNUM
4981    && REGNO (operands[1]) != FRAME_POINTER_REGNUM
4982    && REGNO (operands[3]) != FRAME_POINTER_REGNUM"
4983   "ldr%?\\t%5, [%0, -%3%S2]!\\t%@ loadhi"
4984 [(set_attr "type" "load")])
4985
4986 ; It can also support extended post-inc expressions, but combine doesn't
4987 ; try these....
4988 ; It doesn't seem worth adding peepholes for anything but the most common
4989 ; cases since, unlike combine, the increment must immediately follow the load
4990 ; for this pattern to match.
4991 ; When loading we must watch to see that the base register isn't trampled by
4992 ; the load.  In such cases this isn't a post-inc expression.
4993
4994 (define_peephole
4995   [(set (mem:QI (match_operand:SI 0 "s_register_operand" "+r"))
4996         (match_operand:QI 2 "s_register_operand" "r"))
4997    (set (match_dup 0)
4998         (plus:SI (match_dup 0) (match_operand:SI 1 "index_operand" "rJ")))]
4999   ""
5000   "str%?b\\t%2, [%0], %1")
5001
5002 (define_peephole
5003   [(set (match_operand:QI 0 "s_register_operand" "=r")
5004         (mem:QI (match_operand:SI 1 "s_register_operand" "+r")))
5005    (set (match_dup 1)
5006         (plus:SI (match_dup 1) (match_operand:SI 2 "index_operand" "rJ")))]
5007   "REGNO(operands[0]) != REGNO(operands[1])
5008    && (GET_CODE (operands[2]) != REG
5009        || REGNO(operands[0]) != REGNO (operands[2]))"
5010   "ldr%?b\\t%0, [%1], %2")
5011
5012 (define_peephole
5013   [(set (mem:SI (match_operand:SI 0 "s_register_operand" "+r"))
5014         (match_operand:SI 2 "s_register_operand" "r"))
5015    (set (match_dup 0)
5016         (plus:SI (match_dup 0) (match_operand:SI 1 "index_operand" "rJ")))]
5017   ""
5018   "str%?\\t%2, [%0], %1")
5019
5020 (define_peephole
5021   [(set (match_operand:HI 0 "s_register_operand" "=r")
5022         (mem:HI (match_operand:SI 1 "s_register_operand" "+r")))
5023    (set (match_dup 1)
5024         (plus:SI (match_dup 1) (match_operand:SI 2 "index_operand" "rJ")))]
5025   "(! BYTES_BIG_ENDIAN)
5026    && ! TARGET_SHORT_BY_BYTES
5027    && REGNO(operands[0]) != REGNO(operands[1])
5028    && (GET_CODE (operands[2]) != REG
5029        || REGNO(operands[0]) != REGNO (operands[2]))"
5030   "ldr%?\\t%0, [%1], %2\\t%@ loadhi")
5031
5032 (define_peephole
5033   [(set (match_operand:SI 0 "s_register_operand" "=r")
5034         (mem:SI (match_operand:SI 1 "s_register_operand" "+r")))
5035    (set (match_dup 1)
5036         (plus:SI (match_dup 1) (match_operand:SI 2 "index_operand" "rJ")))]
5037   "REGNO(operands[0]) != REGNO(operands[1])
5038    && (GET_CODE (operands[2]) != REG
5039        || REGNO(operands[0]) != REGNO (operands[2]))"
5040   "ldr%?\\t%0, [%1], %2")
5041
5042 (define_peephole
5043   [(set (mem:QI (plus:SI (match_operand:SI 0 "s_register_operand" "+r")
5044                          (match_operand:SI 1 "index_operand" "rJ")))
5045         (match_operand:QI 2 "s_register_operand" "r"))
5046    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 1)))]
5047   ""
5048   "str%?b\\t%2, [%0, %1]!")
5049
5050 (define_peephole
5051   [(set (mem:QI (plus:SI (match_operator:SI 4 "shift_operator"
5052                           [(match_operand:SI 0 "s_register_operand" "r")
5053                            (match_operand:SI 1 "const_int_operand" "n")])
5054                          (match_operand:SI 2 "s_register_operand" "+r")))
5055         (match_operand:QI 3 "s_register_operand" "r"))
5056    (set (match_dup 2) (plus:SI (match_op_dup 4 [(match_dup 0) (match_dup 1)])
5057                                (match_dup 2)))]
5058   ""
5059   "str%?b\\t%3, [%2, %0%S4]!")
5060
5061 ; This pattern is never tried by combine, so do it as a peephole
5062
5063 (define_peephole
5064   [(set (match_operand:SI 0 "s_register_operand" "=r")
5065         (match_operand:SI 1 "s_register_operand" "r"))
5066    (set (match_operand 2 "cc_register" "")
5067         (compare (match_dup 1) (const_int 0)))]
5068   ""
5069   "sub%?s\\t%0, %1, #0"
5070 [(set_attr "conds" "set")])
5071
5072 ; Peepholes to spot possible load- and store-multiples, if the ordering is
5073 ; reversed, check that the memory references aren't volatile.
5074
5075 (define_peephole
5076   [(set (match_operand:SI 0 "s_register_operand" "=r")
5077         (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5078                          (const_int 12))))
5079    (set (match_operand:SI 2 "s_register_operand" "=r")
5080         (mem:SI (plus:SI (match_dup 1) (const_int 8))))
5081    (set (match_operand:SI 3 "s_register_operand" "=r")
5082         (mem:SI (plus:SI (match_dup 1) (const_int 4))))
5083    (set (match_operand:SI 4 "s_register_operand" "=r")
5084         (mem:SI (match_dup 1)))]
5085   "REGNO (operands[0]) > REGNO (operands[2])
5086    && REGNO (operands[2]) > REGNO (operands[3])
5087    && REGNO (operands[3]) > REGNO (operands[4])
5088    && !(REGNO (operands[1]) == REGNO (operands[0])
5089        || REGNO (operands[1]) == REGNO (operands[2])
5090        || REGNO (operands[1]) == REGNO (operands[3])
5091        || REGNO (operands[1]) == REGNO (operands[4]))
5092    && !MEM_VOLATILE_P (SET_SRC (PATTERN (insn)))
5093    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn (insn))))
5094    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn
5095                                          (prev_nonnote_insn (insn)))))
5096    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn
5097                                          (prev_nonnote_insn
5098                                           (prev_nonnote_insn (insn))))))"
5099   "ldm%?ia\\t%1, {%4, %3, %2, %0}\\t%@ phole ldm")
5100
5101 (define_peephole
5102   [(set (match_operand:SI 0 "s_register_operand" "=r")
5103         (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5104                          (const_int 8))))
5105    (set (match_operand:SI 2 "s_register_operand" "=r")
5106         (mem:SI (plus:SI (match_dup 1) (const_int 4))))
5107    (set (match_operand:SI 3 "s_register_operand" "=r")
5108         (mem:SI (match_dup 1)))]
5109   "REGNO (operands[0]) >  REGNO (operands[2])
5110    && REGNO (operands[2]) > REGNO (operands[3])
5111    && !(REGNO (operands[1]) == REGNO (operands[0])
5112        || REGNO (operands[1]) == REGNO (operands[2])
5113        || REGNO (operands[1]) == REGNO (operands[3]))
5114    && !MEM_VOLATILE_P (SET_SRC (PATTERN (insn)))
5115    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn (insn))))
5116    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn
5117                                          (prev_nonnote_insn (insn)))))"
5118   "ldm%?ia\\t%1, {%3, %2, %0}\\t%@ phole ldm")
5119
5120 (define_peephole
5121   [(set (match_operand:SI 0 "s_register_operand" "=r")
5122         (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5123                          (const_int 4))))
5124    (set (match_operand:SI 2 "s_register_operand" "=r")
5125         (mem:SI (match_dup 1)))]
5126   "REGNO (operands[0]) > REGNO (operands[2])
5127    && !(REGNO (operands[1]) == REGNO (operands[0])
5128        || REGNO (operands[1]) == REGNO (operands[2]))
5129    && !MEM_VOLATILE_P (SET_SRC (PATTERN (insn)))
5130    && !MEM_VOLATILE_P (SET_SRC (PATTERN (prev_nonnote_insn (insn))))"
5131   "ldm%?ia\\t%1, {%2, %0}\\t%@ phole ldm")
5132
5133 (define_peephole
5134   [(set (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5135                          (const_int 12)))
5136         (match_operand:SI 0 "s_register_operand" "r"))
5137    (set (mem:SI (plus:SI (match_dup 1) (const_int 8)))
5138         (match_operand:SI 2 "s_register_operand" "r"))
5139    (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
5140         (match_operand:SI 3 "s_register_operand" "r"))
5141    (set (mem:SI (match_dup 1))
5142         (match_operand:SI 4 "s_register_operand" "r"))]
5143   "REGNO (operands[0]) >  REGNO (operands[2])
5144    && REGNO (operands[2]) > REGNO (operands[3])
5145    && REGNO (operands[3]) > REGNO (operands[4])
5146    && !MEM_VOLATILE_P (SET_DEST (PATTERN (insn)))
5147    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn (insn))))
5148    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn
5149                                           (prev_nonnote_insn (insn)))))
5150    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn
5151                                           (prev_nonnote_insn
5152                                            (prev_nonnote_insn (insn))))))"
5153   "stm%?ia\\t%1, {%4, %3, %2, %0}\\t%@ phole stm")
5154
5155 (define_peephole
5156   [(set (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5157                          (const_int 8)))
5158         (match_operand:SI 0 "s_register_operand" "r"))
5159    (set (mem:SI (plus:SI (match_dup 1) (const_int 4)))
5160         (match_operand:SI 2 "s_register_operand" "r"))
5161    (set (mem:SI (match_dup 1))
5162         (match_operand:SI 3 "s_register_operand" "r"))]
5163   "REGNO (operands[0]) >  REGNO (operands[2])
5164    && REGNO (operands[2]) > REGNO (operands[3])
5165    && !MEM_VOLATILE_P (SET_DEST (PATTERN (insn)))
5166    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn (insn))))
5167    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn
5168                                           (prev_nonnote_insn (insn)))))"
5169   "stm%?ia\\t%1, {%3, %2, %0}\\t%@ phole stm")
5170
5171 (define_peephole
5172   [(set (mem:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r")
5173                          (const_int 4)))
5174         (match_operand:SI 0 "s_register_operand" "r"))
5175    (set (mem:SI (match_dup 1))
5176         (match_operand:SI 2 "s_register_operand" "r"))]
5177   "REGNO (operands[0]) >  REGNO (operands[2])
5178    && !MEM_VOLATILE_P (SET_DEST (PATTERN (insn)))
5179    && !MEM_VOLATILE_P (SET_DEST (PATTERN (prev_nonnote_insn (insn))))"
5180   "stm%?ia\\t%1, {%2, %0}\\t%@ phole stm")
5181
5182 ;; A call followed by return can be replaced by restoring the regs and
5183 ;; jumping to the subroutine, provided we aren't passing the address of
5184 ;; any of our local variables.  If we call alloca then this is unsafe
5185 ;; since restoring the frame frees the memory, which is not what we want.
5186 ;; Sometimes the return might have been targeted by the final prescan:
5187 ;; if so then emit a propper return insn as well.
5188 ;; Unfortunately, if the frame pointer is required, we don't know if the
5189 ;; current function has any implicit stack pointer adjustments that will
5190 ;; be restored by the return: we can't therefore do a tail call.
5191 ;; Another unfortunate that we can't handle is if current_function_args_size
5192 ;; is non-zero: in this case elimination of the argument pointer assumed
5193 ;; that lr was pushed onto the stack, so eliminating upsets the offset
5194 ;; calculations.
5195
5196 (define_peephole
5197   [(parallel [(call (mem:SI (match_operand:SI 0 "" "i"))
5198                           (match_operand:SI 1 "general_operand" "g"))
5199                     (clobber (reg:SI 14))])
5200    (return)]
5201   "(GET_CODE (operands[0]) == SYMBOL_REF && USE_RETURN_INSN
5202     && !get_frame_size () && !current_function_calls_alloca
5203     && !frame_pointer_needed && !current_function_args_size)"
5204   "*
5205 {
5206   extern rtx arm_target_insn;
5207   extern int arm_ccfsm_state, arm_current_cc;
5208
5209   if (arm_ccfsm_state && arm_target_insn && INSN_DELETED_P (arm_target_insn))
5210   {
5211     arm_current_cc ^= 1;
5212     output_return_instruction (NULL, TRUE);
5213     arm_ccfsm_state = 0;
5214     arm_target_insn = NULL;
5215   }
5216
5217   output_return_instruction (NULL, FALSE);
5218   return \"b%?\\t%a0\";
5219 }"
5220 [(set (attr "conds")
5221       (if_then_else (eq_attr "cpu" "arm6")
5222                     (const_string "clob")
5223                     (const_string "nocond")))
5224  (set_attr "length" "8")])
5225
5226 (define_peephole
5227   [(parallel [(set (match_operand 0 "s_register_operand" "=rf")
5228                    (call (mem:SI (match_operand:SI 1 "" "i"))
5229                          (match_operand:SI 2 "general_operand" "g")))
5230               (clobber (reg:SI 14))])
5231    (return)]
5232   "(GET_CODE (operands[1]) == SYMBOL_REF && USE_RETURN_INSN
5233     && !get_frame_size () && !current_function_calls_alloca
5234     && !frame_pointer_needed && !current_function_args_size)"
5235   "*
5236 {
5237   extern rtx arm_target_insn;
5238   extern int arm_ccfsm_state, arm_current_cc;
5239
5240   if (arm_ccfsm_state && arm_target_insn && INSN_DELETED_P (arm_target_insn))
5241   {
5242     arm_current_cc ^= 1;
5243     output_return_instruction (NULL, TRUE);
5244     arm_ccfsm_state = 0;
5245     arm_target_insn = NULL;
5246   }
5247
5248   output_return_instruction (NULL, FALSE);
5249   return \"b%?\\t%a1\";
5250 }"
5251 [(set (attr "conds")
5252       (if_then_else (eq_attr "cpu" "arm6")
5253                     (const_string "clob")
5254                     (const_string "nocond")))
5255  (set_attr "length" "8")])
5256
5257 ;; As above but when this function is not void, we must be returning the
5258 ;; result of the called subroutine.
5259
5260 (define_peephole
5261   [(parallel [(set (match_operand 0 "s_register_operand" "=rf")
5262                    (call (mem:SI (match_operand:SI 1 "" "i"))
5263                          (match_operand:SI 2 "general_operand" "g")))
5264               (clobber (reg:SI 14))])
5265    (use (match_dup 0))
5266    (return)]
5267   "(GET_CODE (operands[1]) == SYMBOL_REF && USE_RETURN_INSN
5268     && !get_frame_size () && !current_function_calls_alloca
5269     && !frame_pointer_needed && !current_function_args_size)"
5270   "*
5271 {
5272   extern rtx arm_target_insn;
5273   extern int arm_ccfsm_state, arm_current_cc;
5274
5275   if (arm_ccfsm_state && arm_target_insn && INSN_DELETED_P (arm_target_insn))
5276   {
5277     arm_current_cc ^= 1;
5278     output_return_instruction (NULL, TRUE);
5279     arm_ccfsm_state = 0;
5280     arm_target_insn = NULL;
5281   }
5282
5283   output_return_instruction (NULL, FALSE);
5284   return \"b%?\\t%a1\";
5285 }"
5286 [(set (attr "conds")
5287       (if_then_else (eq_attr "cpu" "arm6")
5288                     (const_string "clob")
5289                     (const_string "nocond")))
5290  (set_attr "length" "8")])
5291
5292 ;; If calling a subroutine and then jumping back to somewhere else, but not
5293 ;; too far away, then we can set the link register with the branch address
5294 ;; and jump direct to the subroutine.  On return from the subroutine
5295 ;; execution continues at the branch; this avoids a prefetch stall.
5296 ;; We use the length attribute (via short_branch ()) to establish whether or
5297 ;; not this is possible, this is the same asthe sparc does.
5298
5299 (define_peephole
5300   [(parallel[(call (mem:SI (match_operand:SI 0 "" "i"))
5301                    (match_operand:SI 1 "general_operand" "g"))
5302              (clobber (reg:SI 14))])
5303    (set (pc)
5304         (label_ref (match_operand 2 "" "")))]
5305   "0 && GET_CODE (operands[0]) == SYMBOL_REF
5306    && short_branch (INSN_UID (insn), INSN_UID (operands[2]))
5307    && arm_insn_not_targeted (insn)"
5308   "*
5309 {
5310   int backward = arm_backwards_branch (INSN_UID (insn),
5311                                        INSN_UID (operands[2]));
5312
5313 #if 0
5314   /* Putting this in means that TARGET_6 code will ONLY run on an arm6 or
5315    * above, leaving it out means that the code will still run on an arm 2 or 3
5316    */
5317   if (TARGET_6)
5318     {
5319       if (backward)
5320         output_asm_insn (\"sub%?\\t%|lr, %|pc, #(8 + . -%l2)\", operands);
5321       else
5322         output_asm_insn (\"add%?\\t%|lr, %|pc, #(%l2 - . -8)\", operands);
5323     }
5324   else
5325 #endif
5326     {
5327       output_asm_insn (\"mov%?\\t%|lr, %|pc\\t%@ protect cc\", operands);
5328       if (backward)
5329         output_asm_insn (\"sub%?\\t%|lr, %|lr, #(4 + . -%l2)\", operands);
5330       else
5331         output_asm_insn (\"add%?\\t%|lr, %|lr, #(%l2 - . -4)\", operands);
5332     }
5333   return \"b%?\\t%a0\";
5334 }"
5335 [(set (attr "conds")
5336       (if_then_else (eq_attr "cpu" "arm6")
5337                     (const_string "clob")
5338                     (const_string "nocond")))
5339  (set (attr "length")
5340       (if_then_else (eq_attr "cpu" "arm6")
5341                     (const_int 8)
5342                     (const_int 12)))])
5343
5344 (define_peephole
5345   [(parallel[(set (match_operand:SI 0 "s_register_operand" "=r")
5346                   (call (mem:SI (match_operand:SI 1 "" "i"))
5347                         (match_operand:SI 2 "general_operand" "g")))
5348              (clobber (reg:SI 14))])
5349    (set (pc)
5350         (label_ref (match_operand 3 "" "")))]
5351   "0 && GET_CODE (operands[0]) == SYMBOL_REF
5352    && short_branch (INSN_UID (insn), INSN_UID (operands[3]))
5353    && arm_insn_not_targeted (insn)"
5354   "*
5355 {
5356   int backward = arm_backwards_branch (INSN_UID (insn),
5357                                        INSN_UID (operands[3]));
5358
5359 #if 0
5360   /* Putting this in means that TARGET_6 code will ONLY run on an arm6 or
5361    * above, leaving it out means that the code will still run on an arm 2 or 3
5362    */
5363   if (TARGET_6)
5364     {
5365       if (backward)
5366         output_asm_insn (\"sub%?\\t%|lr, %|pc, #(8 + . -%l3)\", operands);
5367       else
5368         output_asm_insn (\"add%?\\t%|lr, %|pc, #(%l3 - . -8)\", operands);
5369     }
5370   else
5371 #endif
5372     {
5373       output_asm_insn (\"mov%?\\t%|lr, %|pc\\t%@ protect cc\", operands);
5374       if (backward)
5375         output_asm_insn (\"sub%?\\t%|lr, %|lr, #(4 + . -%l3)\", operands);
5376       else
5377         output_asm_insn (\"add%?\\t%|lr, %|lr, #(%l3 - . -4)\", operands);
5378     }
5379   return \"b%?\\t%a1\";
5380 }"
5381 [(set (attr "conds")
5382       (if_then_else (eq_attr "cpu" "arm6")
5383                     (const_string "clob")
5384                     (const_string "nocond")))
5385  (set (attr "length")
5386       (if_then_else (eq_attr "cpu" "arm6")
5387                     (const_int 8)
5388                     (const_int 12)))])
5389
5390 (define_split
5391   [(set (pc)
5392         (if_then_else (match_operator 0 "comparison_operator"
5393                        [(match_operator:SI 1 "shift_operator"
5394                          [(match_operand:SI 2 "s_register_operand" "r")
5395                           (match_operand:SI 3 "reg_or_int_operand" "rM")])
5396                         (match_operand:SI 4 "s_register_operand" "r")])
5397                       (label_ref (match_operand 5 "" ""))
5398                       (pc)))
5399    (clobber (reg 24))]
5400   ""
5401   [(set (reg:CC 24)
5402         (compare:CC (match_dup 4)
5403                     (match_op_dup 1 [(match_dup 2) (match_dup 3)])))
5404    (set (pc)
5405         (if_then_else (match_op_dup 0 [(reg 24) (const_int 0)])
5406                       (label_ref (match_dup 5))
5407                       (pc)))]
5408   "
5409   operands[0] = gen_rtx (swap_condition (GET_CODE (operands[0])), VOIDmode,
5410                          operands[1], operands[2]);
5411 ")
5412
5413 (define_split
5414   [(set (match_operand:SI 0 "s_register_operand" "")
5415         (and:SI (ge:SI (match_operand:SI 1 "s_register_operand" "")
5416                        (const_int 0))
5417                 (neg:SI (match_operator:SI 2 "comparison_operator"
5418                          [(match_operand:SI 3 "s_register_operand" "")
5419                           (match_operand:SI 4 "arm_rhs_operand" "")]))))
5420    (clobber (match_operand:SI 5 "s_register_operand" ""))]
5421   ""
5422   [(set (match_dup 5) (not:SI (ashiftrt:SI (match_dup 1) (const_int 31))))
5423    (set (match_dup 0) (and:SI (match_op_dup 2 [(match_dup 3) (match_dup 4)])
5424                               (match_dup 5)))]
5425   "")
5426
5427 ;; This pattern can be used because cc_noov mode implies that the following
5428 ;; branch will be an equality (EQ or NE), so the sign extension is not
5429 ;; needed.  Combine doesn't eliminate these because by the time it sees the
5430 ;; branch it no-longer knows that the data came from memory.
5431
5432 (define_insn ""
5433   [(set (reg:CC_NOOV 24)
5434         (compare:CC_NOOV
5435          (ashift:SI (subreg:SI (match_operand:QI 0 "memory_operand" "m") 0)
5436                     (const_int 24))
5437          (match_operand 1 "immediate_operand" "I")))
5438    (clobber (match_scratch:SI 2 "=r"))]
5439   "((unsigned long) INTVAL (operands[1]))
5440    == (((unsigned long) INTVAL (operands[1])) >> 24) << 24"
5441   "*
5442   operands[1] = GEN_INT (((unsigned long) INTVAL (operands[1])) >> 24);
5443   output_asm_insn (\"ldr%?b\\t%2, %0\", operands);
5444   output_asm_insn (\"cmp%?\\t%2, %1\", operands);
5445   return \"\";
5446 "
5447 [(set_attr "conds" "set")
5448  (set_attr "length" "8")
5449  (set_attr "type" "load")])
5450
5451 (define_expand "prologue"
5452   [(clobber (const_int 0))]
5453   ""
5454   "
5455   arm_expand_prologue ();
5456   DONE;
5457 ")
5458
5459 ;; This split is only used during output to reduce the number of patterns
5460 ;; that need assembler instructions adding to them.  We allowed the setting
5461 ;; of the conditions to be implicit during rtl generation so that
5462 ;; the conditional compare patterns would work.  However this conflicts to
5463 ;; some extend with the conditional data operations, so we have to split them
5464 ;; up again here.
5465
5466 (define_split
5467   [(set (match_operand:SI 0 "s_register_operand" "")
5468         (if_then_else:SI (match_operator 1 "comparison_operator"
5469                           [(match_operand 2 "" "") (match_operand 3 "" "")])
5470                          (match_operand 4 "" "")
5471                          (match_operand 5 "" "")))
5472    (clobber (reg 24))]
5473   "reload_completed"
5474   [(set (match_dup 6) (match_dup 7))
5475    (set (match_dup 0)
5476         (if_then_else:SI (match_op_dup 1 [(match_dup 6) (const_int 0)])
5477                          (match_dup 4)
5478                          (match_dup 5)))]
5479   "
5480 {
5481   enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]), operands[2],
5482                                            operands[3]);
5483
5484   operands[6] = gen_rtx (REG, mode, 24);
5485   operands[7] = gen_rtx (COMPARE, mode, operands[2], operands[3]);
5486 }
5487 ")
5488
5489
5490 (define_insn ""
5491   [(set (match_operand:SI 0 "s_register_operand" "=r,r")
5492         (if_then_else:SI (match_operator 4 "comparison_operator"
5493                           [(match_operand 3 "reversible_cc_register" "")
5494                            (const_int 0)])
5495                          (match_operand:SI 1 "arm_rhs_operand" "0,?rI")
5496                          (not:SI
5497                           (match_operand:SI 2 "s_register_operand" "r,r"))))]
5498   ""
5499   "@
5500    mvn%D4\\t%0, %2
5501    mov%d4\\t%0, %1\;mvn%D4\\t%0, %2"
5502 [(set_attr "conds" "use")
5503  (set_attr "length" "4,8")])
5504
5505 ;; The next two patterns occur when an AND operation is followed by a
5506 ;; scc insn sequence
5507
5508 (define_insn ""
5509   [(set (match_operand:SI 0 "s_register_operand" "=r")
5510         (sign_extract:SI (match_operand:SI 1 "s_register_operand" "r")
5511                          (const_int 1)
5512                          (match_operand:SI 2 "immediate_operand" "n")))]
5513   ""
5514   "*
5515   operands[2] = GEN_INT (1 << INTVAL (operands[2]));
5516   output_asm_insn (\"ands\\t%0, %1, %2\", operands);
5517   return \"mvnne\\t%0, #0\";
5518 "
5519 [(set_attr "conds" "clob")
5520  (set_attr "length" "8")])
5521
5522 (define_insn ""
5523   [(set (match_operand:SI 0 "s_register_operand" "=r")
5524         (not:SI
5525          (sign_extract:SI (match_operand:SI 1 "s_register_operand" "r")
5526                           (const_int 1)
5527                           (match_operand:SI 2 "immediate_operand" "n"))))]
5528   ""
5529   "*
5530   operands[2] = GEN_INT (1 << INTVAL (operands[2]));
5531   output_asm_insn (\"tst\\t%1, %2\", operands);
5532   output_asm_insn (\"mvneq\\t%0, #0\", operands);
5533   return \"movne\\t%0, #0\";
5534 "
5535 [(set_attr "conds" "clob")
5536  (set_attr "length" "12")])
5537
5538 ;; Push multiple registers to the stack.  The first register is in the
5539 ;; unspec part of the insn; subsequent registers are in parallel (use ...)
5540 ;; expressions.
5541 (define_insn ""
5542   [(match_parallel 2 "multi_register_push"
5543     [(set (match_operand:BLK 0 "memory_operand" "=m")
5544           (unspec:BLK [(match_operand:SI 1 "s_register_operand" "r")] 2))])]
5545   ""
5546   "*
5547 {
5548   char pattern[100];
5549   int i;
5550   extern int lr_save_eliminated;
5551
5552   if (lr_save_eliminated)
5553     {
5554       if (XVECLEN (operands[2], 0) > 1)
5555         abort ();
5556       return \"\";
5557     }
5558   strcpy (pattern, \"stmfd\\t%m0!, {%|%1\");
5559   for (i = 1; i < XVECLEN (operands[2], 0); i++)
5560     {
5561       strcat (pattern, \", %|\");
5562       strcat (pattern, reg_names[REGNO (XEXP (XVECEXP (operands[2], 0, i),
5563                                               0))]);
5564     }
5565   strcat (pattern, \"}\");
5566   output_asm_insn (pattern, operands);
5567   return \"\";
5568 }"
5569 [(set_attr "type" "store4")])