gcc/config/pa/pa.md

   1 ;;- Machine description for HP PA-RISC architecture for GCC compiler
   2 ;;   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3 ;;   2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   4 ;;   Contributed by the Center for Software Science at the University
   5 ;;   of Utah.
   6
   7 ;; This file is part of GCC.
   8
   9 ;; GCC 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 ;; GCC 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 GCC; see the file COPYING.  If not, write to
  21 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  22 ;; Boston, MA 02110-1301, USA.
  23
  24 ;; This gcc Version 2 machine description is inspired by sparc.md and
  25 ;; mips.md.
  26
  27 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  28
  29 ;; Uses of UNSPEC in this file:
  30
  31 (define_constants
  32   [(UNSPEC_CFFC         0)      ; canonicalize_funcptr_for_compare
  33    (UNSPEC_GOTO         1)      ; indirect_goto
  34    (UNSPEC_DLTIND14R    2)      ;
  35    (UNSPEC_TP           3)
  36    (UNSPEC_TLSGD        4)
  37    (UNSPEC_TLSLDM       5)
  38    (UNSPEC_TLSLDO       6)
  39    (UNSPEC_TLSLDBASE    7)
  40    (UNSPEC_TLSIE        8)
  41    (UNSPEC_TLSLE        9)
  42   ])
  43
  44 ;; UNSPEC_VOLATILE:
  45
  46 (define_constants
  47   [(UNSPECV_BLOCKAGE    0)      ; blockage
  48    (UNSPECV_DCACHE      1)      ; dcacheflush
  49    (UNSPECV_ICACHE      2)      ; icacheflush
  50    (UNSPECV_OPC         3)      ; outline_prologue_call
  51    (UNSPECV_OEC         4)      ; outline_epilogue_call
  52    (UNSPECV_LONGJMP     5)      ; builtin_longjmp
  53   ])
  54
  55 ;; Maximum pc-relative branch offsets.
  56
  57 ;; These numbers are a bit smaller than the maximum allowable offsets
  58 ;; so that a few instructions may be inserted before the actual branch.
  59
  60 (define_constants
  61   [(MAX_12BIT_OFFSET     8184)  ; 12-bit branch
  62    (MAX_17BIT_OFFSET   262100)  ; 17-bit branch
  63   ])
  64
  65 ;; Insn type.  Used to default other attribute values.
  66
  67 ;; type "unary" insns have one input operand (1) and one output operand (0)
  68 ;; type "binary" insns have two input operands (1,2) and one output (0)
  69
  70 (define_attr "type"
  71   "move,unary,binary,shift,nullshift,compare,load,store,uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,fpload,fpstore,fpalu,fpcc,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,multi,milli,parallel_branch"
  72   (const_string "binary"))
  73
  74 (define_attr "pa_combine_type"
  75   "fmpy,faddsub,uncond_branch,addmove,none"
  76   (const_string "none"))
  77
  78 ;; Processor type (for scheduling, not code generation) -- this attribute
  79 ;; must exactly match the processor_type enumeration in pa.h.
  80 ;;
  81 ;; FIXME: Add 800 scheduling for completeness?
  82
  83 (define_attr "cpu" "700,7100,7100LC,7200,7300,8000" (const (symbol_ref "pa_cpu_attr")))
  84
  85 ;; Length (in # of bytes).
  86 (define_attr "length" ""
  87   (cond [(eq_attr "type" "load,fpload")
  88          (if_then_else (match_operand 1 "symbolic_memory_operand" "")
  89                        (const_int 8) (const_int 4))
  90
  91          (eq_attr "type" "store,fpstore")
  92          (if_then_else (match_operand 0 "symbolic_memory_operand" "")
  93                        (const_int 8) (const_int 4))
  94
  95          (eq_attr "type" "binary,shift,nullshift")
  96          (if_then_else (match_operand 2 "arith_operand" "")
  97                        (const_int 4) (const_int 12))
  98
  99          (eq_attr "type" "move,unary,shift,nullshift")
 100          (if_then_else (match_operand 1 "arith_operand" "")
 101                        (const_int 4) (const_int 8))]
 102
 103         (const_int 4)))
 104
 105 (define_asm_attributes
 106   [(set_attr "length" "4")
 107    (set_attr "type" "multi")])
 108
 109 ;; Attributes for instruction and branch scheduling
 110
 111 ;; For conditional branches.
 112 (define_attr "in_branch_delay" "false,true"
 113   (if_then_else (and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
 114                      (eq_attr "length" "4"))
 115                 (const_string "true")
 116                 (const_string "false")))
 117
 118 ;; Disallow instructions which use the FPU since they will tie up the FPU
 119 ;; even if the instruction is nullified.
 120 (define_attr "in_nullified_branch_delay" "false,true"
 121   (if_then_else (and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,parallel_branch")
 122                      (eq_attr "length" "4"))
 123                 (const_string "true")
 124                 (const_string "false")))
 125
 126 ;; For calls and millicode calls.  Allow unconditional branches in the
 127 ;; delay slot.
 128 (define_attr "in_call_delay" "false,true"
 129   (cond [(and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
 130               (eq_attr "length" "4"))
 131            (const_string "true")
 132          (eq_attr "type" "uncond_branch")
 133            (if_then_else (ne (symbol_ref "TARGET_JUMP_IN_DELAY")
 134                              (const_int 0))
 135                          (const_string "true")
 136                          (const_string "false"))]
 137         (const_string "false")))
 138
 139
 140 ;; Call delay slot description.
 141 (define_delay (eq_attr "type" "call")
 142   [(eq_attr "in_call_delay" "true") (nil) (nil)])
 143
 144 ;; Millicode call delay slot description.
 145 (define_delay (eq_attr "type" "milli")
 146   [(eq_attr "in_call_delay" "true") (nil) (nil)])
 147
 148 ;; Return and other similar instructions.
 149 (define_delay (eq_attr "type" "btable_branch,branch,parallel_branch")
 150   [(eq_attr "in_branch_delay" "true") (nil) (nil)])
 151
 152 ;; Floating point conditional branch delay slot description.
 153 (define_delay (eq_attr "type" "fbranch")
 154   [(eq_attr "in_branch_delay" "true")
 155    (eq_attr "in_nullified_branch_delay" "true")
 156    (nil)])
 157
 158 ;; Integer conditional branch delay slot description.
 159 ;; Nullification of conditional branches on the PA is dependent on the
 160 ;; direction of the branch.  Forward branches nullify true and
 161 ;; backward branches nullify false.  If the direction is unknown
 162 ;; then nullification is not allowed.
 163 (define_delay (eq_attr "type" "cbranch")
 164   [(eq_attr "in_branch_delay" "true")
 165    (and (eq_attr "in_nullified_branch_delay" "true")
 166         (attr_flag "forward"))
 167    (and (eq_attr "in_nullified_branch_delay" "true")
 168         (attr_flag "backward"))])
 169
 170 (define_delay (and (eq_attr "type" "uncond_branch")
 171                    (eq (symbol_ref "following_call (insn)")
 172                        (const_int 0)))
 173   [(eq_attr "in_branch_delay" "true") (nil) (nil)])
 174
 175 ;; Memory. Disregarding Cache misses, the Mustang memory times are:
 176 ;; load: 2, fpload: 3
 177 ;; store, fpstore: 3, no D-cache operations should be scheduled.
 178
 179 ;; The Timex (aka 700) has two floating-point units: ALU, and MUL/DIV/SQRT.
 180 ;; Timings:
 181 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
 182 ;; fcpy         3       ALU     2
 183 ;; fabs         3       ALU     2
 184 ;; fadd         3       ALU     2
 185 ;; fsub         3       ALU     2
 186 ;; fcmp         3       ALU     2
 187 ;; fcnv         3       ALU     2
 188 ;; fmpyadd      3       ALU,MPY 2
 189 ;; fmpysub      3       ALU,MPY 2
 190 ;; fmpycfxt     3       ALU,MPY 2
 191 ;; fmpy         3       MPY     2
 192 ;; fmpyi        3       MPY     2
 193 ;; fdiv,sgl     10      MPY     10
 194 ;; fdiv,dbl     12      MPY     12
 195 ;; fsqrt,sgl    14      MPY     14
 196 ;; fsqrt,dbl    18      MPY     18
 197 ;;
 198 ;; We don't model fmpyadd/fmpysub properly as those instructions
 199 ;; keep both the FP ALU and MPY units busy.  Given that these
 200 ;; processors are obsolete, I'm not going to spend the time to
 201 ;; model those instructions correctly.
 202
 203 (define_automaton "pa700")
 204 (define_cpu_unit "dummy_700,mem_700,fpalu_700,fpmpy_700" "pa700")
 205
 206 (define_insn_reservation "W0" 4
 207   (and (eq_attr "type" "fpcc")
 208        (eq_attr "cpu" "700"))
 209   "fpalu_700*2")
 210
 211 (define_insn_reservation "W1" 3
 212   (and (eq_attr "type" "fpalu")
 213        (eq_attr "cpu" "700"))
 214   "fpalu_700*2")
 215
 216 (define_insn_reservation "W2" 3
 217   (and (eq_attr "type" "fpmulsgl,fpmuldbl")
 218        (eq_attr "cpu" "700"))
 219   "fpmpy_700*2")
 220
 221 (define_insn_reservation "W3" 10
 222   (and (eq_attr "type" "fpdivsgl")
 223        (eq_attr "cpu" "700"))
 224   "fpmpy_700*10")
 225
 226 (define_insn_reservation "W4" 12
 227   (and (eq_attr "type" "fpdivdbl")
 228        (eq_attr "cpu" "700"))
 229   "fpmpy_700*12")
 230
 231 (define_insn_reservation "W5" 14
 232   (and (eq_attr "type" "fpsqrtsgl")
 233        (eq_attr "cpu" "700"))
 234   "fpmpy_700*14")
 235
 236 (define_insn_reservation "W6" 18
 237   (and (eq_attr "type" "fpsqrtdbl")
 238        (eq_attr "cpu" "700"))
 239   "fpmpy_700*18")
 240
 241 (define_insn_reservation "W7" 2
 242   (and (eq_attr "type" "load")
 243        (eq_attr "cpu" "700"))
 244   "mem_700")
 245
 246 (define_insn_reservation "W8" 2
 247   (and (eq_attr "type" "fpload")
 248        (eq_attr "cpu" "700"))
 249   "mem_700")
 250
 251 (define_insn_reservation "W9" 3
 252   (and (eq_attr "type" "store")
 253        (eq_attr "cpu" "700"))
 254   "mem_700*3")
 255
 256 (define_insn_reservation "W10" 3
 257   (and (eq_attr "type" "fpstore")
 258        (eq_attr "cpu" "700"))
 259   "mem_700*3")
 260
 261 (define_insn_reservation "W11" 1
 262   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,load,fpload,store,fpstore")
 263        (eq_attr "cpu" "700"))
 264   "dummy_700")
 265
 266 ;; We have a bypass for all computations in the FP unit which feed an
 267 ;; FP store as long as the sizes are the same.
 268 (define_bypass 2 "W1,W2" "W10" "hppa_fpstore_bypass_p")
 269 (define_bypass 9 "W3" "W10" "hppa_fpstore_bypass_p")
 270 (define_bypass 11 "W4" "W10" "hppa_fpstore_bypass_p")
 271 (define_bypass 13 "W5" "W10" "hppa_fpstore_bypass_p")
 272 (define_bypass 17 "W6" "W10" "hppa_fpstore_bypass_p")
 273
 274 ;; We have an "anti-bypass" for FP loads which feed an FP store.
 275 (define_bypass 4 "W8" "W10" "hppa_fpstore_bypass_p")
 276
 277 ;; Function units for the 7100 and 7150.  The 7100/7150 can dual-issue
 278 ;; floating point computations with non-floating point computations (fp loads
 279 ;; and stores are not fp computations).
 280 ;;
 281 ;; Memory. Disregarding Cache misses, memory loads take two cycles; stores also
 282 ;; take two cycles, during which no Dcache operations should be scheduled.
 283 ;; Any special cases are handled in pa_adjust_cost.  The 7100, 7150 and 7100LC
 284 ;; all have the same memory characteristics if one disregards cache misses.
 285 ;;
 286 ;; The 7100/7150 has three floating-point units: ALU, MUL, and DIV.
 287 ;; There's no value in modeling the ALU and MUL separately though
 288 ;; since there can never be a functional unit conflict given the
 289 ;; latency and issue rates for those units.
 290 ;;
 291 ;; Timings:
 292 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
 293 ;; fcpy         2       ALU     1
 294 ;; fabs         2       ALU     1
 295 ;; fadd         2       ALU     1
 296 ;; fsub         2       ALU     1
 297 ;; fcmp         2       ALU     1
 298 ;; fcnv         2       ALU     1
 299 ;; fmpyadd      2       ALU,MPY 1
 300 ;; fmpysub      2       ALU,MPY 1
 301 ;; fmpycfxt     2       ALU,MPY 1
 302 ;; fmpy         2       MPY     1
 303 ;; fmpyi        2       MPY     1
 304 ;; fdiv,sgl     8       DIV     8
 305 ;; fdiv,dbl     15      DIV     15
 306 ;; fsqrt,sgl    8       DIV     8
 307 ;; fsqrt,dbl    15      DIV     15
 308
 309 (define_automaton "pa7100")
 310 (define_cpu_unit "i_7100, f_7100,fpmac_7100,fpdivsqrt_7100,mem_7100" "pa7100")
 311
 312 (define_insn_reservation "X0" 2
 313   (and (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
 314        (eq_attr "cpu" "7100"))
 315   "f_7100,fpmac_7100")
 316
 317 (define_insn_reservation "X1" 8
 318   (and (eq_attr "type" "fpdivsgl,fpsqrtsgl")
 319        (eq_attr "cpu" "7100"))
 320   "f_7100+fpdivsqrt_7100,fpdivsqrt_7100*7")
 321
 322 (define_insn_reservation "X2" 15
 323   (and (eq_attr "type" "fpdivdbl,fpsqrtdbl")
 324        (eq_attr "cpu" "7100"))
 325   "f_7100+fpdivsqrt_7100,fpdivsqrt_7100*14")
 326
 327 (define_insn_reservation "X3" 2
 328   (and (eq_attr "type" "load")
 329        (eq_attr "cpu" "7100"))
 330   "i_7100+mem_7100")
 331
 332 (define_insn_reservation "X4" 2
 333   (and (eq_attr "type" "fpload")
 334        (eq_attr "cpu" "7100"))
 335   "i_7100+mem_7100")
 336
 337 (define_insn_reservation "X5" 2
 338   (and (eq_attr "type" "store")
 339        (eq_attr "cpu" "7100"))
 340   "i_7100+mem_7100,mem_7100")
 341
 342 (define_insn_reservation "X6" 2
 343   (and (eq_attr "type" "fpstore")
 344        (eq_attr "cpu" "7100"))
 345   "i_7100+mem_7100,mem_7100")
 346
 347 (define_insn_reservation "X7" 1
 348   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl,load,fpload,store,fpstore")
 349        (eq_attr "cpu" "7100"))
 350   "i_7100")
 351
 352 ;; We have a bypass for all computations in the FP unit which feed an
 353 ;; FP store as long as the sizes are the same.
 354 (define_bypass 1 "X0" "X6" "hppa_fpstore_bypass_p")
 355 (define_bypass 7 "X1" "X6" "hppa_fpstore_bypass_p")
 356 (define_bypass 14 "X2" "X6" "hppa_fpstore_bypass_p")
 357
 358 ;; We have an "anti-bypass" for FP loads which feed an FP store.
 359 (define_bypass 3 "X4" "X6" "hppa_fpstore_bypass_p")
 360
 361 ;; The 7100LC has three floating-point units: ALU, MUL, and DIV.
 362 ;; There's no value in modeling the ALU and MUL separately though
 363 ;; since there can never be a functional unit conflict that
 364 ;; can be avoided given the latency, issue rates and mandatory
 365 ;; one cycle cpu-wide lock for a double precision fp multiply.
 366 ;;
 367 ;; Timings:
 368 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
 369 ;; fcpy         2       ALU     1
 370 ;; fabs         2       ALU     1
 371 ;; fadd         2       ALU     1
 372 ;; fsub         2       ALU     1
 373 ;; fcmp         2       ALU     1
 374 ;; fcnv         2       ALU     1
 375 ;; fmpyadd,sgl  2       ALU,MPY 1
 376 ;; fmpyadd,dbl  3       ALU,MPY 2
 377 ;; fmpysub,sgl  2       ALU,MPY 1
 378 ;; fmpysub,dbl  3       ALU,MPY 2
 379 ;; fmpycfxt,sgl 2       ALU,MPY 1
 380 ;; fmpycfxt,dbl 3       ALU,MPY 2
 381 ;; fmpy,sgl     2       MPY     1
 382 ;; fmpy,dbl     3       MPY     2
 383 ;; fmpyi        3       MPY     2
 384 ;; fdiv,sgl     8       DIV     8
 385 ;; fdiv,dbl     15      DIV     15
 386 ;; fsqrt,sgl    8       DIV     8
 387 ;; fsqrt,dbl    15      DIV     15
 388 ;;
 389 ;; The PA7200 is just like the PA7100LC except that there is
 390 ;; no store-store penalty.
 391 ;;
 392 ;; The PA7300 is just like the PA7200 except that there is
 393 ;; no store-load penalty.
 394 ;;
 395 ;; Note there are some aspects of the 7100LC we are not modeling
 396 ;; at the moment.  I'll be reviewing the 7100LC scheduling info
 397 ;; shortly and updating this description.
 398 ;;
 399 ;;   load-load pairs
 400 ;;   store-store pairs
 401 ;;   other issue modeling
 402
 403 (define_automaton "pa7100lc")
 404 (define_cpu_unit "i0_7100lc, i1_7100lc, f_7100lc" "pa7100lc")
 405 (define_cpu_unit "fpmac_7100lc" "pa7100lc")
 406 (define_cpu_unit "mem_7100lc" "pa7100lc")
 407
 408 ;; Double precision multiplies lock the entire CPU for one
 409 ;; cycle.  There is no way to avoid this lock and trying to
 410 ;; schedule around the lock is pointless and thus there is no
 411 ;; value in trying to model this lock.
 412 ;;
 413 ;; Not modeling the lock allows us to treat fp multiplies just
 414 ;; like any other FP alu instruction.  It allows for a smaller
 415 ;; DFA and may reduce register pressure.
 416 (define_insn_reservation "Y0" 2
 417   (and (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
 418        (eq_attr "cpu" "7100LC,7200,7300"))
 419   "f_7100lc,fpmac_7100lc")
 420
 421 ;; fp division and sqrt instructions lock the entire CPU for
 422 ;; 7 cycles (single precision) or 14 cycles (double precision).
 423 ;; There is no way to avoid this lock and trying to schedule
 424 ;; around the lock is pointless and thus there is no value in
 425 ;; trying to model this lock.  Not modeling the lock allows
 426 ;; for a smaller DFA and may reduce register pressure.
 427 (define_insn_reservation "Y1" 1
 428   (and (eq_attr "type" "fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl")
 429        (eq_attr "cpu" "7100LC,7200,7300"))
 430   "f_7100lc")
 431
 432 (define_insn_reservation "Y2" 2
 433   (and (eq_attr "type" "load")
 434        (eq_attr "cpu" "7100LC,7200,7300"))
 435   "i1_7100lc+mem_7100lc")
 436
 437 (define_insn_reservation "Y3" 2
 438   (and (eq_attr "type" "fpload")
 439        (eq_attr "cpu" "7100LC,7200,7300"))
 440   "i1_7100lc+mem_7100lc")
 441
 442 (define_insn_reservation "Y4" 2
 443   (and (eq_attr "type" "store")
 444        (eq_attr "cpu" "7100LC"))
 445   "i1_7100lc+mem_7100lc,mem_7100lc")
 446
 447 (define_insn_reservation "Y5" 2
 448   (and (eq_attr "type" "fpstore")
 449        (eq_attr "cpu" "7100LC"))
 450   "i1_7100lc+mem_7100lc,mem_7100lc")
 451
 452 (define_insn_reservation "Y6" 1
 453   (and (eq_attr "type" "shift,nullshift")
 454        (eq_attr "cpu" "7100LC,7200,7300"))
 455   "i1_7100lc")
 456
 457 (define_insn_reservation "Y7" 1
 458   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl,load,fpload,store,fpstore,shift,nullshift")
 459        (eq_attr "cpu" "7100LC,7200,7300"))
 460   "(i0_7100lc|i1_7100lc)")
 461
 462 ;; The 7200 has a store-load penalty
 463 (define_insn_reservation "Y8" 2
 464   (and (eq_attr "type" "store")
 465        (eq_attr "cpu" "7200"))
 466   "i1_7100lc,mem_7100lc")
 467
 468 (define_insn_reservation "Y9" 2
 469   (and (eq_attr "type" "fpstore")
 470        (eq_attr "cpu" "7200"))
 471   "i1_7100lc,mem_7100lc")
 472
 473 ;; The 7300 has no penalty for store-store or store-load
 474 (define_insn_reservation "Y10" 2
 475   (and (eq_attr "type" "store")
 476        (eq_attr "cpu" "7300"))
 477   "i1_7100lc")
 478
 479 (define_insn_reservation "Y11" 2
 480   (and (eq_attr "type" "fpstore")
 481        (eq_attr "cpu" "7300"))
 482   "i1_7100lc")
 483
 484 ;; We have an "anti-bypass" for FP loads which feed an FP store.
 485 (define_bypass 3 "Y3" "Y5,Y9,Y11" "hppa_fpstore_bypass_p")
 486
 487 ;; Scheduling for the PA8000 is somewhat different than scheduling for a
 488 ;; traditional architecture.
 489 ;;
 490 ;; The PA8000 has a large (56) entry reorder buffer that is split between
 491 ;; memory and non-memory operations.
 492 ;;
 493 ;; The PA8000 can issue two memory and two non-memory operations per cycle to
 494 ;; the function units, with the exception of branches and multi-output
 495 ;; instructions.  The PA8000 can retire two non-memory operations per cycle
 496 ;; and two memory operations per cycle, only one of which may be a store.
 497 ;;
 498 ;; Given the large reorder buffer, the processor can hide most latencies.
 499 ;; According to HP, they've got the best results by scheduling for retirement
 500 ;; bandwidth with limited latency scheduling for floating point operations.
 501 ;; Latency for integer operations and memory references is ignored.
 502 ;;
 503 ;;
 504 ;; We claim floating point operations have a 2 cycle latency and are
 505 ;; fully pipelined, except for div and sqrt which are not pipelined and
 506 ;; take from 17 to 31 cycles to complete.
 507 ;;
 508 ;; It's worth noting that there is no way to saturate all the functional
 509 ;; units on the PA8000 as there is not enough issue bandwidth.
 510
 511 (define_automaton "pa8000")
 512 (define_cpu_unit "inm0_8000, inm1_8000, im0_8000, im1_8000" "pa8000")
 513 (define_cpu_unit "rnm0_8000, rnm1_8000, rm0_8000, rm1_8000" "pa8000")
 514 (define_cpu_unit "store_8000" "pa8000")
 515 (define_cpu_unit "f0_8000, f1_8000" "pa8000")
 516 (define_cpu_unit "fdivsqrt0_8000, fdivsqrt1_8000" "pa8000")
 517 (define_reservation "inm_8000" "inm0_8000 | inm1_8000")
 518 (define_reservation "im_8000" "im0_8000 | im1_8000")
 519 (define_reservation "rnm_8000" "rnm0_8000 | rnm1_8000")
 520 (define_reservation "rm_8000" "rm0_8000 | rm1_8000")
 521 (define_reservation "f_8000" "f0_8000 | f1_8000")
 522 (define_reservation "fdivsqrt_8000" "fdivsqrt0_8000 | fdivsqrt1_8000")
 523
 524 ;; We can issue any two memops per cycle, but we can only retire
 525 ;; one memory store per cycle.  We assume that the reorder buffer
 526 ;; will hide any memory latencies per HP's recommendation.
 527 (define_insn_reservation "Z0" 0
 528   (and
 529     (eq_attr "type" "load,fpload")
 530     (eq_attr "cpu" "8000"))
 531   "im_8000,rm_8000")
 532
 533 (define_insn_reservation "Z1" 0
 534   (and
 535     (eq_attr "type" "store,fpstore")
 536     (eq_attr "cpu" "8000"))
 537   "im_8000,rm_8000+store_8000")
 538
 539 ;; We can issue and retire two non-memory operations per cycle with
 540 ;; a few exceptions (branches).  This group catches those we want
 541 ;; to assume have zero latency.
 542 (define_insn_reservation "Z2" 0
 543   (and
 544     (eq_attr "type" "!load,fpload,store,fpstore,uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch,fpcc,fpalu,fpmulsgl,fpmuldbl,fpsqrtsgl,fpsqrtdbl,fpdivsgl,fpdivdbl")
 545     (eq_attr "cpu" "8000"))
 546   "inm_8000,rnm_8000")
 547
 548 ;; Branches use both slots in the non-memory issue and
 549 ;; retirement unit.
 550 (define_insn_reservation "Z3" 0
 551   (and
 552     (eq_attr "type" "uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
 553     (eq_attr "cpu" "8000"))
 554   "inm0_8000+inm1_8000,rnm0_8000+rnm1_8000")
 555
 556 ;; We partial latency schedule the floating point units.
 557 ;; They can issue/retire two at a time in the non-memory
 558 ;; units.  We fix their latency at 2 cycles and they
 559 ;; are fully pipelined.
 560 (define_insn_reservation "Z4" 1
 561  (and
 562    (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
 563    (eq_attr "cpu" "8000"))
 564  "inm_8000,f_8000,rnm_8000")
 565
 566 ;; The fdivsqrt units are not pipelined and have a very long latency.
 567 ;; To keep the DFA from exploding, we do not show all the
 568 ;; reservations for the divsqrt unit.
 569 (define_insn_reservation "Z5" 17
 570  (and
 571    (eq_attr "type" "fpdivsgl,fpsqrtsgl")
 572    (eq_attr "cpu" "8000"))
 573  "inm_8000,fdivsqrt_8000*6,rnm_8000")
 574
 575 (define_insn_reservation "Z6" 31
 576  (and
 577    (eq_attr "type" "fpdivdbl,fpsqrtdbl")
 578    (eq_attr "cpu" "8000"))
 579  "inm_8000,fdivsqrt_8000*6,rnm_8000")
 580
 581 (include "predicates.md")
 582 \f
 583 ;; Compare instructions.
 584 ;; This controls RTL generation and register allocation.
 585
 586 ;; We generate RTL for comparisons and branches by having the cmpxx
 587 ;; patterns store away the operands.  Then, the scc and bcc patterns
 588 ;; emit RTL for both the compare and the branch.
 589 ;;
 590
 591 (define_expand "cmpdi"
 592   [(set (reg:CC 0)
 593         (compare:CC (match_operand:DI 0 "reg_or_0_operand" "")
 594                     (match_operand:DI 1 "register_operand" "")))]
 595   "TARGET_64BIT"
 596
 597   "
 598 {
 599  hppa_compare_op0 = operands[0];
 600  hppa_compare_op1 = operands[1];
 601  hppa_branch_type = CMP_SI;
 602  DONE;
 603 }")
 604
 605 (define_expand "cmpsi"
 606   [(set (reg:CC 0)
 607         (compare:CC (match_operand:SI 0 "reg_or_0_operand" "")
 608                     (match_operand:SI 1 "arith5_operand" "")))]
 609   ""
 610   "
 611 {
 612  hppa_compare_op0 = operands[0];
 613  hppa_compare_op1 = operands[1];
 614  hppa_branch_type = CMP_SI;
 615  DONE;
 616 }")
 617
 618 (define_expand "cmpsf"
 619   [(set (reg:CCFP 0)
 620         (compare:CCFP (match_operand:SF 0 "reg_or_0_operand" "")
 621                       (match_operand:SF 1 "reg_or_0_operand" "")))]
 622   "! TARGET_SOFT_FLOAT"
 623   "
 624 {
 625   hppa_compare_op0 = operands[0];
 626   hppa_compare_op1 = operands[1];
 627   hppa_branch_type = CMP_SF;
 628   DONE;
 629 }")
 630
 631 (define_expand "cmpdf"
 632   [(set (reg:CCFP 0)
 633       (compare:CCFP (match_operand:DF 0 "reg_or_0_operand" "")
 634                     (match_operand:DF 1 "reg_or_0_operand" "")))]
 635   "! TARGET_SOFT_FLOAT"
 636   "
 637 {
 638   hppa_compare_op0 = operands[0];
 639   hppa_compare_op1 = operands[1];
 640   hppa_branch_type = CMP_DF;
 641   DONE;
 642 }")
 643
 644 (define_insn ""
 645   [(set (reg:CCFP 0)
 646         (match_operator:CCFP 2 "comparison_operator"
 647                              [(match_operand:SF 0 "reg_or_0_operand" "fG")
 648                               (match_operand:SF 1 "reg_or_0_operand" "fG")]))]
 649   "! TARGET_SOFT_FLOAT"
 650   "fcmp,sgl,%Y2 %f0,%f1"
 651   [(set_attr "length" "4")
 652    (set_attr "type" "fpcc")])
 653
 654 (define_insn ""
 655   [(set (reg:CCFP 0)
 656         (match_operator:CCFP 2 "comparison_operator"
 657                              [(match_operand:DF 0 "reg_or_0_operand" "fG")
 658                               (match_operand:DF 1 "reg_or_0_operand" "fG")]))]
 659   "! TARGET_SOFT_FLOAT"
 660   "fcmp,dbl,%Y2 %f0,%f1"
 661   [(set_attr "length" "4")
 662    (set_attr "type" "fpcc")])
 663
 664 ;; Provide a means to emit the movccfp0 and movccfp1 optimization
 665 ;; placeholders.  This is necessary in rare situations when a
 666 ;; placeholder is re-emitted (see PR 8705).
 667
 668 (define_expand "movccfp"
 669   [(set (reg:CCFP 0)
 670         (match_operand 0 "const_int_operand" ""))]
 671   "! TARGET_SOFT_FLOAT"
 672   "
 673 {
 674   if ((unsigned HOST_WIDE_INT) INTVAL (operands[0]) > 1)
 675     FAIL;
 676 }")
 677
 678 ;; The following patterns are optimization placeholders.  In almost
 679 ;; all cases, the user of the condition code will be simplified and the
 680 ;; original condition code setting insn should be eliminated.
 681
 682 (define_insn "*movccfp0"
 683   [(set (reg:CCFP 0)
 684         (const_int 0))]
 685   "! TARGET_SOFT_FLOAT"
 686   "fcmp,dbl,= %%fr0,%%fr0"
 687   [(set_attr "length" "4")
 688    (set_attr "type" "fpcc")])
 689
 690 (define_insn "*movccfp1"
 691   [(set (reg:CCFP 0)
 692         (const_int 1))]
 693   "! TARGET_SOFT_FLOAT"
 694   "fcmp,dbl,!= %%fr0,%%fr0"
 695   [(set_attr "length" "4")
 696    (set_attr "type" "fpcc")])
 697
 698 ;; scc insns.
 699
 700 (define_expand "seq"
 701   [(set (match_operand:SI 0 "register_operand" "")
 702         (eq:SI (match_dup 1)
 703                (match_dup 2)))]
 704   "!TARGET_64BIT"
 705   "
 706 {
 707   /* fp scc patterns rarely match, and are not a win on the PA.  */
 708   if (hppa_branch_type != CMP_SI)
 709     FAIL;
 710   /* set up operands from compare.  */
 711   operands[1] = hppa_compare_op0;
 712   operands[2] = hppa_compare_op1;
 713   /* fall through and generate default code */
 714 }")
 715
 716 (define_expand "sne"
 717   [(set (match_operand:SI 0 "register_operand" "")
 718         (ne:SI (match_dup 1)
 719                (match_dup 2)))]
 720   "!TARGET_64BIT"
 721   "
 722 {
 723   /* fp scc patterns rarely match, and are not a win on the PA.  */
 724   if (hppa_branch_type != CMP_SI)
 725     FAIL;
 726   operands[1] = hppa_compare_op0;
 727   operands[2] = hppa_compare_op1;
 728 }")
 729
 730 (define_expand "slt"
 731   [(set (match_operand:SI 0 "register_operand" "")
 732         (lt:SI (match_dup 1)
 733                (match_dup 2)))]
 734   "!TARGET_64BIT"
 735   "
 736 {
 737   /* fp scc patterns rarely match, and are not a win on the PA.  */
 738   if (hppa_branch_type != CMP_SI)
 739     FAIL;
 740   operands[1] = hppa_compare_op0;
 741   operands[2] = hppa_compare_op1;
 742 }")
 743
 744 (define_expand "sgt"
 745   [(set (match_operand:SI 0 "register_operand" "")
 746         (gt:SI (match_dup 1)
 747                (match_dup 2)))]
 748   "!TARGET_64BIT"
 749   "
 750 {
 751   /* fp scc patterns rarely match, and are not a win on the PA.  */
 752   if (hppa_branch_type != CMP_SI)
 753     FAIL;
 754   operands[1] = hppa_compare_op0;
 755   operands[2] = hppa_compare_op1;
 756 }")
 757
 758 (define_expand "sle"
 759   [(set (match_operand:SI 0 "register_operand" "")
 760         (le:SI (match_dup 1)
 761                (match_dup 2)))]
 762   "!TARGET_64BIT"
 763   "
 764 {
 765   /* fp scc patterns rarely match, and are not a win on the PA.  */
 766   if (hppa_branch_type != CMP_SI)
 767     FAIL;
 768   operands[1] = hppa_compare_op0;
 769   operands[2] = hppa_compare_op1;
 770 }")
 771
 772 (define_expand "sge"
 773   [(set (match_operand:SI 0 "register_operand" "")
 774         (ge:SI (match_dup 1)
 775                (match_dup 2)))]
 776   "!TARGET_64BIT"
 777   "
 778 {
 779   /* fp scc patterns rarely match, and are not a win on the PA.  */
 780   if (hppa_branch_type != CMP_SI)
 781     FAIL;
 782   operands[1] = hppa_compare_op0;
 783   operands[2] = hppa_compare_op1;
 784 }")
 785
 786 (define_expand "sltu"
 787   [(set (match_operand:SI 0 "register_operand" "")
 788         (ltu:SI (match_dup 1)
 789                 (match_dup 2)))]
 790   "!TARGET_64BIT"
 791   "
 792 {
 793   if (hppa_branch_type != CMP_SI)
 794     FAIL;
 795   operands[1] = hppa_compare_op0;
 796   operands[2] = hppa_compare_op1;
 797 }")
 798
 799 (define_expand "sgtu"
 800   [(set (match_operand:SI 0 "register_operand" "")
 801         (gtu:SI (match_dup 1)
 802                 (match_dup 2)))]
 803   "!TARGET_64BIT"
 804   "
 805 {
 806   if (hppa_branch_type != CMP_SI)
 807     FAIL;
 808   operands[1] = hppa_compare_op0;
 809   operands[2] = hppa_compare_op1;
 810 }")
 811
 812 (define_expand "sleu"
 813   [(set (match_operand:SI 0 "register_operand" "")
 814         (leu:SI (match_dup 1)
 815                 (match_dup 2)))]
 816   "!TARGET_64BIT"
 817   "
 818 {
 819   if (hppa_branch_type != CMP_SI)
 820     FAIL;
 821   operands[1] = hppa_compare_op0;
 822   operands[2] = hppa_compare_op1;
 823 }")
 824
 825 (define_expand "sgeu"
 826   [(set (match_operand:SI 0 "register_operand" "")
 827         (geu:SI (match_dup 1)
 828                 (match_dup 2)))]
 829   "!TARGET_64BIT"
 830   "
 831 {
 832   if (hppa_branch_type != CMP_SI)
 833     FAIL;
 834   operands[1] = hppa_compare_op0;
 835   operands[2] = hppa_compare_op1;
 836 }")
 837
 838 ;; Instruction canonicalization puts immediate operands second, which
 839 ;; is the reverse of what we want.
 840
 841 (define_insn "scc"
 842   [(set (match_operand:SI 0 "register_operand" "=r")
 843         (match_operator:SI 3 "comparison_operator"
 844                            [(match_operand:SI 1 "register_operand" "r")
 845                             (match_operand:SI 2 "arith11_operand" "rI")]))]
 846   ""
 847   "{com%I2clr|cmp%I2clr},%B3 %2,%1,%0\;ldi 1,%0"
 848   [(set_attr "type" "binary")
 849    (set_attr "length" "8")])
 850
 851 (define_insn ""
 852   [(set (match_operand:DI 0 "register_operand" "=r")
 853         (match_operator:DI 3 "comparison_operator"
 854                            [(match_operand:DI 1 "register_operand" "r")
 855                             (match_operand:DI 2 "arith11_operand" "rI")]))]
 856   "TARGET_64BIT"
 857   "cmp%I2clr,*%B3 %2,%1,%0\;ldi 1,%0"
 858   [(set_attr "type" "binary")
 859    (set_attr "length" "8")])
 860
 861 (define_insn "iorscc"
 862   [(set (match_operand:SI 0 "register_operand" "=r")
 863         (ior:SI (match_operator:SI 3 "comparison_operator"
 864                                    [(match_operand:SI 1 "register_operand" "r")
 865                                     (match_operand:SI 2 "arith11_operand" "rI")])
 866                 (match_operator:SI 6 "comparison_operator"
 867                                    [(match_operand:SI 4 "register_operand" "r")
 868                                     (match_operand:SI 5 "arith11_operand" "rI")])))]
 869   ""
 870   "{com%I2clr|cmp%I2clr},%S3 %2,%1,%%r0\;{com%I5clr|cmp%I5clr},%B6 %5,%4,%0\;ldi 1,%0"
 871   [(set_attr "type" "binary")
 872    (set_attr "length" "12")])
 873
 874 (define_insn ""
 875   [(set (match_operand:DI 0 "register_operand" "=r")
 876         (ior:DI (match_operator:DI 3 "comparison_operator"
 877                                    [(match_operand:DI 1 "register_operand" "r")
 878                                     (match_operand:DI 2 "arith11_operand" "rI")])
 879                 (match_operator:DI 6 "comparison_operator"
 880                                    [(match_operand:DI 4 "register_operand" "r")
 881                                     (match_operand:DI 5 "arith11_operand" "rI")])))]
 882   "TARGET_64BIT"
 883   "cmp%I2clr,*%S3 %2,%1,%%r0\;cmp%I5clr,*%B6 %5,%4,%0\;ldi 1,%0"
 884   [(set_attr "type" "binary")
 885    (set_attr "length" "12")])
 886
 887 ;; Combiner patterns for common operations performed with the output
 888 ;; from an scc insn (negscc and incscc).
 889 (define_insn "negscc"
 890   [(set (match_operand:SI 0 "register_operand" "=r")
 891         (neg:SI (match_operator:SI 3 "comparison_operator"
 892                [(match_operand:SI 1 "register_operand" "r")
 893                 (match_operand:SI 2 "arith11_operand" "rI")])))]
 894   ""
 895   "{com%I2clr|cmp%I2clr},%B3 %2,%1,%0\;ldi -1,%0"
 896   [(set_attr "type" "binary")
 897    (set_attr "length" "8")])
 898
 899 (define_insn ""
 900   [(set (match_operand:DI 0 "register_operand" "=r")
 901         (neg:DI (match_operator:DI 3 "comparison_operator"
 902                [(match_operand:DI 1 "register_operand" "r")
 903                 (match_operand:DI 2 "arith11_operand" "rI")])))]
 904   "TARGET_64BIT"
 905   "cmp%I2clr,*%B3 %2,%1,%0\;ldi -1,%0"
 906   [(set_attr "type" "binary")
 907    (set_attr "length" "8")])
 908
 909 ;; Patterns for adding/subtracting the result of a boolean expression from
 910 ;; a register.  First we have special patterns that make use of the carry
 911 ;; bit, and output only two instructions.  For the cases we can't in
 912 ;; general do in two instructions, the incscc pattern at the end outputs
 913 ;; two or three instructions.
 914
 915 (define_insn ""
 916   [(set (match_operand:SI 0 "register_operand" "=r")
 917         (plus:SI (leu:SI (match_operand:SI 2 "register_operand" "r")
 918                          (match_operand:SI 3 "arith11_operand" "rI"))
 919                  (match_operand:SI 1 "register_operand" "r")))]
 920   ""
 921   "sub%I3 %3,%2,%%r0\;{addc|add,c} %%r0,%1,%0"
 922   [(set_attr "type" "binary")
 923    (set_attr "length" "8")])
 924
 925 (define_insn ""
 926   [(set (match_operand:DI 0 "register_operand" "=r")
 927         (plus:DI (leu:DI (match_operand:DI 2 "register_operand" "r")
 928                          (match_operand:DI 3 "arith11_operand" "rI"))
 929                  (match_operand:DI 1 "register_operand" "r")))]
 930   "TARGET_64BIT"
 931   "sub%I3 %3,%2,%%r0\;add,dc %%r0,%1,%0"
 932   [(set_attr "type" "binary")
 933    (set_attr "length" "8")])
 934
 935 ; This need only accept registers for op3, since canonicalization
 936 ; replaces geu with gtu when op3 is an integer.
 937 (define_insn ""
 938   [(set (match_operand:SI 0 "register_operand" "=r")
 939         (plus:SI (geu:SI (match_operand:SI 2 "register_operand" "r")
 940                          (match_operand:SI 3 "register_operand" "r"))
 941                  (match_operand:SI 1 "register_operand" "r")))]
 942   ""
 943   "sub %2,%3,%%r0\;{addc|add,c} %%r0,%1,%0"
 944   [(set_attr "type" "binary")
 945    (set_attr "length" "8")])
 946
 947 (define_insn ""
 948   [(set (match_operand:DI 0 "register_operand" "=r")
 949         (plus:DI (geu:DI (match_operand:DI 2 "register_operand" "r")
 950                          (match_operand:DI 3 "register_operand" "r"))
 951                  (match_operand:DI 1 "register_operand" "r")))]
 952   "TARGET_64BIT"
 953   "sub %2,%3,%%r0\;add,dc %%r0,%1,%0"
 954   [(set_attr "type" "binary")
 955    (set_attr "length" "8")])
 956
 957 ; Match only integers for op3 here.  This is used as canonical form of the
 958 ; geu pattern when op3 is an integer.  Don't match registers since we can't
 959 ; make better code than the general incscc pattern.
 960 (define_insn ""
 961   [(set (match_operand:SI 0 "register_operand" "=r")
 962         (plus:SI (gtu:SI (match_operand:SI 2 "register_operand" "r")
 963                          (match_operand:SI 3 "int11_operand" "I"))
 964                  (match_operand:SI 1 "register_operand" "r")))]
 965   ""
 966   "addi %k3,%2,%%r0\;{addc|add,c} %%r0,%1,%0"
 967   [(set_attr "type" "binary")
 968    (set_attr "length" "8")])
 969
 970 (define_insn ""
 971   [(set (match_operand:DI 0 "register_operand" "=r")
 972         (plus:DI (gtu:DI (match_operand:DI 2 "register_operand" "r")
 973                          (match_operand:DI 3 "int11_operand" "I"))
 974                  (match_operand:DI 1 "register_operand" "r")))]
 975   "TARGET_64BIT"
 976   "addi %k3,%2,%%r0\;add,dc %%r0,%1,%0"
 977   [(set_attr "type" "binary")
 978    (set_attr "length" "8")])
 979
 980 (define_insn "incscc"
 981   [(set (match_operand:SI 0 "register_operand" "=r,r")
 982         (plus:SI (match_operator:SI 4 "comparison_operator"
 983                     [(match_operand:SI 2 "register_operand" "r,r")
 984                      (match_operand:SI 3 "arith11_operand" "rI,rI")])
 985                  (match_operand:SI 1 "register_operand" "0,?r")))]
 986   ""
 987   "@
 988    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi 1,%0,%0
 989    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi,tr 1,%1,%0\;copy %1,%0"
 990   [(set_attr "type" "binary,binary")
 991    (set_attr "length" "8,12")])
 992
 993 (define_insn ""
 994   [(set (match_operand:DI 0 "register_operand" "=r,r")
 995         (plus:DI (match_operator:DI 4 "comparison_operator"
 996                     [(match_operand:DI 2 "register_operand" "r,r")
 997                      (match_operand:DI 3 "arith11_operand" "rI,rI")])
 998                  (match_operand:DI 1 "register_operand" "0,?r")))]
 999   "TARGET_64BIT"
1000   "@
1001    cmp%I3clr,*%B4 %3,%2,%%r0\;addi 1,%0,%0
1002    cmp%I3clr,*%B4 %3,%2,%%r0\;addi,tr 1,%1,%0\;copy %1,%0"
1003   [(set_attr "type" "binary,binary")
1004    (set_attr "length" "8,12")])
1005
1006 (define_insn ""
1007   [(set (match_operand:SI 0 "register_operand" "=r")
1008         (minus:SI (match_operand:SI 1 "register_operand" "r")
1009                   (gtu:SI (match_operand:SI 2 "register_operand" "r")
1010                           (match_operand:SI 3 "arith11_operand" "rI"))))]
1011   ""
1012   "sub%I3 %3,%2,%%r0\;{subb|sub,b} %1,%%r0,%0"
1013   [(set_attr "type" "binary")
1014    (set_attr "length" "8")])
1015
1016 (define_insn ""
1017   [(set (match_operand:DI 0 "register_operand" "=r")
1018         (minus:DI (match_operand:DI 1 "register_operand" "r")
1019                   (gtu:DI (match_operand:DI 2 "register_operand" "r")
1020                           (match_operand:DI 3 "arith11_operand" "rI"))))]
1021   "TARGET_64BIT"
1022   "sub%I3 %3,%2,%%r0\;sub,db %1,%%r0,%0"
1023   [(set_attr "type" "binary")
1024    (set_attr "length" "8")])
1025
1026 (define_insn ""
1027   [(set (match_operand:SI 0 "register_operand" "=r")
1028         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1029                             (gtu:SI (match_operand:SI 2 "register_operand" "r")
1030                                     (match_operand:SI 3 "arith11_operand" "rI")))
1031                   (match_operand:SI 4 "register_operand" "r")))]
1032   ""
1033   "sub%I3 %3,%2,%%r0\;{subb|sub,b} %1,%4,%0"
1034   [(set_attr "type" "binary")
1035    (set_attr "length" "8")])
1036
1037 (define_insn ""
1038   [(set (match_operand:DI 0 "register_operand" "=r")
1039         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1040                             (gtu:DI (match_operand:DI 2 "register_operand" "r")
1041                                     (match_operand:DI 3 "arith11_operand" "rI")))
1042                   (match_operand:DI 4 "register_operand" "r")))]
1043   "TARGET_64BIT"
1044   "sub%I3 %3,%2,%%r0\;sub,db %1,%4,%0"
1045   [(set_attr "type" "binary")
1046    (set_attr "length" "8")])
1047
1048 ; This need only accept registers for op3, since canonicalization
1049 ; replaces ltu with leu when op3 is an integer.
1050 (define_insn ""
1051   [(set (match_operand:SI 0 "register_operand" "=r")
1052         (minus:SI (match_operand:SI 1 "register_operand" "r")
1053                   (ltu:SI (match_operand:SI 2 "register_operand" "r")
1054                           (match_operand:SI 3 "register_operand" "r"))))]
1055   ""
1056   "sub %2,%3,%%r0\;{subb|sub,b} %1,%%r0,%0"
1057   [(set_attr "type" "binary")
1058    (set_attr "length" "8")])
1059
1060 (define_insn ""
1061   [(set (match_operand:DI 0 "register_operand" "=r")
1062         (minus:DI (match_operand:DI 1 "register_operand" "r")
1063                   (ltu:DI (match_operand:DI 2 "register_operand" "r")
1064                           (match_operand:DI 3 "register_operand" "r"))))]
1065   "TARGET_64BIT"
1066   "sub %2,%3,%%r0\;sub,db %1,%%r0,%0"
1067   [(set_attr "type" "binary")
1068    (set_attr "length" "8")])
1069
1070 (define_insn ""
1071   [(set (match_operand:SI 0 "register_operand" "=r")
1072         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1073                             (ltu:SI (match_operand:SI 2 "register_operand" "r")
1074                                     (match_operand:SI 3 "register_operand" "r")))
1075                   (match_operand:SI 4 "register_operand" "r")))]
1076   ""
1077   "sub %2,%3,%%r0\;{subb|sub,b} %1,%4,%0"
1078   [(set_attr "type" "binary")
1079    (set_attr "length" "8")])
1080
1081 (define_insn ""
1082   [(set (match_operand:DI 0 "register_operand" "=r")
1083         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1084                             (ltu:DI (match_operand:DI 2 "register_operand" "r")
1085                                     (match_operand:DI 3 "register_operand" "r")))
1086                   (match_operand:DI 4 "register_operand" "r")))]
1087   "TARGET_64BIT"
1088   "sub %2,%3,%%r0\;sub,db %1,%4,%0"
1089   [(set_attr "type" "binary")
1090    (set_attr "length" "8")])
1091
1092 ; Match only integers for op3 here.  This is used as canonical form of the
1093 ; ltu pattern when op3 is an integer.  Don't match registers since we can't
1094 ; make better code than the general incscc pattern.
1095 (define_insn ""
1096   [(set (match_operand:SI 0 "register_operand" "=r")
1097         (minus:SI (match_operand:SI 1 "register_operand" "r")
1098                   (leu:SI (match_operand:SI 2 "register_operand" "r")
1099                           (match_operand:SI 3 "int11_operand" "I"))))]
1100   ""
1101   "addi %k3,%2,%%r0\;{subb|sub,b} %1,%%r0,%0"
1102   [(set_attr "type" "binary")
1103    (set_attr "length" "8")])
1104
1105 (define_insn ""
1106   [(set (match_operand:DI 0 "register_operand" "=r")
1107         (minus:DI (match_operand:DI 1 "register_operand" "r")
1108                   (leu:DI (match_operand:DI 2 "register_operand" "r")
1109                           (match_operand:DI 3 "int11_operand" "I"))))]
1110   "TARGET_64BIT"
1111   "addi %k3,%2,%%r0\;sub,db %1,%%r0,%0"
1112   [(set_attr "type" "binary")
1113    (set_attr "length" "8")])
1114
1115 (define_insn ""
1116   [(set (match_operand:SI 0 "register_operand" "=r")
1117         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1118                             (leu:SI (match_operand:SI 2 "register_operand" "r")
1119                                     (match_operand:SI 3 "int11_operand" "I")))
1120                   (match_operand:SI 4 "register_operand" "r")))]
1121   ""
1122   "addi %k3,%2,%%r0\;{subb|sub,b} %1,%4,%0"
1123   [(set_attr "type" "binary")
1124    (set_attr "length" "8")])
1125
1126 (define_insn ""
1127   [(set (match_operand:DI 0 "register_operand" "=r")
1128         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1129                             (leu:DI (match_operand:DI 2 "register_operand" "r")
1130                                     (match_operand:DI 3 "int11_operand" "I")))
1131                   (match_operand:DI 4 "register_operand" "r")))]
1132   "TARGET_64BIT"
1133   "addi %k3,%2,%%r0\;sub,db %1,%4,%0"
1134   [(set_attr "type" "binary")
1135    (set_attr "length" "8")])
1136
1137 (define_insn "decscc"
1138   [(set (match_operand:SI 0 "register_operand" "=r,r")
1139         (minus:SI (match_operand:SI 1 "register_operand" "0,?r")
1140                   (match_operator:SI 4 "comparison_operator"
1141                      [(match_operand:SI 2 "register_operand" "r,r")
1142                       (match_operand:SI 3 "arith11_operand" "rI,rI")])))]
1143   ""
1144   "@
1145    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi -1,%0,%0
1146    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi,tr -1,%1,%0\;copy %1,%0"
1147   [(set_attr "type" "binary,binary")
1148    (set_attr "length" "8,12")])
1149
1150 (define_insn ""
1151   [(set (match_operand:DI 0 "register_operand" "=r,r")
1152         (minus:DI (match_operand:DI 1 "register_operand" "0,?r")
1153                   (match_operator:DI 4 "comparison_operator"
1154                      [(match_operand:DI 2 "register_operand" "r,r")
1155                       (match_operand:DI 3 "arith11_operand" "rI,rI")])))]
1156   "TARGET_64BIT"
1157   "@
1158    cmp%I3clr,*%B4 %3,%2,%%r0\;addi -1,%0,%0
1159    cmp%I3clr,*%B4 %3,%2,%%r0\;addi,tr -1,%1,%0\;copy %1,%0"
1160   [(set_attr "type" "binary,binary")
1161    (set_attr "length" "8,12")])
1162
1163 ; Patterns for max and min.  (There is no need for an earlyclobber in the
1164 ; last alternative since the middle alternative will match if op0 == op1.)
1165
1166 (define_insn "sminsi3"
1167   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1168         (smin:SI (match_operand:SI 1 "register_operand" "%0,0,r")
1169                  (match_operand:SI 2 "arith11_operand" "r,I,M")))]
1170   ""
1171   "@
1172   {comclr|cmpclr},> %2,%0,%%r0\;copy %2,%0
1173   {comiclr|cmpiclr},> %2,%0,%%r0\;ldi %2,%0
1174   {comclr|cmpclr},> %1,%r2,%0\;copy %1,%0"
1175 [(set_attr "type" "multi,multi,multi")
1176  (set_attr "length" "8,8,8")])
1177
1178 (define_insn "smindi3"
1179   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
1180         (smin:DI (match_operand:DI 1 "register_operand" "%0,0,r")
1181                  (match_operand:DI 2 "arith11_operand" "r,I,M")))]
1182   "TARGET_64BIT"
1183   "@
1184   cmpclr,*> %2,%0,%%r0\;copy %2,%0
1185   cmpiclr,*> %2,%0,%%r0\;ldi %2,%0
1186   cmpclr,*> %1,%r2,%0\;copy %1,%0"
1187 [(set_attr "type" "multi,multi,multi")
1188  (set_attr "length" "8,8,8")])
1189
1190 (define_insn "uminsi3"
1191   [(set (match_operand:SI 0 "register_operand" "=r,r")
1192         (umin:SI (match_operand:SI 1 "register_operand" "%0,0")
1193                  (match_operand:SI 2 "arith11_operand" "r,I")))]
1194   ""
1195   "@
1196   {comclr|cmpclr},>> %2,%0,%%r0\;copy %2,%0
1197   {comiclr|cmpiclr},>> %2,%0,%%r0\;ldi %2,%0"
1198 [(set_attr "type" "multi,multi")
1199  (set_attr "length" "8,8")])
1200
1201 (define_insn "umindi3"
1202   [(set (match_operand:DI 0 "register_operand" "=r,r")
1203         (umin:DI (match_operand:DI 1 "register_operand" "%0,0")
1204                  (match_operand:DI 2 "arith11_operand" "r,I")))]
1205   "TARGET_64BIT"
1206   "@
1207   cmpclr,*>> %2,%0,%%r0\;copy %2,%0
1208   cmpiclr,*>> %2,%0,%%r0\;ldi %2,%0"
1209 [(set_attr "type" "multi,multi")
1210  (set_attr "length" "8,8")])
1211
1212 (define_insn "smaxsi3"
1213   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1214         (smax:SI (match_operand:SI 1 "register_operand" "%0,0,r")
1215                  (match_operand:SI 2 "arith11_operand" "r,I,M")))]
1216   ""
1217   "@
1218   {comclr|cmpclr},< %2,%0,%%r0\;copy %2,%0
1219   {comiclr|cmpiclr},< %2,%0,%%r0\;ldi %2,%0
1220   {comclr|cmpclr},< %1,%r2,%0\;copy %1,%0"
1221 [(set_attr "type" "multi,multi,multi")
1222  (set_attr "length" "8,8,8")])
1223
1224 (define_insn "smaxdi3"
1225   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
1226         (smax:DI (match_operand:DI 1 "register_operand" "%0,0,r")
1227                  (match_operand:DI 2 "arith11_operand" "r,I,M")))]
1228   "TARGET_64BIT"
1229   "@
1230   cmpclr,*< %2,%0,%%r0\;copy %2,%0
1231   cmpiclr,*< %2,%0,%%r0\;ldi %2,%0
1232   cmpclr,*< %1,%r2,%0\;copy %1,%0"
1233 [(set_attr "type" "multi,multi,multi")
1234  (set_attr "length" "8,8,8")])
1235
1236 (define_insn "umaxsi3"
1237   [(set (match_operand:SI 0 "register_operand" "=r,r")
1238         (umax:SI (match_operand:SI 1 "register_operand" "%0,0")
1239                  (match_operand:SI 2 "arith11_operand" "r,I")))]
1240   ""
1241   "@
1242   {comclr|cmpclr},<< %2,%0,%%r0\;copy %2,%0
1243   {comiclr|cmpiclr},<< %2,%0,%%r0\;ldi %2,%0"
1244 [(set_attr "type" "multi,multi")
1245  (set_attr "length" "8,8")])
1246
1247 (define_insn "umaxdi3"
1248   [(set (match_operand:DI 0 "register_operand" "=r,r")
1249         (umax:DI (match_operand:DI 1 "register_operand" "%0,0")
1250                  (match_operand:DI 2 "arith11_operand" "r,I")))]
1251   "TARGET_64BIT"
1252   "@
1253   cmpclr,*<< %2,%0,%%r0\;copy %2,%0
1254   cmpiclr,*<< %2,%0,%%r0\;ldi %2,%0"
1255 [(set_attr "type" "multi,multi")
1256  (set_attr "length" "8,8")])
1257
1258 (define_insn "abssi2"
1259   [(set (match_operand:SI 0 "register_operand" "=r")
1260         (abs:SI (match_operand:SI 1 "register_operand" "r")))]
1261   ""
1262   "or,>= %%r0,%1,%0\;subi 0,%0,%0"
1263   [(set_attr "type" "multi")
1264    (set_attr "length" "8")])
1265
1266 (define_insn "absdi2"
1267   [(set (match_operand:DI 0 "register_operand" "=r")
1268         (abs:DI (match_operand:DI 1 "register_operand" "r")))]
1269   "TARGET_64BIT"
1270   "or,*>= %%r0,%1,%0\;subi 0,%0,%0"
1271   [(set_attr "type" "multi")
1272    (set_attr "length" "8")])
1273
1274 ;;; Experimental conditional move patterns
1275
1276 (define_expand "movsicc"
1277   [(set (match_operand:SI 0 "register_operand" "")
1278         (if_then_else:SI
1279          (match_operator 1 "comparison_operator"
1280             [(match_dup 4)
1281              (match_dup 5)])
1282          (match_operand:SI 2 "reg_or_cint_move_operand" "")
1283          (match_operand:SI 3 "reg_or_cint_move_operand" "")))]
1284   ""
1285   "
1286 {
1287   enum rtx_code code = GET_CODE (operands[1]);
1288
1289   if (hppa_branch_type != CMP_SI)
1290     FAIL;
1291
1292   if (GET_MODE (hppa_compare_op0) != GET_MODE (hppa_compare_op1)
1293       || GET_MODE (hppa_compare_op0) != GET_MODE (operands[0]))
1294     FAIL;
1295
1296   /* operands[1] is currently the result of compare_from_rtx.  We want to
1297      emit a compare of the original operands.  */
1298   operands[1] = gen_rtx_fmt_ee (code, SImode, hppa_compare_op0, hppa_compare_op1);
1299   operands[4] = hppa_compare_op0;
1300   operands[5] = hppa_compare_op1;
1301 }")
1302
1303 ;; We used to accept any register for op1.
1304 ;;
1305 ;; However, it loses sometimes because the compiler will end up using
1306 ;; different registers for op0 and op1 in some critical cases.  local-alloc
1307 ;; will  not tie op0 and op1 because op0 is used in multiple basic blocks.
1308 ;;
1309 ;; If/when global register allocation supports tying we should allow any
1310 ;; register for op1 again.
1311 (define_insn ""
1312   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
1313         (if_then_else:SI
1314          (match_operator 2 "comparison_operator"
1315             [(match_operand:SI 3 "register_operand" "r,r,r,r")
1316              (match_operand:SI 4 "arith11_operand" "rI,rI,rI,rI")])
1317          (match_operand:SI 1 "reg_or_cint_move_operand" "0,J,N,K")
1318          (const_int 0)))]
1319   ""
1320   "@
1321    {com%I4clr|cmp%I4clr},%S2 %4,%3,%%r0\;ldi 0,%0
1322    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;ldi %1,%0
1323    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;ldil L'%1,%0
1324    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;{zdepi|depwi,z} %Z1,%0"
1325   [(set_attr "type" "multi,multi,multi,nullshift")
1326    (set_attr "length" "8,8,8,8")])
1327
1328 (define_insn ""
1329   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,r,r,r,r")
1330         (if_then_else:SI
1331          (match_operator 5 "comparison_operator"
1332             [(match_operand:SI 3 "register_operand" "r,r,r,r,r,r,r,r")
1333              (match_operand:SI 4 "arith11_operand" "rI,rI,rI,rI,rI,rI,rI,rI")])
1334          (match_operand:SI 1 "reg_or_cint_move_operand" "0,0,0,0,r,J,N,K")
1335          (match_operand:SI 2 "reg_or_cint_move_operand" "r,J,N,K,0,0,0,0")))]
1336   ""
1337   "@
1338    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;copy %2,%0
1339    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;ldi %2,%0
1340    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;ldil L'%2,%0
1341    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;{zdepi|depwi,z} %Z2,%0
1342    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;copy %1,%0
1343    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;ldi %1,%0
1344    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;ldil L'%1,%0
1345    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;{zdepi|depwi,z} %Z1,%0"
1346   [(set_attr "type" "multi,multi,multi,nullshift,multi,multi,multi,nullshift")
1347    (set_attr "length" "8,8,8,8,8,8,8,8")])
1348
1349 (define_expand "movdicc"
1350   [(set (match_operand:DI 0 "register_operand" "")
1351         (if_then_else:DI
1352          (match_operator 1 "comparison_operator"
1353             [(match_dup 4)
1354              (match_dup 5)])
1355          (match_operand:DI 2 "reg_or_cint_move_operand" "")
1356          (match_operand:DI 3 "reg_or_cint_move_operand" "")))]
1357   "TARGET_64BIT"
1358   "
1359 {
1360   enum rtx_code code = GET_CODE (operands[1]);
1361
1362   if (hppa_branch_type != CMP_SI)
1363     FAIL;
1364
1365   if (GET_MODE (hppa_compare_op0) != GET_MODE (hppa_compare_op1)
1366       || GET_MODE (hppa_compare_op0) != GET_MODE (operands[0]))
1367     FAIL;
1368
1369   /* operands[1] is currently the result of compare_from_rtx.  We want to
1370      emit a compare of the original operands.  */
1371   operands[1] = gen_rtx_fmt_ee (code, DImode, hppa_compare_op0, hppa_compare_op1);
1372   operands[4] = hppa_compare_op0;
1373   operands[5] = hppa_compare_op1;
1374 }")
1375
1376 ; We need the first constraint alternative in order to avoid
1377 ; earlyclobbers on all other alternatives.
1378 (define_insn ""
1379   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r,r")
1380         (if_then_else:DI
1381          (match_operator 2 "comparison_operator"
1382             [(match_operand:DI 3 "register_operand" "r,r,r,r,r")
1383              (match_operand:DI 4 "arith11_operand" "rI,rI,rI,rI,rI")])
1384          (match_operand:DI 1 "reg_or_cint_move_operand" "0,r,J,N,K")
1385          (const_int 0)))]
1386   "TARGET_64BIT"
1387   "@
1388    cmp%I4clr,*%S2 %4,%3,%%r0\;ldi 0,%0
1389    cmp%I4clr,*%B2 %4,%3,%0\;copy %1,%0
1390    cmp%I4clr,*%B2 %4,%3,%0\;ldi %1,%0
1391    cmp%I4clr,*%B2 %4,%3,%0\;ldil L'%1,%0
1392    cmp%I4clr,*%B2 %4,%3,%0\;depdi,z %z1,%0"
1393   [(set_attr "type" "multi,multi,multi,multi,nullshift")
1394    (set_attr "length" "8,8,8,8,8")])
1395
1396 (define_insn ""
1397   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r,r,r,r,r")
1398         (if_then_else:DI
1399          (match_operator 5 "comparison_operator"
1400             [(match_operand:DI 3 "register_operand" "r,r,r,r,r,r,r,r")
1401              (match_operand:DI 4 "arith11_operand" "rI,rI,rI,rI,rI,rI,rI,rI")])
1402          (match_operand:DI 1 "reg_or_cint_move_operand" "0,0,0,0,r,J,N,K")
1403          (match_operand:DI 2 "reg_or_cint_move_operand" "r,J,N,K,0,0,0,0")))]
1404   "TARGET_64BIT"
1405   "@
1406    cmp%I4clr,*%S5 %4,%3,%%r0\;copy %2,%0
1407    cmp%I4clr,*%S5 %4,%3,%%r0\;ldi %2,%0
1408    cmp%I4clr,*%S5 %4,%3,%%r0\;ldil L'%2,%0
1409    cmp%I4clr,*%S5 %4,%3,%%r0\;depdi,z %z2,%0
1410    cmp%I4clr,*%B5 %4,%3,%%r0\;copy %1,%0
1411    cmp%I4clr,*%B5 %4,%3,%%r0\;ldi %1,%0
1412    cmp%I4clr,*%B5 %4,%3,%%r0\;ldil L'%1,%0
1413    cmp%I4clr,*%B5 %4,%3,%%r0\;depdi,z %z1,%0"
1414   [(set_attr "type" "multi,multi,multi,nullshift,multi,multi,multi,nullshift")
1415    (set_attr "length" "8,8,8,8,8,8,8,8")])
1416
1417 ;; Conditional Branches
1418
1419 (define_expand "beq"
1420   [(set (pc)
1421         (if_then_else (eq (match_dup 1) (match_dup 2))
1422                       (label_ref (match_operand 0 "" ""))
1423                       (pc)))]
1424   ""
1425   "
1426 {
1427   if (hppa_branch_type != CMP_SI)
1428     {
1429       emit_insn (gen_cmp_fp (EQ, hppa_compare_op0, hppa_compare_op1));
1430       emit_bcond_fp (NE, operands[0]);
1431       DONE;
1432     }
1433   /* set up operands from compare.  */
1434   operands[1] = hppa_compare_op0;
1435   operands[2] = hppa_compare_op1;
1436   /* fall through and generate default code */
1437 }")
1438
1439 (define_expand "bne"
1440   [(set (pc)
1441         (if_then_else (ne (match_dup 1) (match_dup 2))
1442                       (label_ref (match_operand 0 "" ""))
1443                       (pc)))]
1444   ""
1445   "
1446 {
1447   if (hppa_branch_type != CMP_SI)
1448     {
1449       emit_insn (gen_cmp_fp (NE, hppa_compare_op0, hppa_compare_op1));
1450       emit_bcond_fp (NE, operands[0]);
1451       DONE;
1452     }
1453   operands[1] = hppa_compare_op0;
1454   operands[2] = hppa_compare_op1;
1455 }")
1456
1457 (define_expand "bgt"
1458   [(set (pc)
1459         (if_then_else (gt (match_dup 1) (match_dup 2))
1460                       (label_ref (match_operand 0 "" ""))
1461                       (pc)))]
1462   ""
1463   "
1464 {
1465   if (hppa_branch_type != CMP_SI)
1466     {
1467       emit_insn (gen_cmp_fp (GT, hppa_compare_op0, hppa_compare_op1));
1468       emit_bcond_fp (NE, operands[0]);
1469       DONE;
1470     }
1471   operands[1] = hppa_compare_op0;
1472   operands[2] = hppa_compare_op1;
1473 }")
1474
1475 (define_expand "blt"
1476   [(set (pc)
1477         (if_then_else (lt (match_dup 1) (match_dup 2))
1478                       (label_ref (match_operand 0 "" ""))
1479                       (pc)))]
1480   ""
1481   "
1482 {
1483   if (hppa_branch_type != CMP_SI)
1484     {
1485       emit_insn (gen_cmp_fp (LT, hppa_compare_op0, hppa_compare_op1));
1486       emit_bcond_fp (NE, operands[0]);
1487       DONE;
1488     }
1489   operands[1] = hppa_compare_op0;
1490   operands[2] = hppa_compare_op1;
1491 }")
1492
1493 (define_expand "bge"
1494   [(set (pc)
1495         (if_then_else (ge (match_dup 1) (match_dup 2))
1496                       (label_ref (match_operand 0 "" ""))
1497                       (pc)))]
1498   ""
1499   "
1500 {
1501   if (hppa_branch_type != CMP_SI)
1502     {
1503       emit_insn (gen_cmp_fp (GE, hppa_compare_op0, hppa_compare_op1));
1504       emit_bcond_fp (NE, operands[0]);
1505       DONE;
1506     }
1507   operands[1] = hppa_compare_op0;
1508   operands[2] = hppa_compare_op1;
1509 }")
1510
1511 (define_expand "ble"
1512   [(set (pc)
1513         (if_then_else (le (match_dup 1) (match_dup 2))
1514                       (label_ref (match_operand 0 "" ""))
1515                       (pc)))]
1516   ""
1517   "
1518 {
1519   if (hppa_branch_type != CMP_SI)
1520     {
1521       emit_insn (gen_cmp_fp (LE, hppa_compare_op0, hppa_compare_op1));
1522       emit_bcond_fp (NE, operands[0]);
1523       DONE;
1524     }
1525   operands[1] = hppa_compare_op0;
1526   operands[2] = hppa_compare_op1;
1527 }")
1528
1529 (define_expand "bgtu"
1530   [(set (pc)
1531         (if_then_else (gtu (match_dup 1) (match_dup 2))
1532                       (label_ref (match_operand 0 "" ""))
1533                       (pc)))]
1534   ""
1535   "
1536 {
1537   if (hppa_branch_type != CMP_SI)
1538     FAIL;
1539   operands[1] = hppa_compare_op0;
1540   operands[2] = hppa_compare_op1;
1541 }")
1542
1543 (define_expand "bltu"
1544   [(set (pc)
1545         (if_then_else (ltu (match_dup 1) (match_dup 2))
1546                       (label_ref (match_operand 0 "" ""))
1547                       (pc)))]
1548   ""
1549   "
1550 {
1551   if (hppa_branch_type != CMP_SI)
1552     FAIL;
1553   operands[1] = hppa_compare_op0;
1554   operands[2] = hppa_compare_op1;
1555 }")
1556
1557 (define_expand "bgeu"
1558   [(set (pc)
1559         (if_then_else (geu (match_dup 1) (match_dup 2))
1560                       (label_ref (match_operand 0 "" ""))
1561                       (pc)))]
1562   ""
1563   "
1564 {
1565   if (hppa_branch_type != CMP_SI)
1566     FAIL;
1567   operands[1] = hppa_compare_op0;
1568   operands[2] = hppa_compare_op1;
1569 }")
1570
1571 (define_expand "bleu"
1572   [(set (pc)
1573         (if_then_else (leu (match_dup 1) (match_dup 2))
1574                       (label_ref (match_operand 0 "" ""))
1575                       (pc)))]
1576   ""
1577   "
1578 {
1579   if (hppa_branch_type != CMP_SI)
1580     FAIL;
1581   operands[1] = hppa_compare_op0;
1582   operands[2] = hppa_compare_op1;
1583 }")
1584
1585 (define_expand "bltgt"
1586   [(set (pc)
1587         (if_then_else (ltgt (match_dup 1) (match_dup 2))
1588                       (label_ref (match_operand 0 "" ""))
1589                       (pc)))]
1590   ""
1591   "
1592 {
1593   if (hppa_branch_type == CMP_SI)
1594     FAIL;
1595   emit_insn (gen_cmp_fp (LTGT, hppa_compare_op0, hppa_compare_op1));
1596   emit_bcond_fp (NE, operands[0]);
1597   DONE;
1598 }")
1599
1600 (define_expand "bunle"
1601   [(set (pc)
1602         (if_then_else (unle (match_dup 1) (match_dup 2))
1603                       (label_ref (match_operand 0 "" ""))
1604                       (pc)))]
1605   ""
1606   "
1607 {
1608   if (hppa_branch_type == CMP_SI)
1609     FAIL;
1610   emit_insn (gen_cmp_fp (UNLE, hppa_compare_op0, hppa_compare_op1));
1611   emit_bcond_fp (NE, operands[0]);
1612   DONE;
1613 }")
1614
1615 (define_expand "bunlt"
1616   [(set (pc)
1617         (if_then_else (unlt (match_dup 1) (match_dup 2))
1618                       (label_ref (match_operand 0 "" ""))
1619                       (pc)))]
1620   ""
1621   "
1622 {
1623   if (hppa_branch_type == CMP_SI)
1624     FAIL;
1625   emit_insn (gen_cmp_fp (UNLT, hppa_compare_op0, hppa_compare_op1));
1626   emit_bcond_fp (NE, operands[0]);
1627   DONE;
1628 }")
1629
1630 (define_expand "bunge"
1631   [(set (pc)
1632         (if_then_else (unge (match_dup 1) (match_dup 2))
1633                       (label_ref (match_operand 0 "" ""))
1634                       (pc)))]
1635   ""
1636   "
1637 {
1638   if (hppa_branch_type == CMP_SI)
1639     FAIL;
1640   emit_insn (gen_cmp_fp (UNGE, hppa_compare_op0, hppa_compare_op1));
1641   emit_bcond_fp (NE, operands[0]);
1642   DONE;
1643 }")
1644
1645 (define_expand "bungt"
1646   [(set (pc)
1647         (if_then_else (ungt (match_dup 1) (match_dup 2))
1648                       (label_ref (match_operand 0 "" ""))
1649                       (pc)))]
1650   ""
1651   "
1652 {
1653   if (hppa_branch_type == CMP_SI)
1654     FAIL;
1655   emit_insn (gen_cmp_fp (UNGT, hppa_compare_op0, hppa_compare_op1));
1656   emit_bcond_fp (NE, operands[0]);
1657   DONE;
1658 }")
1659
1660 (define_expand "buneq"
1661   [(set (pc)
1662         (if_then_else (uneq (match_dup 1) (match_dup 2))
1663                       (label_ref (match_operand 0 "" ""))
1664                       (pc)))]
1665   ""
1666   "
1667 {
1668   if (hppa_branch_type == CMP_SI)
1669     FAIL;
1670   emit_insn (gen_cmp_fp (UNEQ, hppa_compare_op0, hppa_compare_op1));
1671   emit_bcond_fp (NE, operands[0]);
1672   DONE;
1673 }")
1674
1675 (define_expand "bunordered"
1676   [(set (pc)
1677         (if_then_else (unordered (match_dup 1) (match_dup 2))
1678                       (label_ref (match_operand 0 "" ""))
1679                       (pc)))]
1680   ""
1681   "
1682 {
1683   if (hppa_branch_type == CMP_SI)
1684     FAIL;
1685   emit_insn (gen_cmp_fp (UNORDERED, hppa_compare_op0, hppa_compare_op1));
1686   emit_bcond_fp (NE, operands[0]);
1687   DONE;
1688 }")
1689
1690 (define_expand "bordered"
1691   [(set (pc)
1692         (if_then_else (ordered (match_dup 1) (match_dup 2))
1693                       (label_ref (match_operand 0 "" ""))
1694                       (pc)))]
1695   ""
1696   "
1697 {
1698   if (hppa_branch_type == CMP_SI)
1699     FAIL;
1700   emit_insn (gen_cmp_fp (ORDERED, hppa_compare_op0, hppa_compare_op1));
1701   emit_bcond_fp (NE, operands[0]);
1702   DONE;
1703 }")
1704
1705 ;; Match the branch patterns.
1706
1707
1708 ;; Note a long backward conditional branch with an annulled delay slot
1709 ;; has a length of 12.
1710 (define_insn ""
1711   [(set (pc)
1712         (if_then_else
1713          (match_operator 3 "comparison_operator"
1714                          [(match_operand:SI 1 "reg_or_0_operand" "rM")
1715                           (match_operand:SI 2 "arith5_operand" "rL")])
1716          (label_ref (match_operand 0 "" ""))
1717          (pc)))]
1718   ""
1719   "*
1720 {
1721   return output_cbranch (operands, 0, insn);
1722 }"
1723 [(set_attr "type" "cbranch")
1724  (set (attr "length")
1725     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1726                (const_int MAX_12BIT_OFFSET))
1727            (const_int 4)
1728            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1729                (const_int MAX_17BIT_OFFSET))
1730            (const_int 8)
1731            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1732            (const_int 24)
1733            (eq (symbol_ref "flag_pic") (const_int 0))
1734            (const_int 20)]
1735           (const_int 28)))])
1736
1737 ;; Match the negated branch.
1738
1739 (define_insn ""
1740   [(set (pc)
1741         (if_then_else
1742          (match_operator 3 "comparison_operator"
1743                          [(match_operand:SI 1 "reg_or_0_operand" "rM")
1744                           (match_operand:SI 2 "arith5_operand" "rL")])
1745          (pc)
1746          (label_ref (match_operand 0 "" ""))))]
1747   ""
1748   "*
1749 {
1750   return output_cbranch (operands, 1, insn);
1751 }"
1752 [(set_attr "type" "cbranch")
1753  (set (attr "length")
1754     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1755                (const_int MAX_12BIT_OFFSET))
1756            (const_int 4)
1757            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1758                (const_int MAX_17BIT_OFFSET))
1759            (const_int 8)
1760            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1761            (const_int 24)
1762            (eq (symbol_ref "flag_pic") (const_int 0))
1763            (const_int 20)]
1764           (const_int 28)))])
1765
1766 (define_insn ""
1767   [(set (pc)
1768         (if_then_else
1769          (match_operator 3 "comparison_operator"
1770                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1771                           (match_operand:DI 2 "reg_or_0_operand" "rM")])
1772          (label_ref (match_operand 0 "" ""))
1773          (pc)))]
1774   "TARGET_64BIT"
1775   "*
1776 {
1777   return output_cbranch (operands, 0, insn);
1778 }"
1779 [(set_attr "type" "cbranch")
1780  (set (attr "length")
1781     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1782                (const_int MAX_12BIT_OFFSET))
1783            (const_int 4)
1784            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1785                (const_int MAX_17BIT_OFFSET))
1786            (const_int 8)
1787            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1788            (const_int 24)
1789            (eq (symbol_ref "flag_pic") (const_int 0))
1790            (const_int 20)]
1791           (const_int 28)))])
1792
1793 ;; Match the negated branch.
1794
1795 (define_insn ""
1796   [(set (pc)
1797         (if_then_else
1798          (match_operator 3 "comparison_operator"
1799                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1800                           (match_operand:DI 2 "reg_or_0_operand" "rM")])
1801          (pc)
1802          (label_ref (match_operand 0 "" ""))))]
1803   "TARGET_64BIT"
1804   "*
1805 {
1806   return output_cbranch (operands, 1, insn);
1807 }"
1808 [(set_attr "type" "cbranch")
1809  (set (attr "length")
1810     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1811                (const_int MAX_12BIT_OFFSET))
1812            (const_int 4)
1813            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1814                (const_int MAX_17BIT_OFFSET))
1815            (const_int 8)
1816            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1817            (const_int 24)
1818            (eq (symbol_ref "flag_pic") (const_int 0))
1819            (const_int 20)]
1820           (const_int 28)))])
1821 (define_insn ""
1822   [(set (pc)
1823         (if_then_else
1824          (match_operator 3 "cmpib_comparison_operator"
1825                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1826                           (match_operand:DI 2 "arith5_operand" "rL")])
1827          (label_ref (match_operand 0 "" ""))
1828          (pc)))]
1829   "TARGET_64BIT"
1830   "*
1831 {
1832   return output_cbranch (operands, 0, insn);
1833 }"
1834 [(set_attr "type" "cbranch")
1835  (set (attr "length")
1836     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1837                (const_int MAX_12BIT_OFFSET))
1838            (const_int 4)
1839            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1840                (const_int MAX_17BIT_OFFSET))
1841            (const_int 8)
1842            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1843            (const_int 24)
1844            (eq (symbol_ref "flag_pic") (const_int 0))
1845            (const_int 20)]
1846           (const_int 28)))])
1847
1848 ;; Match the negated branch.
1849
1850 (define_insn ""
1851   [(set (pc)
1852         (if_then_else
1853          (match_operator 3 "cmpib_comparison_operator"
1854                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1855                           (match_operand:DI 2 "arith5_operand" "rL")])
1856          (pc)
1857          (label_ref (match_operand 0 "" ""))))]
1858   "TARGET_64BIT"
1859   "*
1860 {
1861   return output_cbranch (operands, 1, insn);
1862 }"
1863 [(set_attr "type" "cbranch")
1864  (set (attr "length")
1865     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1866                (const_int MAX_12BIT_OFFSET))
1867            (const_int 4)
1868            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1869                (const_int MAX_17BIT_OFFSET))
1870            (const_int 8)
1871            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1872            (const_int 24)
1873            (eq (symbol_ref "flag_pic") (const_int 0))
1874            (const_int 20)]
1875           (const_int 28)))])
1876
1877 ;; Branch on Bit patterns.
1878 (define_insn ""
1879   [(set (pc)
1880         (if_then_else
1881          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1882                               (const_int 1)
1883                               (match_operand:SI 1 "uint5_operand" ""))
1884              (const_int 0))
1885          (label_ref (match_operand 2 "" ""))
1886          (pc)))]
1887   ""
1888   "*
1889 {
1890   return output_bb (operands, 0, insn, 0);
1891 }"
1892 [(set_attr "type" "cbranch")
1893  (set (attr "length")
1894     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1895                (const_int MAX_12BIT_OFFSET))
1896            (const_int 4)
1897            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1898                (const_int MAX_17BIT_OFFSET))
1899            (const_int 8)
1900            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1901            (const_int 24)
1902            (eq (symbol_ref "flag_pic") (const_int 0))
1903            (const_int 20)]
1904           (const_int 28)))])
1905
1906 (define_insn ""
1907   [(set (pc)
1908         (if_then_else
1909          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
1910                               (const_int 1)
1911                               (match_operand:DI 1 "uint32_operand" ""))
1912              (const_int 0))
1913          (label_ref (match_operand 2 "" ""))
1914          (pc)))]
1915   "TARGET_64BIT"
1916   "*
1917 {
1918   return output_bb (operands, 0, insn, 0);
1919 }"
1920 [(set_attr "type" "cbranch")
1921  (set (attr "length")
1922     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1923                (const_int MAX_12BIT_OFFSET))
1924            (const_int 4)
1925            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1926                (const_int MAX_17BIT_OFFSET))
1927            (const_int 8)
1928            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1929            (const_int 24)
1930            (eq (symbol_ref "flag_pic") (const_int 0))
1931            (const_int 20)]
1932           (const_int 28)))])
1933
1934 (define_insn ""
1935   [(set (pc)
1936         (if_then_else
1937          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1938                               (const_int 1)
1939                               (match_operand:SI 1 "uint5_operand" ""))
1940              (const_int 0))
1941          (pc)
1942          (label_ref (match_operand 2 "" ""))))]
1943   ""
1944   "*
1945 {
1946   return output_bb (operands, 1, insn, 0);
1947 }"
1948 [(set_attr "type" "cbranch")
1949  (set (attr "length")
1950     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1951                (const_int MAX_12BIT_OFFSET))
1952            (const_int 4)
1953            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1954                (const_int MAX_17BIT_OFFSET))
1955            (const_int 8)
1956            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1957            (const_int 24)
1958            (eq (symbol_ref "flag_pic") (const_int 0))
1959            (const_int 20)]
1960           (const_int 28)))])
1961
1962 (define_insn ""
1963   [(set (pc)
1964         (if_then_else
1965          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
1966                               (const_int 1)
1967                               (match_operand:DI 1 "uint32_operand" ""))
1968              (const_int 0))
1969          (pc)
1970          (label_ref (match_operand 2 "" ""))))]
1971   "TARGET_64BIT"
1972   "*
1973 {
1974   return output_bb (operands, 1, insn, 0);
1975 }"
1976 [(set_attr "type" "cbranch")
1977  (set (attr "length")
1978     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1979                (const_int MAX_12BIT_OFFSET))
1980            (const_int 4)
1981            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1982                (const_int MAX_17BIT_OFFSET))
1983            (const_int 8)
1984            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
1985            (const_int 24)
1986            (eq (symbol_ref "flag_pic") (const_int 0))
1987            (const_int 20)]
1988           (const_int 28)))])
1989
1990 (define_insn ""
1991   [(set (pc)
1992         (if_then_else
1993          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1994                               (const_int 1)
1995                               (match_operand:SI 1 "uint5_operand" ""))
1996              (const_int 0))
1997          (label_ref (match_operand 2 "" ""))
1998          (pc)))]
1999   ""
2000   "*
2001 {
2002   return output_bb (operands, 0, insn, 1);
2003 }"
2004 [(set_attr "type" "cbranch")
2005  (set (attr "length")
2006     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2007                (const_int MAX_12BIT_OFFSET))
2008            (const_int 4)
2009            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2010                (const_int MAX_17BIT_OFFSET))
2011            (const_int 8)
2012            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2013            (const_int 24)
2014            (eq (symbol_ref "flag_pic") (const_int 0))
2015            (const_int 20)]
2016           (const_int 28)))])
2017
2018 (define_insn ""
2019   [(set (pc)
2020         (if_then_else
2021          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2022                               (const_int 1)
2023                               (match_operand:DI 1 "uint32_operand" ""))
2024              (const_int 0))
2025          (label_ref (match_operand 2 "" ""))
2026          (pc)))]
2027   "TARGET_64BIT"
2028   "*
2029 {
2030   return output_bb (operands, 0, insn, 1);
2031 }"
2032 [(set_attr "type" "cbranch")
2033  (set (attr "length")
2034     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2035                (const_int MAX_12BIT_OFFSET))
2036            (const_int 4)
2037            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2038                (const_int MAX_17BIT_OFFSET))
2039            (const_int 8)
2040            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2041            (const_int 24)
2042            (eq (symbol_ref "flag_pic") (const_int 0))
2043            (const_int 20)]
2044           (const_int 28)))])
2045
2046 (define_insn ""
2047   [(set (pc)
2048         (if_then_else
2049          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2050                               (const_int 1)
2051                               (match_operand:SI 1 "uint5_operand" ""))
2052              (const_int 0))
2053          (pc)
2054          (label_ref (match_operand 2 "" ""))))]
2055   ""
2056   "*
2057 {
2058   return output_bb (operands, 1, insn, 1);
2059 }"
2060 [(set_attr "type" "cbranch")
2061  (set (attr "length")
2062     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2063                (const_int MAX_12BIT_OFFSET))
2064            (const_int 4)
2065            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2066                (const_int MAX_17BIT_OFFSET))
2067            (const_int 8)
2068            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2069            (const_int 24)
2070            (eq (symbol_ref "flag_pic") (const_int 0))
2071            (const_int 20)]
2072           (const_int 28)))])
2073
2074 (define_insn ""
2075   [(set (pc)
2076         (if_then_else
2077          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2078                               (const_int 1)
2079                               (match_operand:DI 1 "uint32_operand" ""))
2080              (const_int 0))
2081          (pc)
2082          (label_ref (match_operand 2 "" ""))))]
2083   "TARGET_64BIT"
2084   "*
2085 {
2086   return output_bb (operands, 1, insn, 1);
2087 }"
2088 [(set_attr "type" "cbranch")
2089  (set (attr "length")
2090     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2091                (const_int MAX_12BIT_OFFSET))
2092            (const_int 4)
2093            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2094                (const_int MAX_17BIT_OFFSET))
2095            (const_int 8)
2096            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2097            (const_int 24)
2098            (eq (symbol_ref "flag_pic") (const_int 0))
2099            (const_int 20)]
2100           (const_int 28)))])
2101
2102 ;; Branch on Variable Bit patterns.
2103 (define_insn ""
2104   [(set (pc)
2105         (if_then_else
2106          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2107                               (const_int 1)
2108                               (match_operand:SI 1 "register_operand" "q"))
2109              (const_int 0))
2110          (label_ref (match_operand 2 "" ""))
2111          (pc)))]
2112   ""
2113   "*
2114 {
2115   return output_bvb (operands, 0, insn, 0);
2116 }"
2117 [(set_attr "type" "cbranch")
2118  (set (attr "length")
2119     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2120                (const_int MAX_12BIT_OFFSET))
2121            (const_int 4)
2122            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2123                (const_int MAX_17BIT_OFFSET))
2124            (const_int 8)
2125            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2126            (const_int 24)
2127            (eq (symbol_ref "flag_pic") (const_int 0))
2128            (const_int 20)]
2129           (const_int 28)))])
2130
2131 (define_insn ""
2132   [(set (pc)
2133         (if_then_else
2134          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2135                               (const_int 1)
2136                               (match_operand:DI 1 "register_operand" "q"))
2137              (const_int 0))
2138          (label_ref (match_operand 2 "" ""))
2139          (pc)))]
2140   "TARGET_64BIT"
2141   "*
2142 {
2143   return output_bvb (operands, 0, insn, 0);
2144 }"
2145 [(set_attr "type" "cbranch")
2146  (set (attr "length")
2147     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2148                (const_int MAX_12BIT_OFFSET))
2149            (const_int 4)
2150            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2151                (const_int MAX_17BIT_OFFSET))
2152            (const_int 8)
2153            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2154            (const_int 24)
2155            (eq (symbol_ref "flag_pic") (const_int 0))
2156            (const_int 20)]
2157           (const_int 28)))])
2158
2159 (define_insn ""
2160   [(set (pc)
2161         (if_then_else
2162          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2163                               (const_int 1)
2164                               (match_operand:SI 1 "register_operand" "q"))
2165              (const_int 0))
2166          (pc)
2167          (label_ref (match_operand 2 "" ""))))]
2168   ""
2169   "*
2170 {
2171   return output_bvb (operands, 1, insn, 0);
2172 }"
2173 [(set_attr "type" "cbranch")
2174  (set (attr "length")
2175     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2176                (const_int MAX_12BIT_OFFSET))
2177            (const_int 4)
2178            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2179                (const_int MAX_17BIT_OFFSET))
2180            (const_int 8)
2181            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2182            (const_int 24)
2183            (eq (symbol_ref "flag_pic") (const_int 0))
2184            (const_int 20)]
2185           (const_int 28)))])
2186
2187 (define_insn ""
2188   [(set (pc)
2189         (if_then_else
2190          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2191                               (const_int 1)
2192                               (match_operand:DI 1 "register_operand" "q"))
2193              (const_int 0))
2194          (pc)
2195          (label_ref (match_operand 2 "" ""))))]
2196   "TARGET_64BIT"
2197   "*
2198 {
2199   return output_bvb (operands, 1, insn, 0);
2200 }"
2201 [(set_attr "type" "cbranch")
2202  (set (attr "length")
2203     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2204                (const_int MAX_12BIT_OFFSET))
2205            (const_int 4)
2206            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2207                (const_int MAX_17BIT_OFFSET))
2208            (const_int 8)
2209            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2210            (const_int 24)
2211            (eq (symbol_ref "flag_pic") (const_int 0))
2212            (const_int 20)]
2213           (const_int 28)))])
2214
2215 (define_insn ""
2216   [(set (pc)
2217         (if_then_else
2218          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2219                               (const_int 1)
2220                               (match_operand:SI 1 "register_operand" "q"))
2221              (const_int 0))
2222          (label_ref (match_operand 2 "" ""))
2223          (pc)))]
2224   ""
2225   "*
2226 {
2227   return output_bvb (operands, 0, insn, 1);
2228 }"
2229 [(set_attr "type" "cbranch")
2230  (set (attr "length")
2231     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2232                (const_int MAX_12BIT_OFFSET))
2233            (const_int 4)
2234            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2235                (const_int MAX_17BIT_OFFSET))
2236            (const_int 8)
2237            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2238            (const_int 24)
2239            (eq (symbol_ref "flag_pic") (const_int 0))
2240            (const_int 20)]
2241           (const_int 28)))])
2242
2243 (define_insn ""
2244   [(set (pc)
2245         (if_then_else
2246          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2247                               (const_int 1)
2248                               (match_operand:DI 1 "register_operand" "q"))
2249              (const_int 0))
2250          (label_ref (match_operand 2 "" ""))
2251          (pc)))]
2252   "TARGET_64BIT"
2253   "*
2254 {
2255   return output_bvb (operands, 0, insn, 1);
2256 }"
2257 [(set_attr "type" "cbranch")
2258  (set (attr "length")
2259     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2260                (const_int MAX_12BIT_OFFSET))
2261            (const_int 4)
2262            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2263                (const_int MAX_17BIT_OFFSET))
2264            (const_int 8)
2265            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2266            (const_int 24)
2267            (eq (symbol_ref "flag_pic") (const_int 0))
2268            (const_int 20)]
2269           (const_int 28)))])
2270
2271 (define_insn ""
2272   [(set (pc)
2273         (if_then_else
2274          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2275                               (const_int 1)
2276                               (match_operand:SI 1 "register_operand" "q"))
2277              (const_int 0))
2278          (pc)
2279          (label_ref (match_operand 2 "" ""))))]
2280   ""
2281   "*
2282 {
2283   return output_bvb (operands, 1, insn, 1);
2284 }"
2285 [(set_attr "type" "cbranch")
2286  (set (attr "length")
2287     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2288                (const_int MAX_12BIT_OFFSET))
2289            (const_int 4)
2290            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2291                (const_int MAX_17BIT_OFFSET))
2292            (const_int 8)
2293            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2294            (const_int 24)
2295            (eq (symbol_ref "flag_pic") (const_int 0))
2296            (const_int 20)]
2297           (const_int 28)))])
2298
2299 (define_insn ""
2300   [(set (pc)
2301         (if_then_else
2302          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2303                               (const_int 1)
2304                               (match_operand:DI 1 "register_operand" "q"))
2305              (const_int 0))
2306          (pc)
2307          (label_ref (match_operand 2 "" ""))))]
2308   "TARGET_64BIT"
2309   "*
2310 {
2311   return output_bvb (operands, 1, insn, 1);
2312 }"
2313 [(set_attr "type" "cbranch")
2314  (set (attr "length")
2315     (cond [(lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2316                (const_int MAX_12BIT_OFFSET))
2317            (const_int 4)
2318            (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2319                (const_int MAX_17BIT_OFFSET))
2320            (const_int 8)
2321            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2322            (const_int 24)
2323            (eq (symbol_ref "flag_pic") (const_int 0))
2324            (const_int 20)]
2325           (const_int 28)))])
2326
2327 ;; Floating point branches
2328
2329 ;; ??? Nullification is handled differently from other branches.
2330 ;; If nullification is specified, the delay slot is nullified on any
2331 ;; taken branch regardless of branch direction.
2332 (define_insn ""
2333   [(set (pc) (if_then_else (ne (reg:CCFP 0) (const_int 0))
2334                            (label_ref (match_operand 0 "" ""))
2335                            (pc)))]
2336   "!TARGET_SOFT_FLOAT"
2337   "*
2338 {
2339   int length = get_attr_length (insn);
2340   rtx xoperands[1];
2341   int nullify, xdelay;
2342
2343   if (length < 16)
2344     return \"ftest\;b%* %l0\";
2345
2346   if (dbr_sequence_length () == 0 || INSN_ANNULLED_BRANCH_P (insn))
2347     {
2348       nullify = 1;
2349       xdelay = 0;
2350       xoperands[0] = GEN_INT (length - 8);
2351     }
2352   else
2353     {
2354       nullify = 0;
2355       xdelay = 1;
2356       xoperands[0] = GEN_INT (length - 4);
2357     }
2358
2359   if (nullify)
2360     output_asm_insn (\"ftest\;add,tr %%r0,%%r0,%%r0\;b,n .+%0\", xoperands);
2361   else
2362     output_asm_insn (\"ftest\;add,tr %%r0,%%r0,%%r0\;b .+%0\", xoperands);
2363   return output_lbranch (operands[0], insn, xdelay);
2364 }"
2365 [(set_attr "type" "fbranch")
2366  (set (attr "length")
2367     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
2368                (const_int MAX_17BIT_OFFSET))
2369            (const_int 8)
2370            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2371            (const_int 32)
2372            (eq (symbol_ref "flag_pic") (const_int 0))
2373            (const_int 28)]
2374           (const_int 36)))])
2375
2376 (define_insn ""
2377   [(set (pc) (if_then_else (ne (reg:CCFP 0) (const_int 0))
2378                            (pc)
2379                            (label_ref (match_operand 0 "" ""))))]
2380   "!TARGET_SOFT_FLOAT"
2381   "*
2382 {
2383   int length = get_attr_length (insn);
2384   rtx xoperands[1];
2385   int nullify, xdelay;
2386
2387   if (length < 16)
2388     return \"ftest\;add,tr %%r0,%%r0,%%r0\;b%* %0\";
2389
2390   if (dbr_sequence_length () == 0 || INSN_ANNULLED_BRANCH_P (insn))
2391     {
2392       nullify = 1;
2393       xdelay = 0;
2394       xoperands[0] = GEN_INT (length - 4);
2395     }
2396   else
2397     {
2398       nullify = 0;
2399       xdelay = 1;
2400       xoperands[0] = GEN_INT (length);
2401     }
2402
2403   if (nullify)
2404     output_asm_insn (\"ftest\;b,n .+%0\", xoperands);
2405   else
2406     output_asm_insn (\"ftest\;b .+%0\", xoperands);
2407   return output_lbranch (operands[0], insn, xdelay);
2408 }"
2409 [(set_attr "type" "fbranch")
2410  (set (attr "length")
2411     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
2412                (const_int MAX_17BIT_OFFSET))
2413            (const_int 12)
2414            (ne (symbol_ref "TARGET_PORTABLE_RUNTIME") (const_int 0))
2415            (const_int 28)
2416            (eq (symbol_ref "flag_pic") (const_int 0))
2417            (const_int 24)]
2418           (const_int 32)))])
2419
2420 ;; Move instructions
2421
2422 (define_expand "movsi"
2423   [(set (match_operand:SI 0 "general_operand" "")
2424         (match_operand:SI 1 "general_operand" ""))]
2425   ""
2426   "
2427 {
2428   if (emit_move_sequence (operands, SImode, 0))
2429     DONE;
2430 }")
2431
2432 ;; Handle SImode input reloads requiring %r1 as a scratch register.
2433 (define_expand "reload_insi_r1"
2434   [(set (match_operand:SI 0 "register_operand" "=Z")
2435         (match_operand:SI 1 "non_hard_reg_operand" ""))
2436    (clobber (match_operand:SI 2 "register_operand" "=&a"))]
2437   ""
2438   "
2439 {
2440   if (emit_move_sequence (operands, SImode, operands[2]))
2441     DONE;
2442
2443   /* We don't want the clobber emitted, so handle this ourselves.  */
2444   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
2445   DONE;
2446 }")
2447
2448 ;; Handle SImode input reloads requiring a general register as a
2449 ;; scratch register.
2450 (define_expand "reload_insi"
2451   [(set (match_operand:SI 0 "register_operand" "=Z")
2452         (match_operand:SI 1 "non_hard_reg_operand" ""))
2453    (clobber (match_operand:SI 2 "register_operand" "=&r"))]
2454   ""
2455   "
2456 {
2457   if (emit_move_sequence (operands, SImode, operands[2]))
2458     DONE;
2459
2460   /* We don't want the clobber emitted, so handle this ourselves.  */
2461   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
2462   DONE;
2463 }")
2464
2465 ;; Handle SImode output reloads requiring a general register as a
2466 ;; scratch register.
2467 (define_expand "reload_outsi"
2468   [(set (match_operand:SI 0 "non_hard_reg_operand" "")
2469         (match_operand:SI 1  "register_operand" "Z"))
2470    (clobber (match_operand:SI 2 "register_operand" "=&r"))]
2471   ""
2472   "
2473 {
2474   if (emit_move_sequence (operands, SImode, operands[2]))
2475     DONE;
2476
2477   /* We don't want the clobber emitted, so handle this ourselves.  */
2478   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
2479   DONE;
2480 }")
2481
2482 (define_insn ""
2483   [(set (match_operand:SI 0 "move_dest_operand"
2484                           "=r,r,r,r,r,r,Q,!*q,!r,!*f,*f,T,!r,!f")
2485         (match_operand:SI 1 "move_src_operand"
2486                           "A,r,J,N,K,RQ,rM,!rM,!*q,!*fM,RT,*f,!f,!r"))]
2487   "(register_operand (operands[0], SImode)
2488     || reg_or_0_operand (operands[1], SImode))
2489    && !TARGET_SOFT_FLOAT
2490    && !TARGET_64BIT"
2491   "@
2492    ldw RT'%A1,%0
2493    copy %1,%0
2494    ldi %1,%0
2495    ldil L'%1,%0
2496    {zdepi|depwi,z} %Z1,%0
2497    ldw%M1 %1,%0
2498    stw%M0 %r1,%0
2499    mtsar %r1
2500    {mfctl|mfctl,w} %%sar,%0
2501    fcpy,sgl %f1,%0
2502    fldw%F1 %1,%0
2503    fstw%F0 %1,%0
2504    {fstws|fstw} %1,-16(%%sp)\n\t{ldws|ldw} -16(%%sp),%0
2505    {stws|stw} %1,-16(%%sp)\n\t{fldws|fldw} -16(%%sp),%0"
2506   [(set_attr "type" "load,move,move,move,shift,load,store,move,move,fpalu,fpload,fpstore,move,move")
2507    (set_attr "pa_combine_type" "addmove")
2508    (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,8,8")])
2509
2510 (define_insn ""
2511   [(set (match_operand:SI 0 "move_dest_operand"
2512                           "=r,r,r,r,r,r,Q,!*q,!r,!*f,*f,T")
2513         (match_operand:SI 1 "move_src_operand"
2514                           "A,r,J,N,K,RQ,rM,!rM,!*q,!*fM,RT,*f"))]
2515   "(register_operand (operands[0], SImode)
2516     || reg_or_0_operand (operands[1], SImode))
2517    && !TARGET_SOFT_FLOAT
2518    && TARGET_64BIT"
2519   "@
2520    ldw RT'%A1,%0
2521    copy %1,%0
2522    ldi %1,%0
2523    ldil L'%1,%0
2524    {zdepi|depwi,z} %Z1,%0
2525    ldw%M1 %1,%0
2526    stw%M0 %r1,%0
2527    mtsar %r1
2528    {mfctl|mfctl,w} %%sar,%0
2529    fcpy,sgl %f1,%0
2530    fldw%F1 %1,%0
2531    fstw%F0 %1,%0"
2532   [(set_attr "type" "load,move,move,move,shift,load,store,move,move,fpalu,fpload,fpstore")
2533    (set_attr "pa_combine_type" "addmove")
2534    (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4")])
2535
2536 (define_insn ""
2537   [(set (match_operand:SI 0 "indexed_memory_operand" "=R")
2538         (match_operand:SI 1 "register_operand" "f"))]
2539   "!TARGET_SOFT_FLOAT
2540    && !TARGET_DISABLE_INDEXING
2541    && reload_completed"
2542   "fstw%F0 %1,%0"
2543   [(set_attr "type" "fpstore")
2544    (set_attr "pa_combine_type" "addmove")
2545    (set_attr "length" "4")])
2546
2547 ; Rewrite RTL using an indexed store.  This will allow the insn that
2548 ; computes the address to be deleted if the register it sets is dead.
2549 (define_peephole2
2550   [(set (match_operand:SI 0 "register_operand" "")
2551         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
2552                           (const_int 4))
2553                  (match_operand:SI 2 "register_operand" "")))
2554    (set (mem:SI (match_dup 0))
2555         (match_operand:SI 3 "register_operand" ""))]
2556   "!TARGET_SOFT_FLOAT
2557    && !TARGET_DISABLE_INDEXING
2558    && REG_OK_FOR_BASE_P (operands[2])
2559    && FP_REGNO_P (REGNO (operands[3]))"
2560   [(set (mem:SI (plus:SI (mult:SI (match_dup 1) (const_int 4)) (match_dup 2)))
2561         (match_dup 3))
2562    (set (match_dup 0) (plus:SI (mult:SI (match_dup 1) (const_int 4))
2563                                (match_dup 2)))]
2564   "")
2565
2566 (define_peephole2
2567   [(set (match_operand:SI 0 "register_operand" "")
2568         (plus:SI (match_operand:SI 2 "register_operand" "")
2569                  (mult:SI (match_operand:SI 1 "register_operand" "")
2570                           (const_int 4))))
2571    (set (mem:SI (match_dup 0))
2572         (match_operand:SI 3 "register_operand" ""))]
2573   "!TARGET_SOFT_FLOAT
2574    && !TARGET_DISABLE_INDEXING
2575    && REG_OK_FOR_BASE_P (operands[2])
2576    && FP_REGNO_P (REGNO (operands[3]))"
2577   [(set (mem:SI (plus:SI (mult:SI (match_dup 1) (const_int 4)) (match_dup 2)))
2578         (match_dup 3))
2579    (set (match_dup 0) (plus:SI (mult:SI (match_dup 1) (const_int 4))
2580                                (match_dup 2)))]
2581   "")
2582
2583 (define_peephole2
2584   [(set (match_operand:DI 0 "register_operand" "")
2585         (plus:DI (mult:DI (match_operand:DI 1 "register_operand" "")
2586                           (const_int 4))
2587                  (match_operand:DI 2 "register_operand" "")))
2588    (set (mem:SI (match_dup 0))
2589         (match_operand:SI 3 "register_operand" ""))]
2590   "!TARGET_SOFT_FLOAT
2591    && !TARGET_DISABLE_INDEXING
2592    && TARGET_64BIT
2593    && REG_OK_FOR_BASE_P (operands[2])
2594    && FP_REGNO_P (REGNO (operands[3]))"
2595   [(set (mem:SI (plus:DI (mult:DI (match_dup 1) (const_int 4)) (match_dup 2)))
2596         (match_dup 3))
2597    (set (match_dup 0) (plus:DI (mult:DI (match_dup 1) (const_int 4))
2598                                (match_dup 2)))]
2599   "")
2600
2601 (define_peephole2
2602   [(set (match_operand:DI 0 "register_operand" "")
2603         (plus:DI (match_operand:DI 2 "register_operand" "")
2604                  (mult:DI (match_operand:DI 1 "register_operand" "")
2605                           (const_int 4))))
2606    (set (mem:SI (match_dup 0))
2607         (match_operand:SI 3 "register_operand" ""))]
2608   "!TARGET_SOFT_FLOAT
2609    && !TARGET_DISABLE_INDEXING
2610    && TARGET_64BIT
2611    && REG_OK_FOR_BASE_P (operands[2])
2612    && FP_REGNO_P (REGNO (operands[3]))"
2613   [(set (mem:SI (plus:DI (mult:DI (match_dup 1) (const_int 4)) (match_dup 2)))
2614         (match_dup 3))
2615    (set (match_dup 0) (plus:DI (mult:DI (match_dup 1) (const_int 4))
2616                                (match_dup 2)))]
2617   "")
2618
2619 (define_peephole2
2620   [(set (match_operand:SI 0 "register_operand" "")
2621         (plus:SI (match_operand:SI 1 "register_operand" "")
2622                  (match_operand:SI 2 "register_operand" "")))
2623    (set (mem:SI (match_dup 0))
2624         (match_operand:SI 3 "register_operand" ""))]
2625   "!TARGET_SOFT_FLOAT
2626    && !TARGET_DISABLE_INDEXING
2627    && TARGET_NO_SPACE_REGS
2628    && REG_OK_FOR_INDEX_P (operands[1])
2629    && REG_OK_FOR_BASE_P (operands[2])
2630    && FP_REGNO_P (REGNO (operands[3]))"
2631   [(set (mem:SI (plus:SI (match_dup 1) (match_dup 2)))
2632         (match_dup 3))
2633    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))]
2634   "")
2635
2636 (define_peephole2
2637   [(set (match_operand:SI 0 "register_operand" "")
2638         (plus:SI (match_operand:SI 1 "register_operand" "")
2639                  (match_operand:SI 2 "register_operand" "")))
2640    (set (mem:SI (match_dup 0))
2641         (match_operand:SI 3 "register_operand" ""))]
2642   "!TARGET_SOFT_FLOAT
2643    && !TARGET_DISABLE_INDEXING
2644    && TARGET_NO_SPACE_REGS
2645    && REG_OK_FOR_BASE_P (operands[1])
2646    && REG_OK_FOR_INDEX_P (operands[2])
2647    && FP_REGNO_P (REGNO (operands[3]))"
2648   [(set (mem:SI (plus:SI (match_dup 2) (match_dup 1)))
2649         (match_dup 3))
2650    (set (match_dup 0) (plus:SI (match_dup 2) (match_dup 1)))]
2651   "")
2652
2653 (define_peephole2
2654   [(set (match_operand:DI 0 "register_operand" "")
2655         (plus:DI (match_operand:DI 1 "register_operand" "")
2656                  (match_operand:DI 2 "register_operand" "")))
2657    (set (mem:SI (match_dup 0))
2658         (match_operand:SI 3 "register_operand" ""))]
2659   "!TARGET_SOFT_FLOAT
2660    && !TARGET_DISABLE_INDEXING
2661    && TARGET_64BIT
2662    && TARGET_NO_SPACE_REGS
2663    && REG_OK_FOR_INDEX_P (operands[1])
2664    && REG_OK_FOR_BASE_P (operands[2])
2665    && FP_REGNO_P (REGNO (operands[3]))"
2666   [(set (mem:SI (plus:DI (match_dup 1) (match_dup 2)))
2667         (match_dup 3))
2668    (set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))]
2669   "")
2670
2671 (define_peephole2
2672   [(set (match_operand:DI 0 "register_operand" "")
2673         (plus:DI (match_operand:DI 1 "register_operand" "")
2674                  (match_operand:DI 2 "register_operand" "")))
2675    (set (mem:SI (match_dup 0))
2676         (match_operand:SI 3 "register_operand" ""))]
2677   "!TARGET_SOFT_FLOAT
2678    && !TARGET_DISABLE_INDEXING
2679    && TARGET_64BIT
2680    && TARGET_NO_SPACE_REGS
2681    && REG_OK_FOR_BASE_P (operands[1])
2682    && REG_OK_FOR_INDEX_P (operands[2])
2683    && FP_REGNO_P (REGNO (operands[3]))"
2684   [(set (mem:SI (plus:DI (match_dup 2) (match_dup 1)))
2685         (match_dup 3))
2686    (set (match_dup 0) (plus:DI (match_dup 2) (match_dup 1)))]
2687   "")
2688
2689 (define_insn ""
2690   [(set (match_operand:SI 0 "move_dest_operand"
2691                           "=r,r,r,r,r,r,Q,!*q,!r")
2692         (match_operand:SI 1 "move_src_operand"
2693                           "A,r,J,N,K,RQ,rM,!rM,!*q"))]
2694   "(register_operand (operands[0], SImode)
2695     || reg_or_0_operand (operands[1], SImode))
2696    && TARGET_SOFT_FLOAT"
2697   "@
2698    ldw RT'%A1,%0
2699    copy %1,%0
2700    ldi %1,%0
2701    ldil L'%1,%0
2702    {zdepi|depwi,z} %Z1,%0
2703    ldw%M1 %1,%0
2704    stw%M0 %r1,%0
2705    mtsar %r1
2706    {mfctl|mfctl,w} %%sar,%0"
2707   [(set_attr "type" "load,move,move,move,move,load,store,move,move")
2708    (set_attr "pa_combine_type" "addmove")
2709    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
2710
2711 ;; Load or store with base-register modification.
2712 (define_insn ""
2713   [(set (match_operand:SI 0 "register_operand" "=r")
2714         (mem:SI (plus:DI (match_operand:DI 1 "register_operand" "+r")
2715                          (match_operand:DI 2 "int5_operand" "L"))))
2716    (set (match_dup 1)
2717         (plus:DI (match_dup 1) (match_dup 2)))]
2718   "TARGET_64BIT"
2719   "ldw,mb %2(%1),%0"
2720   [(set_attr "type" "load")
2721    (set_attr "length" "4")])
2722
2723 ; And a zero extended variant.
2724 (define_insn ""
2725   [(set (match_operand:DI 0 "register_operand" "=r")
2726         (zero_extend:DI (mem:SI
2727                           (plus:DI
2728                             (match_operand:DI 1 "register_operand" "+r")
2729                             (match_operand:DI 2 "int5_operand" "L")))))
2730    (set (match_dup 1)
2731         (plus:DI (match_dup 1) (match_dup 2)))]
2732   "TARGET_64BIT"
2733   "ldw,mb %2(%1),%0"
2734   [(set_attr "type" "load")
2735    (set_attr "length" "4")])
2736
2737 (define_expand "pre_load"
2738   [(parallel [(set (match_operand:SI 0 "register_operand" "")
2739               (mem (plus (match_operand 1 "register_operand" "")
2740                                (match_operand 2 "pre_cint_operand" ""))))
2741               (set (match_dup 1)
2742                    (plus (match_dup 1) (match_dup 2)))])]
2743   ""
2744   "
2745 {
2746   if (TARGET_64BIT)
2747     {
2748       emit_insn (gen_pre_ldd (operands[0], operands[1], operands[2]));
2749       DONE;
2750     }
2751   emit_insn (gen_pre_ldw (operands[0], operands[1], operands[2]));
2752   DONE;
2753 }")
2754
2755 (define_insn "pre_ldw"
2756   [(set (match_operand:SI 0 "register_operand" "=r")
2757         (mem:SI (plus:SI (match_operand:SI 1 "register_operand" "+r")
2758                          (match_operand:SI 2 "pre_cint_operand" ""))))
2759    (set (match_dup 1)
2760         (plus:SI (match_dup 1) (match_dup 2)))]
2761   ""
2762   "*
2763 {
2764   if (INTVAL (operands[2]) < 0)
2765     return \"{ldwm|ldw,mb} %2(%1),%0\";
2766   return \"{ldws|ldw},mb %2(%1),%0\";
2767 }"
2768   [(set_attr "type" "load")
2769    (set_attr "length" "4")])
2770
2771 (define_insn "pre_ldd"
2772   [(set (match_operand:DI 0 "register_operand" "=r")
2773         (mem:DI (plus:DI (match_operand:DI 1 "register_operand" "+r")
2774                          (match_operand:DI 2 "pre_cint_operand" ""))))
2775    (set (match_dup 1)
2776         (plus:DI (match_dup 1) (match_dup 2)))]
2777   "TARGET_64BIT"
2778   "ldd,mb %2(%1),%0"
2779   [(set_attr "type" "load")
2780    (set_attr "length" "4")])
2781
2782 (define_insn ""
2783   [(set (mem:SI (plus:SI (match_operand:SI 0 "register_operand" "+r")
2784                          (match_operand:SI 1 "pre_cint_operand" "")))
2785         (match_operand:SI 2 "reg_or_0_operand" "rM"))
2786    (set (match_dup 0)
2787         (plus:SI (match_dup 0) (match_dup 1)))]
2788   ""
2789   "*
2790 {
2791   if (INTVAL (operands[1]) < 0)
2792     return \"{stwm|stw,mb} %r2,%1(%0)\";
2793   return \"{stws|stw},mb %r2,%1(%0)\";
2794 }"
2795   [(set_attr "type" "store")
2796    (set_attr "length" "4")])
2797
2798 (define_insn ""
2799   [(set (match_operand:SI 0 "register_operand" "=r")
2800         (mem:SI (match_operand:SI 1 "register_operand" "+r")))
2801    (set (match_dup 1)
2802         (plus:SI (match_dup 1)
2803                  (match_operand:SI 2 "post_cint_operand" "")))]
2804   ""
2805   "*
2806 {
2807   if (INTVAL (operands[2]) > 0)
2808     return \"{ldwm|ldw,ma} %2(%1),%0\";
2809   return \"{ldws|ldw},ma %2(%1),%0\";
2810 }"
2811   [(set_attr "type" "load")
2812    (set_attr "length" "4")])
2813
2814 (define_expand "post_store"
2815   [(parallel [(set (mem (match_operand 0 "register_operand" ""))
2816                    (match_operand 1 "reg_or_0_operand" ""))
2817               (set (match_dup 0)
2818                    (plus (match_dup 0)
2819                          (match_operand 2 "post_cint_operand" "")))])]
2820   ""
2821   "
2822 {
2823   if (TARGET_64BIT)
2824     {
2825       emit_insn (gen_post_std (operands[0], operands[1], operands[2]));
2826       DONE;
2827     }
2828   emit_insn (gen_post_stw (operands[0], operands[1], operands[2]));
2829   DONE;
2830 }")
2831
2832 (define_insn "post_stw"
2833   [(set (mem:SI (match_operand:SI 0 "register_operand" "+r"))
2834         (match_operand:SI 1 "reg_or_0_operand" "rM"))
2835    (set (match_dup 0)
2836         (plus:SI (match_dup 0)
2837                  (match_operand:SI 2 "post_cint_operand" "")))]
2838   ""
2839   "*
2840 {
2841   if (INTVAL (operands[2]) > 0)
2842     return \"{stwm|stw,ma} %r1,%2(%0)\";
2843   return \"{stws|stw},ma %r1,%2(%0)\";
2844 }"
2845   [(set_attr "type" "store")
2846    (set_attr "length" "4")])
2847
2848 (define_insn "post_std"
2849   [(set (mem:DI (match_operand:DI 0 "register_operand" "+r"))
2850         (match_operand:DI 1 "reg_or_0_operand" "rM"))
2851    (set (match_dup 0)
2852         (plus:DI (match_dup 0)
2853                  (match_operand:DI 2 "post_cint_operand" "")))]
2854   "TARGET_64BIT"
2855   "std,ma %r1,%2(%0)"
2856   [(set_attr "type" "store")
2857    (set_attr "length" "4")])
2858
2859 ;; For loading the address of a label while generating PIC code.
2860 ;; Note since this pattern can be created at reload time (via movsi), all
2861 ;; the same rules for movsi apply here.  (no new pseudos, no temporaries).
2862 (define_insn ""
2863   [(set (match_operand 0 "pmode_register_operand" "=a")
2864         (match_operand 1 "pic_label_operand" ""))]
2865   "TARGET_PA_20"
2866   "*
2867 {
2868   rtx xoperands[3];
2869
2870   xoperands[0] = operands[0];
2871   xoperands[1] = operands[1];
2872   xoperands[2] = gen_label_rtx ();
2873
2874   (*targetm.asm_out.internal_label) (asm_out_file, \"L\",
2875                                      CODE_LABEL_NUMBER (xoperands[2]));
2876   output_asm_insn (\"mfia %0\", xoperands);
2877
2878   /* If we're trying to load the address of a label that happens to be
2879      close, then we can use a shorter sequence.  */
2880   if (GET_CODE (operands[1]) == LABEL_REF
2881       && !LABEL_REF_NONLOCAL_P (operands[1])
2882       && INSN_ADDRESSES_SET_P ()
2883       && abs (INSN_ADDRESSES (INSN_UID (XEXP (operands[1], 0)))
2884                 - INSN_ADDRESSES (INSN_UID (insn))) < 8100)
2885     output_asm_insn (\"ldo %1-%2(%0),%0\", xoperands);
2886   else
2887     {
2888       output_asm_insn (\"addil L%%%1-%2,%0\", xoperands);
2889       output_asm_insn (\"ldo R%%%1-%2(%0),%0\", xoperands);
2890     }
2891   return \"\";
2892 }"
2893   [(set_attr "type" "multi")
2894    (set_attr "length" "12")])           ; 8 or 12
2895
2896 (define_insn ""
2897   [(set (match_operand 0 "pmode_register_operand" "=a")
2898         (match_operand 1 "pic_label_operand" ""))]
2899   "!TARGET_PA_20"
2900   "*
2901 {
2902   rtx xoperands[3];
2903
2904   xoperands[0] = operands[0];
2905   xoperands[1] = operands[1];
2906   xoperands[2] = gen_label_rtx ();
2907
2908   output_asm_insn (\"bl .+8,%0\", xoperands);
2909   output_asm_insn (\"depi 0,31,2,%0\", xoperands);
2910   (*targetm.asm_out.internal_label) (asm_out_file, \"L\",
2911                                      CODE_LABEL_NUMBER (xoperands[2]));
2912
2913   /* If we're trying to load the address of a label that happens to be
2914      close, then we can use a shorter sequence.  */
2915   if (GET_CODE (operands[1]) == LABEL_REF
2916       && !LABEL_REF_NONLOCAL_P (operands[1])
2917       && INSN_ADDRESSES_SET_P ()
2918       && abs (INSN_ADDRESSES (INSN_UID (XEXP (operands[1], 0)))
2919                 - INSN_ADDRESSES (INSN_UID (insn))) < 8100)
2920     output_asm_insn (\"ldo %1-%2(%0),%0\", xoperands);
2921   else
2922     {
2923       output_asm_insn (\"addil L%%%1-%2,%0\", xoperands);
2924       output_asm_insn (\"ldo R%%%1-%2(%0),%0\", xoperands);
2925     }
2926   return \"\";
2927 }"
2928   [(set_attr "type" "multi")
2929    (set_attr "length" "16")])           ; 12 or 16
2930
2931 (define_insn ""
2932   [(set (match_operand:SI 0 "register_operand" "=a")
2933         (plus:SI (match_operand:SI 1 "register_operand" "r")
2934                  (high:SI (match_operand 2 "" ""))))]
2935   "symbolic_operand (operands[2], Pmode)
2936    && ! function_label_operand (operands[2], Pmode)
2937    && flag_pic"
2938   "addil LT'%G2,%1"
2939   [(set_attr "type" "binary")
2940    (set_attr "length" "4")])
2941
2942 (define_insn ""
2943   [(set (match_operand:DI 0 "register_operand" "=a")
2944         (plus:DI (match_operand:DI 1 "register_operand" "r")
2945                  (high:DI (match_operand 2 "" ""))))]
2946   "symbolic_operand (operands[2], Pmode)
2947    && ! function_label_operand (operands[2], Pmode)
2948    && TARGET_64BIT
2949    && flag_pic"
2950   "addil LT'%G2,%1"
2951   [(set_attr "type" "binary")
2952    (set_attr "length" "4")])
2953
2954 ;; Always use addil rather than ldil;add sequences.  This allows the
2955 ;; HP linker to eliminate the dp relocation if the symbolic operand
2956 ;; lives in the TEXT space.
2957 (define_insn ""
2958   [(set (match_operand:SI 0 "register_operand" "=a")
2959         (high:SI (match_operand 1 "" "")))]
2960   "symbolic_operand (operands[1], Pmode)
2961    && ! function_label_operand (operands[1], Pmode)
2962    && ! read_only_operand (operands[1], Pmode)
2963    && ! flag_pic"
2964   "*
2965 {
2966   if (TARGET_LONG_LOAD_STORE)
2967     return \"addil NLR'%H1,%%r27\;ldo N'%H1(%%r1),%%r1\";
2968   else
2969     return \"addil LR'%H1,%%r27\";
2970 }"
2971   [(set_attr "type" "binary")
2972    (set (attr "length")
2973       (if_then_else (eq (symbol_ref "TARGET_LONG_LOAD_STORE") (const_int 0))
2974                     (const_int 4)
2975                     (const_int 8)))])
2976
2977
2978 ;; This is for use in the prologue/epilogue code.  We need it
2979 ;; to add large constants to a stack pointer or frame pointer.
2980 ;; Because of the additional %r1 pressure, we probably do not
2981 ;; want to use this in general code, so make it available
2982 ;; only after reload.
2983 (define_insn ""
2984   [(set (match_operand:SI 0 "register_operand" "=!a,*r")
2985         (plus:SI (match_operand:SI 1 "register_operand" "r,r")
2986                  (high:SI (match_operand 2 "const_int_operand" ""))))]
2987   "reload_completed"
2988   "@
2989    addil L'%G2,%1
2990    ldil L'%G2,%0\;{addl|add,l} %0,%1,%0"
2991   [(set_attr "type" "binary,binary")
2992    (set_attr "length" "4,8")])
2993
2994 (define_insn ""
2995   [(set (match_operand:DI 0 "register_operand" "=!a,*r")
2996         (plus:DI (match_operand:DI 1 "register_operand" "r,r")
2997                  (high:DI (match_operand 2 "const_int_operand" ""))))]
2998   "reload_completed && TARGET_64BIT"
2999   "@
3000    addil L'%G2,%1
3001    ldil L'%G2,%0\;{addl|add,l} %0,%1,%0"
3002   [(set_attr "type" "binary,binary")
3003    (set_attr "length" "4,8")])
3004
3005 (define_insn ""
3006   [(set (match_operand:SI 0 "register_operand" "=r")
3007         (high:SI (match_operand 1 "" "")))]
3008   "(!flag_pic || !symbolic_operand (operands[1], Pmode))
3009     && !is_function_label_plus_const (operands[1])"
3010   "*
3011 {
3012   if (symbolic_operand (operands[1], Pmode))
3013     return \"ldil LR'%H1,%0\";
3014   else
3015     return \"ldil L'%G1,%0\";
3016 }"
3017   [(set_attr "type" "move")
3018    (set_attr "length" "4")])
3019
3020 (define_insn ""
3021   [(set (match_operand:DI 0 "register_operand" "=r")
3022         (high:DI (match_operand 1 "const_int_operand" "")))]
3023   "TARGET_64BIT"
3024   "ldil L'%G1,%0";
3025   [(set_attr "type" "move")
3026    (set_attr "length" "4")])
3027
3028 (define_insn ""
3029   [(set (match_operand:DI 0 "register_operand" "=r")
3030         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
3031                    (match_operand:DI 2 "const_int_operand" "i")))]
3032   "TARGET_64BIT"
3033   "ldo R'%G2(%1),%0";
3034   [(set_attr "type" "move")
3035    (set_attr "length" "4")])
3036
3037 (define_insn ""
3038   [(set (match_operand:SI 0 "register_operand" "=r")
3039         (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
3040                    (match_operand:SI 2 "immediate_operand" "i")))]
3041   "!is_function_label_plus_const (operands[2])"
3042   "*
3043 {
3044   gcc_assert (!flag_pic || !symbolic_operand (operands[2], Pmode));
3045
3046   if (symbolic_operand (operands[2], Pmode))
3047     return \"ldo RR'%G2(%1),%0\";
3048   else
3049     return \"ldo R'%G2(%1),%0\";
3050 }"
3051   [(set_attr "type" "move")
3052    (set_attr "length" "4")])
3053
3054 ;; Now that a symbolic_address plus a constant is broken up early
3055 ;; in the compilation phase (for better CSE) we need a special
3056 ;; combiner pattern to load the symbolic address plus the constant
3057 ;; in only 2 instructions. (For cases where the symbolic address
3058 ;; was not a common subexpression.)
3059 (define_split
3060   [(set (match_operand:SI 0 "register_operand" "")
3061         (match_operand:SI 1 "symbolic_operand" ""))
3062    (clobber (match_operand:SI 2 "register_operand" ""))]
3063   "! (flag_pic && pic_label_operand (operands[1], SImode))"
3064   [(set (match_dup 2) (high:SI (match_dup 1)))
3065    (set (match_dup 0) (lo_sum:SI (match_dup 2) (match_dup 1)))]
3066   "")
3067
3068 ;; hppa_legitimize_address goes to a great deal of trouble to
3069 ;; create addresses which use indexing.  In some cases, this
3070 ;; is a lose because there isn't any store instructions which
3071 ;; allow indexed addresses (with integer register source).
3072 ;;
3073 ;; These define_splits try to turn a 3 insn store into
3074 ;; a 2 insn store with some creative RTL rewriting.
3075 (define_split
3076   [(set (mem:SI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
3077                                (match_operand:SI 1 "shadd_operand" ""))
3078                    (plus:SI (match_operand:SI 2 "register_operand" "")
3079                             (match_operand:SI 3 "const_int_operand" ""))))
3080         (match_operand:SI 4 "register_operand" ""))
3081    (clobber (match_operand:SI 5 "register_operand" ""))]
3082   ""
3083   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
3084                                (match_dup 2)))
3085    (set (mem:SI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
3086   "")
3087
3088 (define_split
3089   [(set (mem:HI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
3090                                (match_operand:SI 1 "shadd_operand" ""))
3091                    (plus:SI (match_operand:SI 2 "register_operand" "")
3092                             (match_operand:SI 3 "const_int_operand" ""))))
3093         (match_operand:HI 4 "register_operand" ""))
3094    (clobber (match_operand:SI 5 "register_operand" ""))]
3095   ""
3096   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
3097                                (match_dup 2)))
3098    (set (mem:HI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
3099   "")
3100
3101 (define_split
3102   [(set (mem:QI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
3103                                (match_operand:SI 1 "shadd_operand" ""))
3104                    (plus:SI (match_operand:SI 2 "register_operand" "")
3105                             (match_operand:SI 3 "const_int_operand" ""))))
3106         (match_operand:QI 4 "register_operand" ""))
3107    (clobber (match_operand:SI 5 "register_operand" ""))]
3108   ""
3109   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
3110                                (match_dup 2)))
3111    (set (mem:QI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
3112   "")
3113
3114 (define_expand "movhi"
3115   [(set (match_operand:HI 0 "general_operand" "")
3116         (match_operand:HI 1 "general_operand" ""))]
3117   ""
3118   "
3119 {
3120   if (emit_move_sequence (operands, HImode, 0))
3121     DONE;
3122 }")
3123
3124 (define_insn ""
3125   [(set (match_operand:HI 0 "move_dest_operand"
3126                           "=r,r,r,r,r,Q,!*q,!r,!*f,!r,!f")
3127         (match_operand:HI 1 "move_src_operand"
3128                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM,!f,!r"))]
3129   "(register_operand (operands[0], HImode)
3130     || reg_or_0_operand (operands[1], HImode))
3131    && !TARGET_SOFT_FLOAT
3132    && !TARGET_64BIT"
3133   "@
3134    copy %1,%0
3135    ldi %1,%0
3136    ldil L'%1,%0
3137    {zdepi|depwi,z} %Z1,%0
3138    ldh%M1 %1,%0
3139    sth%M0 %r1,%0
3140    mtsar %r1
3141    {mfctl|mfctl,w} %sar,%0
3142    fcpy,sgl %f1,%0
3143    {fstws|fstw} %1,-16(%%sp)\n\t{ldws|ldw} -16(%%sp),%0
3144    {stws|stw} %1,-16(%%sp)\n\t{fldws|fldw} -16(%%sp),%0"
3145   [(set_attr "type" "move,move,move,shift,load,store,move,move,move,move,move")
3146    (set_attr "pa_combine_type" "addmove")
3147    (set_attr "length" "4,4,4,4,4,4,4,4,4,8,8")])
3148
3149 (define_insn ""
3150   [(set (match_operand:HI 0 "move_dest_operand"
3151                           "=r,r,r,r,r,Q,!*q,!r,!*f")
3152         (match_operand:HI 1 "move_src_operand"
3153                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM"))]
3154   "(register_operand (operands[0], HImode)
3155     || reg_or_0_operand (operands[1], HImode))
3156    && !TARGET_SOFT_FLOAT
3157    && TARGET_64BIT"
3158   "@
3159    copy %1,%0
3160    ldi %1,%0
3161    ldil L'%1,%0
3162    {zdepi|depwi,z} %Z1,%0
3163    ldh%M1 %1,%0
3164    sth%M0 %r1,%0
3165    mtsar %r1
3166    {mfctl|mfctl,w} %sar,%0
3167    fcpy,sgl %f1,%0"
3168   [(set_attr "type" "move,move,move,shift,load,store,move,move,move")
3169    (set_attr "pa_combine_type" "addmove")
3170    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
3171
3172 (define_insn ""
3173   [(set (match_operand:HI 0 "move_dest_operand"
3174                           "=r,r,r,r,r,Q,!*q,!r")
3175         (match_operand:HI 1 "move_src_operand"
3176                           "r,J,N,K,RQ,rM,!rM,!*q"))]
3177   "(register_operand (operands[0], HImode)
3178     || reg_or_0_operand (operands[1], HImode))
3179    && TARGET_SOFT_FLOAT"
3180   "@
3181    copy %1,%0
3182    ldi %1,%0
3183    ldil L'%1,%0
3184    {zdepi|depwi,z} %Z1,%0
3185    ldh%M1 %1,%0
3186    sth%M0 %r1,%0
3187    mtsar %r1
3188    {mfctl|mfctl,w} %sar,%0"
3189   [(set_attr "type" "move,move,move,shift,load,store,move,move")
3190    (set_attr "pa_combine_type" "addmove")
3191    (set_attr "length" "4,4,4,4,4,4,4,4")])
3192
3193 (define_insn ""
3194   [(set (match_operand:HI 0 "register_operand" "=r")
3195         (mem:HI (plus:SI (match_operand:SI 1 "register_operand" "+r")
3196                          (match_operand:SI 2 "int5_operand" "L"))))
3197    (set (match_dup 1)
3198         (plus:SI (match_dup 1) (match_dup 2)))]
3199   ""
3200   "{ldhs|ldh},mb %2(%1),%0"
3201   [(set_attr "type" "load")
3202    (set_attr "length" "4")])
3203
3204 (define_insn ""
3205   [(set (match_operand:HI 0 "register_operand" "=r")
3206         (mem:HI (plus:DI (match_operand:DI 1 "register_operand" "+r")
3207                          (match_operand:DI 2 "int5_operand" "L"))))
3208    (set (match_dup 1)
3209         (plus:DI (match_dup 1) (match_dup 2)))]
3210   "TARGET_64BIT"
3211   "ldh,mb %2(%1),%0"
3212   [(set_attr "type" "load")
3213    (set_attr "length" "4")])
3214
3215 ; And a zero extended variant.
3216 (define_insn ""
3217   [(set (match_operand:DI 0 "register_operand" "=r")
3218         (zero_extend:DI (mem:HI
3219                           (plus:DI
3220                             (match_operand:DI 1 "register_operand" "+r")
3221                             (match_operand:DI 2 "int5_operand" "L")))))
3222    (set (match_dup 1)
3223         (plus:DI (match_dup 1) (match_dup 2)))]
3224   "TARGET_64BIT"
3225   "ldh,mb %2(%1),%0"
3226   [(set_attr "type" "load")
3227    (set_attr "length" "4")])
3228
3229 (define_insn ""
3230   [(set (match_operand:SI 0 "register_operand" "=r")
3231         (zero_extend:SI (mem:HI
3232                           (plus:SI
3233                             (match_operand:SI 1 "register_operand" "+r")
3234                             (match_operand:SI 2 "int5_operand" "L")))))
3235    (set (match_dup 1)
3236         (plus:SI (match_dup 1) (match_dup 2)))]
3237   ""
3238   "{ldhs|ldh},mb %2(%1),%0"
3239   [(set_attr "type" "load")
3240    (set_attr "length" "4")])
3241
3242 (define_insn ""
3243   [(set (match_operand:SI 0 "register_operand" "=r")
3244         (zero_extend:SI (mem:HI
3245                           (plus:DI
3246                             (match_operand:DI 1 "register_operand" "+r")
3247                             (match_operand:DI 2 "int5_operand" "L")))))
3248    (set (match_dup 1)
3249         (plus:DI (match_dup 1) (match_dup 2)))]
3250   "TARGET_64BIT"
3251   "ldh,mb %2(%1),%0"
3252   [(set_attr "type" "load")
3253    (set_attr "length" "4")])
3254
3255 (define_insn ""
3256   [(set (mem:HI (plus:SI (match_operand:SI 0 "register_operand" "+r")
3257                          (match_operand:SI 1 "int5_operand" "L")))
3258         (match_operand:HI 2 "reg_or_0_operand" "rM"))
3259    (set (match_dup 0)
3260         (plus:SI (match_dup 0) (match_dup 1)))]
3261   ""
3262   "{sths|sth},mb %r2,%1(%0)"
3263   [(set_attr "type" "store")
3264    (set_attr "length" "4")])
3265
3266 (define_insn ""
3267   [(set (mem:HI (plus:DI (match_operand:DI 0 "register_operand" "+r")
3268                          (match_operand:DI 1 "int5_operand" "L")))
3269         (match_operand:HI 2 "reg_or_0_operand" "rM"))
3270    (set (match_dup 0)
3271         (plus:DI (match_dup 0) (match_dup 1)))]
3272   "TARGET_64BIT"
3273   "sth,mb %r2,%1(%0)"
3274   [(set_attr "type" "store")
3275    (set_attr "length" "4")])
3276
3277 (define_insn ""
3278   [(set (match_operand:HI 0 "register_operand" "=r")
3279         (plus:HI (match_operand:HI 1 "register_operand" "r")
3280                  (match_operand 2 "const_int_operand" "J")))]
3281   ""
3282   "ldo %2(%1),%0"
3283   [(set_attr "type" "binary")
3284    (set_attr "pa_combine_type" "addmove")
3285    (set_attr "length" "4")])
3286
3287 (define_expand "movqi"
3288   [(set (match_operand:QI 0 "general_operand" "")
3289         (match_operand:QI 1 "general_operand" ""))]
3290   ""
3291   "
3292 {
3293   if (emit_move_sequence (operands, QImode, 0))
3294     DONE;
3295 }")
3296
3297 (define_insn ""
3298   [(set (match_operand:QI 0 "move_dest_operand"
3299                           "=r,r,r,r,r,Q,!*q,!r,!*f,!r,!f")
3300         (match_operand:QI 1 "move_src_operand"
3301                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM,!f,!r"))]
3302   "(register_operand (operands[0], QImode)
3303     || reg_or_0_operand (operands[1], QImode))
3304    && !TARGET_SOFT_FLOAT
3305    && !TARGET_64BIT"
3306   "@
3307    copy %1,%0
3308    ldi %1,%0
3309    ldil L'%1,%0
3310    {zdepi|depwi,z} %Z1,%0
3311    ldb%M1 %1,%0
3312    stb%M0 %r1,%0
3313    mtsar %r1
3314    {mfctl|mfctl,w} %%sar,%0
3315    fcpy,sgl %f1,%0
3316    {fstws|fstw} %1,-16(%%sp)\n\t{ldws|ldw} -16(%%sp),%0
3317    {stws|stw} %1,-16(%%sp)\n\t{fldws|fldw} -16(%%sp),%0"
3318   [(set_attr "type" "move,move,move,shift,load,store,move,move,move,move,move")
3319    (set_attr "pa_combine_type" "addmove")
3320    (set_attr "length" "4,4,4,4,4,4,4,4,4,8,8")])
3321
3322 (define_insn ""
3323   [(set (match_operand:QI 0 "move_dest_operand"
3324                           "=r,r,r,r,r,Q,!*q,!r,!*f")
3325         (match_operand:QI 1 "move_src_operand"
3326                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM"))]
3327   "(register_operand (operands[0], QImode)
3328     || reg_or_0_operand (operands[1], QImode))
3329    && !TARGET_SOFT_FLOAT
3330    && TARGET_64BIT"
3331   "@
3332    copy %1,%0
3333    ldi %1,%0
3334    ldil L'%1,%0
3335    {zdepi|depwi,z} %Z1,%0
3336    ldb%M1 %1,%0
3337    stb%M0 %r1,%0
3338    mtsar %r1
3339    {mfctl|mfctl,w} %%sar,%0
3340    fcpy,sgl %f1,%0"
3341   [(set_attr "type" "move,move,move,shift,load,store,move,move,move")
3342    (set_attr "pa_combine_type" "addmove")
3343    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
3344
3345 (define_insn ""
3346   [(set (match_operand:QI 0 "move_dest_operand"
3347                           "=r,r,r,r,r,Q,!*q,!r")
3348         (match_operand:QI 1 "move_src_operand"
3349                           "r,J,N,K,RQ,rM,!rM,!*q"))]
3350   "(register_operand (operands[0], QImode)
3351     || reg_or_0_operand (operands[1], QImode))
3352    && TARGET_SOFT_FLOAT"
3353   "@
3354    copy %1,%0
3355    ldi %1,%0
3356    ldil L'%1,%0
3357    {zdepi|depwi,z} %Z1,%0
3358    ldb%M1 %1,%0
3359    stb%M0 %r1,%0
3360    mtsar %r1
3361    {mfctl|mfctl,w} %%sar,%0"
3362   [(set_attr "type" "move,move,move,shift,load,store,move,move")
3363    (set_attr "pa_combine_type" "addmove")
3364    (set_attr "length" "4,4,4,4,4,4,4,4")])
3365
3366 (define_insn ""
3367   [(set (match_operand:QI 0 "register_operand" "=r")
3368         (mem:QI (plus:SI (match_operand:SI 1 "register_operand" "+r")
3369                          (match_operand:SI 2 "int5_operand" "L"))))
3370    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3371   ""
3372   "{ldbs|ldb},mb %2(%1),%0"
3373   [(set_attr "type" "load")
3374    (set_attr "length" "4")])
3375
3376 (define_insn ""
3377   [(set (match_operand:QI 0 "register_operand" "=r")
3378         (mem:QI (plus:DI (match_operand:DI 1 "register_operand" "+r")
3379                          (match_operand:DI 2 "int5_operand" "L"))))
3380    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3381   "TARGET_64BIT"
3382   "ldb,mb %2(%1),%0"
3383   [(set_attr "type" "load")
3384    (set_attr "length" "4")])
3385
3386 ; Now the same thing with zero extensions.
3387 (define_insn ""
3388   [(set (match_operand:DI 0 "register_operand" "=r")
3389         (zero_extend:DI (mem:QI (plus:DI
3390                                   (match_operand:DI 1 "register_operand" "+r")
3391                                   (match_operand:DI 2 "int5_operand" "L")))))
3392    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3393   "TARGET_64BIT"
3394   "ldb,mb %2(%1),%0"
3395   [(set_attr "type" "load")
3396    (set_attr "length" "4")])
3397
3398 (define_insn ""
3399   [(set (match_operand:SI 0 "register_operand" "=r")
3400         (zero_extend:SI (mem:QI (plus:SI
3401                                   (match_operand:SI 1 "register_operand" "+r")
3402                                   (match_operand:SI 2 "int5_operand" "L")))))
3403    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3404   ""
3405   "{ldbs|ldb},mb %2(%1),%0"
3406   [(set_attr "type" "load")
3407    (set_attr "length" "4")])
3408
3409 (define_insn ""
3410   [(set (match_operand:SI 0 "register_operand" "=r")
3411         (zero_extend:SI (mem:QI (plus:DI
3412                                   (match_operand:DI 1 "register_operand" "+r")
3413                                   (match_operand:DI 2 "int5_operand" "L")))))
3414    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3415   "TARGET_64BIT"
3416   "ldb,mb %2(%1),%0"
3417   [(set_attr "type" "load")
3418    (set_attr "length" "4")])
3419
3420 (define_insn ""
3421   [(set (match_operand:HI 0 "register_operand" "=r")
3422         (zero_extend:HI (mem:QI (plus:SI
3423                                   (match_operand:SI 1 "register_operand" "+r")
3424                                   (match_operand:SI 2 "int5_operand" "L")))))
3425    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3426   ""
3427   "{ldbs|ldb},mb %2(%1),%0"
3428   [(set_attr "type" "load")
3429    (set_attr "length" "4")])
3430
3431 (define_insn ""
3432   [(set (match_operand:HI 0 "register_operand" "=r")
3433         (zero_extend:HI (mem:QI (plus:DI
3434                                   (match_operand:DI 1 "register_operand" "+r")
3435                                   (match_operand:DI 2 "int5_operand" "L")))))
3436    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3437   "TARGET_64BIT"
3438   "ldb,mb %2(%1),%0"
3439   [(set_attr "type" "load")
3440    (set_attr "length" "4")])
3441
3442 (define_insn ""
3443   [(set (mem:QI (plus:SI (match_operand:SI 0 "register_operand" "+r")
3444                          (match_operand:SI 1 "int5_operand" "L")))
3445         (match_operand:QI 2 "reg_or_0_operand" "rM"))
3446    (set (match_dup 0)
3447         (plus:SI (match_dup 0) (match_dup 1)))]
3448   ""
3449   "{stbs|stb},mb %r2,%1(%0)"
3450   [(set_attr "type" "store")
3451    (set_attr "length" "4")])
3452
3453 (define_insn ""
3454   [(set (mem:QI (plus:DI (match_operand:DI 0 "register_operand" "+r")
3455                          (match_operand:DI 1 "int5_operand" "L")))
3456         (match_operand:QI 2 "reg_or_0_operand" "rM"))
3457    (set (match_dup 0)
3458         (plus:DI (match_dup 0) (match_dup 1)))]
3459   "TARGET_64BIT"
3460   "stb,mb %r2,%1(%0)"
3461   [(set_attr "type" "store")
3462    (set_attr "length" "4")])
3463
3464 ;; The definition of this insn does not really explain what it does,
3465 ;; but it should suffice that anything generated as this insn will be
3466 ;; recognized as a movmemsi operation, and that it will not successfully
3467 ;; combine with anything.
3468 (define_expand "movmemsi"
3469   [(parallel [(set (match_operand:BLK 0 "" "")
3470                    (match_operand:BLK 1 "" ""))
3471               (clobber (match_dup 4))
3472               (clobber (match_dup 5))
3473               (clobber (match_dup 6))
3474               (clobber (match_dup 7))
3475               (clobber (match_dup 8))
3476               (use (match_operand:SI 2 "arith_operand" ""))
3477               (use (match_operand:SI 3 "const_int_operand" ""))])]
3478   "!TARGET_64BIT && optimize > 0"
3479   "
3480 {
3481   int size, align;
3482
3483   /* HP provides very fast block move library routine for the PA;
3484      this routine includes:
3485
3486         4x4 byte at a time block moves,
3487         1x4 byte at a time with alignment checked at runtime with
3488             attempts to align the source and destination as needed
3489         1x1 byte loop
3490
3491      With that in mind, here's the heuristics to try and guess when
3492      the inlined block move will be better than the library block
3493      move:
3494
3495         If the size isn't constant, then always use the library routines.
3496
3497         If the size is large in respect to the known alignment, then use
3498         the library routines.
3499
3500         If the size is small in respect to the known alignment, then open
3501         code the copy (since that will lead to better scheduling).
3502
3503         Else use the block move pattern.   */
3504
3505   /* Undetermined size, use the library routine.  */
3506   if (GET_CODE (operands[2]) != CONST_INT)
3507     FAIL;
3508
3509   size = INTVAL (operands[2]);
3510   align = INTVAL (operands[3]);
3511   align = align > 4 ? 4 : align;
3512
3513   /* If size/alignment is large, then use the library routines.  */
3514   if (size / align > 16)
3515     FAIL;
3516
3517   /* This does happen, but not often enough to worry much about.  */
3518   if (size / align < MOVE_RATIO)
3519     FAIL;
3520
3521   /* Fall through means we're going to use our block move pattern.  */
3522   operands[0]
3523     = replace_equiv_address (operands[0],
3524                              copy_to_mode_reg (SImode, XEXP (operands[0], 0)));
3525   operands[1]
3526     = replace_equiv_address (operands[1],
3527                              copy_to_mode_reg (SImode, XEXP (operands[1], 0)));
3528   operands[4] = gen_reg_rtx (SImode);
3529   operands[5] = gen_reg_rtx (SImode);
3530   operands[6] = gen_reg_rtx (SImode);
3531   operands[7] = gen_reg_rtx (SImode);
3532   operands[8] = gen_reg_rtx (SImode);
3533 }")
3534
3535 ;; The operand constraints are written like this to support both compile-time
3536 ;; and run-time determined byte counts.  The expander and output_block_move
3537 ;; only support compile-time determined counts at this time.
3538 ;;
3539 ;; If the count is run-time determined, the register with the byte count
3540 ;; is clobbered by the copying code, and therefore it is forced to operand 2.
3541 ;;
3542 ;; We used to clobber operands 0 and 1.  However, a change to regrename.c
3543 ;; broke this semantic for pseudo registers.  We can't use match_scratch
3544 ;; as this requires two registers in the class R1_REGS when the MEMs for
3545 ;; operands 0 and 1 are both equivalent to symbolic MEMs.  Thus, we are
3546 ;; forced to internally copy operands 0 and 1 to operands 7 and 8,
3547 ;; respectively.  We then split or peephole optimize after reload.
3548 (define_insn "movmemsi_prereload"
3549   [(set (mem:BLK (match_operand:SI 0 "register_operand" "r,r"))
3550         (mem:BLK (match_operand:SI 1 "register_operand" "r,r")))
3551    (clobber (match_operand:SI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3552    (clobber (match_operand:SI 3 "register_operand" "=&r,&r"))   ;item tmp1
3553    (clobber (match_operand:SI 6 "register_operand" "=&r,&r"))   ;item tmp2
3554    (clobber (match_operand:SI 7 "register_operand" "=&r,&r"))   ;item tmp3
3555    (clobber (match_operand:SI 8 "register_operand" "=&r,&r"))   ;item tmp4
3556    (use (match_operand:SI 4 "arith_operand" "J,2"))      ;byte count
3557    (use (match_operand:SI 5 "const_int_operand" "n,n"))] ;alignment
3558   "!TARGET_64BIT"
3559   "#"
3560   [(set_attr "type" "multi,multi")])
3561
3562 (define_split
3563   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3564                    (match_operand:BLK 1 "memory_operand" ""))
3565               (clobber (match_operand:SI 2 "register_operand" ""))
3566               (clobber (match_operand:SI 3 "register_operand" ""))
3567               (clobber (match_operand:SI 6 "register_operand" ""))
3568               (clobber (match_operand:SI 7 "register_operand" ""))
3569               (clobber (match_operand:SI 8 "register_operand" ""))
3570               (use (match_operand:SI 4 "arith_operand" ""))
3571               (use (match_operand:SI 5 "const_int_operand" ""))])]
3572   "!TARGET_64BIT && reload_completed && !flag_peephole2
3573    && GET_CODE (operands[0]) == MEM
3574    && register_operand (XEXP (operands[0], 0), SImode)
3575    && GET_CODE (operands[1]) == MEM
3576    && register_operand (XEXP (operands[1], 0), SImode)"
3577   [(set (match_dup 7) (match_dup 9))
3578    (set (match_dup 8) (match_dup 10))
3579    (parallel [(set (match_dup 0) (match_dup 1))
3580               (clobber (match_dup 2))
3581               (clobber (match_dup 3))
3582               (clobber (match_dup 6))
3583               (clobber (match_dup 7))
3584               (clobber (match_dup 8))
3585               (use (match_dup 4))
3586               (use (match_dup 5))
3587               (const_int 0)])]
3588   "
3589 {
3590   operands[9] = XEXP (operands[0], 0);
3591   operands[10] = XEXP (operands[1], 0);
3592   operands[0] = replace_equiv_address (operands[0], operands[7]);
3593   operands[1] = replace_equiv_address (operands[1], operands[8]);
3594 }")
3595
3596 (define_peephole2
3597   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3598                    (match_operand:BLK 1 "memory_operand" ""))
3599               (clobber (match_operand:SI 2 "register_operand" ""))
3600               (clobber (match_operand:SI 3 "register_operand" ""))
3601               (clobber (match_operand:SI 6 "register_operand" ""))
3602               (clobber (match_operand:SI 7 "register_operand" ""))
3603               (clobber (match_operand:SI 8 "register_operand" ""))
3604               (use (match_operand:SI 4 "arith_operand" ""))
3605               (use (match_operand:SI 5 "const_int_operand" ""))])]
3606   "!TARGET_64BIT
3607    && GET_CODE (operands[0]) == MEM
3608    && register_operand (XEXP (operands[0], 0), SImode)
3609    && GET_CODE (operands[1]) == MEM
3610    && register_operand (XEXP (operands[1], 0), SImode)"
3611   [(parallel [(set (match_dup 0) (match_dup 1))
3612               (clobber (match_dup 2))
3613               (clobber (match_dup 3))
3614               (clobber (match_dup 6))
3615               (clobber (match_dup 7))
3616               (clobber (match_dup 8))
3617               (use (match_dup 4))
3618               (use (match_dup 5))
3619               (const_int 0)])]
3620   "
3621 {
3622   rtx addr = XEXP (operands[0], 0);
3623   if (dead_or_set_p (curr_insn, addr))
3624     operands[7] = addr;
3625   else
3626     {
3627       emit_insn (gen_rtx_SET (VOIDmode, operands[7], addr));
3628       operands[0] = replace_equiv_address (operands[0], operands[7]);
3629     }
3630
3631   addr = XEXP (operands[1], 0);
3632   if (dead_or_set_p (curr_insn, addr))
3633     operands[8] = addr;
3634   else
3635     {
3636       emit_insn (gen_rtx_SET (VOIDmode, operands[8], addr));
3637       operands[1] = replace_equiv_address (operands[1], operands[8]);
3638     }
3639 }")
3640
3641 (define_insn "movmemsi_postreload"
3642   [(set (mem:BLK (match_operand:SI 0 "register_operand" "+r,r"))
3643         (mem:BLK (match_operand:SI 1 "register_operand" "+r,r")))
3644    (clobber (match_operand:SI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3645    (clobber (match_operand:SI 3 "register_operand" "=&r,&r"))   ;item tmp1
3646    (clobber (match_operand:SI 6 "register_operand" "=&r,&r"))   ;item tmp2
3647    (clobber (match_dup 0))
3648    (clobber (match_dup 1))
3649    (use (match_operand:SI 4 "arith_operand" "J,2"))      ;byte count
3650    (use (match_operand:SI 5 "const_int_operand" "n,n"))  ;alignment
3651    (const_int 0)]
3652   "!TARGET_64BIT && reload_completed"
3653   "* return output_block_move (operands, !which_alternative);"
3654   [(set_attr "type" "multi,multi")])
3655
3656 (define_expand "movmemdi"
3657   [(parallel [(set (match_operand:BLK 0 "" "")
3658                    (match_operand:BLK 1 "" ""))
3659               (clobber (match_dup 4))
3660               (clobber (match_dup 5))
3661               (clobber (match_dup 6))
3662               (clobber (match_dup 7))
3663               (clobber (match_dup 8))
3664               (use (match_operand:DI 2 "arith_operand" ""))
3665               (use (match_operand:DI 3 "const_int_operand" ""))])]
3666   "TARGET_64BIT && optimize > 0"
3667   "
3668 {
3669   int size, align;
3670
3671   /* HP provides very fast block move library routine for the PA;
3672      this routine includes:
3673
3674         4x4 byte at a time block moves,
3675         1x4 byte at a time with alignment checked at runtime with
3676             attempts to align the source and destination as needed
3677         1x1 byte loop
3678
3679      With that in mind, here's the heuristics to try and guess when
3680      the inlined block move will be better than the library block
3681      move:
3682
3683         If the size isn't constant, then always use the library routines.
3684
3685         If the size is large in respect to the known alignment, then use
3686         the library routines.
3687
3688         If the size is small in respect to the known alignment, then open
3689         code the copy (since that will lead to better scheduling).
3690
3691         Else use the block move pattern.   */
3692
3693   /* Undetermined size, use the library routine.  */
3694   if (GET_CODE (operands[2]) != CONST_INT)
3695     FAIL;
3696
3697   size = INTVAL (operands[2]);
3698   align = INTVAL (operands[3]);
3699   align = align > 8 ? 8 : align;
3700
3701   /* If size/alignment is large, then use the library routines.  */
3702   if (size / align > 16)
3703     FAIL;
3704
3705   /* This does happen, but not often enough to worry much about.  */
3706   if (size / align < MOVE_RATIO)
3707     FAIL;
3708
3709   /* Fall through means we're going to use our block move pattern.  */
3710   operands[0]
3711     = replace_equiv_address (operands[0],
3712                              copy_to_mode_reg (DImode, XEXP (operands[0], 0)));
3713   operands[1]
3714     = replace_equiv_address (operands[1],
3715                              copy_to_mode_reg (DImode, XEXP (operands[1], 0)));
3716   operands[4] = gen_reg_rtx (DImode);
3717   operands[5] = gen_reg_rtx (DImode);
3718   operands[6] = gen_reg_rtx (DImode);
3719   operands[7] = gen_reg_rtx (DImode);
3720   operands[8] = gen_reg_rtx (DImode);
3721 }")
3722
3723 ;; The operand constraints are written like this to support both compile-time
3724 ;; and run-time determined byte counts.  The expander and output_block_move
3725 ;; only support compile-time determined counts at this time.
3726 ;;
3727 ;; If the count is run-time determined, the register with the byte count
3728 ;; is clobbered by the copying code, and therefore it is forced to operand 2.
3729 ;;
3730 ;; We used to clobber operands 0 and 1.  However, a change to regrename.c
3731 ;; broke this semantic for pseudo registers.  We can't use match_scratch
3732 ;; as this requires two registers in the class R1_REGS when the MEMs for
3733 ;; operands 0 and 1 are both equivalent to symbolic MEMs.  Thus, we are
3734 ;; forced to internally copy operands 0 and 1 to operands 7 and 8,
3735 ;; respectively.  We then split or peephole optimize after reload.
3736 (define_insn "movmemdi_prereload"
3737   [(set (mem:BLK (match_operand:DI 0 "register_operand" "r,r"))
3738         (mem:BLK (match_operand:DI 1 "register_operand" "r,r")))
3739    (clobber (match_operand:DI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3740    (clobber (match_operand:DI 3 "register_operand" "=&r,&r"))   ;item tmp1
3741    (clobber (match_operand:DI 6 "register_operand" "=&r,&r"))   ;item tmp2
3742    (clobber (match_operand:DI 7 "register_operand" "=&r,&r"))   ;item tmp3
3743    (clobber (match_operand:DI 8 "register_operand" "=&r,&r"))   ;item tmp4
3744    (use (match_operand:DI 4 "arith_operand" "J,2"))      ;byte count
3745    (use (match_operand:DI 5 "const_int_operand" "n,n"))] ;alignment
3746   "TARGET_64BIT"
3747   "#"
3748   [(set_attr "type" "multi,multi")])
3749
3750 (define_split
3751   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3752                    (match_operand:BLK 1 "memory_operand" ""))
3753               (clobber (match_operand:DI 2 "register_operand" ""))
3754               (clobber (match_operand:DI 3 "register_operand" ""))
3755               (clobber (match_operand:DI 6 "register_operand" ""))
3756               (clobber (match_operand:DI 7 "register_operand" ""))
3757               (clobber (match_operand:DI 8 "register_operand" ""))
3758               (use (match_operand:DI 4 "arith_operand" ""))
3759               (use (match_operand:DI 5 "const_int_operand" ""))])]
3760   "TARGET_64BIT && reload_completed && !flag_peephole2
3761    && GET_CODE (operands[0]) == MEM
3762    && register_operand (XEXP (operands[0], 0), DImode)
3763    && GET_CODE (operands[1]) == MEM
3764    && register_operand (XEXP (operands[1], 0), DImode)"
3765   [(set (match_dup 7) (match_dup 9))
3766    (set (match_dup 8) (match_dup 10))
3767    (parallel [(set (match_dup 0) (match_dup 1))
3768               (clobber (match_dup 2))
3769               (clobber (match_dup 3))
3770               (clobber (match_dup 6))
3771               (clobber (match_dup 7))
3772               (clobber (match_dup 8))
3773               (use (match_dup 4))
3774               (use (match_dup 5))
3775               (const_int 0)])]
3776   "
3777 {
3778   operands[9] = XEXP (operands[0], 0);
3779   operands[10] = XEXP (operands[1], 0);
3780   operands[0] = replace_equiv_address (operands[0], operands[7]);
3781   operands[1] = replace_equiv_address (operands[1], operands[8]);
3782 }")
3783
3784 (define_peephole2
3785   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3786                    (match_operand:BLK 1 "memory_operand" ""))
3787               (clobber (match_operand:DI 2 "register_operand" ""))
3788               (clobber (match_operand:DI 3 "register_operand" ""))
3789               (clobber (match_operand:DI 6 "register_operand" ""))
3790               (clobber (match_operand:DI 7 "register_operand" ""))
3791               (clobber (match_operand:DI 8 "register_operand" ""))
3792               (use (match_operand:DI 4 "arith_operand" ""))
3793               (use (match_operand:DI 5 "const_int_operand" ""))])]
3794   "TARGET_64BIT
3795    && GET_CODE (operands[0]) == MEM
3796    && register_operand (XEXP (operands[0], 0), DImode)
3797    && GET_CODE (operands[1]) == MEM
3798    && register_operand (XEXP (operands[1], 0), DImode)"
3799   [(parallel [(set (match_dup 0) (match_dup 1))
3800               (clobber (match_dup 2))
3801               (clobber (match_dup 3))
3802               (clobber (match_dup 6))
3803               (clobber (match_dup 7))
3804               (clobber (match_dup 8))
3805               (use (match_dup 4))
3806               (use (match_dup 5))
3807               (const_int 0)])]
3808   "
3809 {
3810   rtx addr = XEXP (operands[0], 0);
3811   if (dead_or_set_p (curr_insn, addr))
3812     operands[7] = addr;
3813   else
3814     {
3815       emit_insn (gen_rtx_SET (VOIDmode, operands[7], addr));
3816       operands[0] = replace_equiv_address (operands[0], operands[7]);
3817     }
3818
3819   addr = XEXP (operands[1], 0);
3820   if (dead_or_set_p (curr_insn, addr))
3821     operands[8] = addr;
3822   else
3823     {
3824       emit_insn (gen_rtx_SET (VOIDmode, operands[8], addr));
3825       operands[1] = replace_equiv_address (operands[1], operands[8]);
3826     }
3827 }")
3828
3829 (define_insn "movmemdi_postreload"
3830   [(set (mem:BLK (match_operand:DI 0 "register_operand" "+r,r"))
3831         (mem:BLK (match_operand:DI 1 "register_operand" "+r,r")))
3832    (clobber (match_operand:DI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3833    (clobber (match_operand:DI 3 "register_operand" "=&r,&r"))   ;item tmp1
3834    (clobber (match_operand:DI 6 "register_operand" "=&r,&r"))   ;item tmp2
3835    (clobber (match_dup 0))
3836    (clobber (match_dup 1))
3837    (use (match_operand:DI 4 "arith_operand" "J,2"))      ;byte count
3838    (use (match_operand:DI 5 "const_int_operand" "n,n"))  ;alignment
3839    (const_int 0)]
3840   "TARGET_64BIT && reload_completed"
3841   "* return output_block_move (operands, !which_alternative);"
3842   [(set_attr "type" "multi,multi")])
3843
3844 (define_expand "setmemsi"
3845   [(parallel [(set (match_operand:BLK 0 "" "")
3846                    (match_operand 2 "const_int_operand" ""))
3847               (clobber (match_dup 4))
3848               (clobber (match_dup 5))
3849               (use (match_operand:SI 1 "arith_operand" ""))
3850               (use (match_operand:SI 3 "const_int_operand" ""))])]
3851   "!TARGET_64BIT && optimize > 0"
3852   "
3853 {
3854   int size, align;
3855
3856   /* If value to set is not zero, use the library routine.  */
3857   if (operands[2] != const0_rtx)
3858     FAIL;
3859
3860   /* Undetermined size, use the library routine.  */
3861   if (GET_CODE (operands[1]) != CONST_INT)
3862     FAIL;
3863
3864   size = INTVAL (operands[1]);
3865   align = INTVAL (operands[3]);
3866   align = align > 4 ? 4 : align;
3867
3868   /* If size/alignment is large, then use the library routines.  */
3869   if (size / align > 16)
3870     FAIL;
3871
3872   /* This does happen, but not often enough to worry much about.  */
3873   if (size / align < MOVE_RATIO)
3874     FAIL;
3875
3876   /* Fall through means we're going to use our block clear pattern.  */
3877   operands[0]
3878     = replace_equiv_address (operands[0],
3879                              copy_to_mode_reg (SImode, XEXP (operands[0], 0)));
3880   operands[4] = gen_reg_rtx (SImode);
3881   operands[5] = gen_reg_rtx (SImode);
3882 }")
3883
3884 (define_insn "clrmemsi_prereload"
3885   [(set (mem:BLK (match_operand:SI 0 "register_operand" "r,r"))
3886         (const_int 0))
3887    (clobber (match_operand:SI 1 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3888    (clobber (match_operand:SI 4 "register_operand" "=&r,&r"))   ;tmp1
3889    (use (match_operand:SI 2 "arith_operand" "J,1"))      ;byte count
3890    (use (match_operand:SI 3 "const_int_operand" "n,n"))] ;alignment
3891   "!TARGET_64BIT"
3892   "#"
3893   [(set_attr "type" "multi,multi")])
3894
3895 (define_split
3896   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3897                    (const_int 0))
3898               (clobber (match_operand:SI 1 "register_operand" ""))
3899               (clobber (match_operand:SI 4 "register_operand" ""))
3900               (use (match_operand:SI 2 "arith_operand" ""))
3901               (use (match_operand:SI 3 "const_int_operand" ""))])]
3902   "!TARGET_64BIT && reload_completed && !flag_peephole2
3903    && GET_CODE (operands[0]) == MEM
3904    && register_operand (XEXP (operands[0], 0), SImode)"
3905   [(set (match_dup 4) (match_dup 5))
3906    (parallel [(set (match_dup 0) (const_int 0))
3907               (clobber (match_dup 1))
3908               (clobber (match_dup 4))
3909               (use (match_dup 2))
3910               (use (match_dup 3))
3911               (const_int 0)])]
3912   "
3913 {
3914   operands[5] = XEXP (operands[0], 0);
3915   operands[0] = replace_equiv_address (operands[0], operands[4]);
3916 }")
3917
3918 (define_peephole2
3919   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3920                    (const_int 0))
3921               (clobber (match_operand:SI 1 "register_operand" ""))
3922               (clobber (match_operand:SI 4 "register_operand" ""))
3923               (use (match_operand:SI 2 "arith_operand" ""))
3924               (use (match_operand:SI 3 "const_int_operand" ""))])]
3925   "!TARGET_64BIT
3926    && GET_CODE (operands[0]) == MEM
3927    && register_operand (XEXP (operands[0], 0), SImode)"
3928   [(parallel [(set (match_dup 0) (const_int 0))
3929               (clobber (match_dup 1))
3930               (clobber (match_dup 4))
3931               (use (match_dup 2))
3932               (use (match_dup 3))
3933               (const_int 0)])]
3934   "
3935 {
3936   rtx addr = XEXP (operands[0], 0);
3937   if (dead_or_set_p (curr_insn, addr))
3938     operands[4] = addr;
3939   else
3940     {
3941       emit_insn (gen_rtx_SET (VOIDmode, operands[4], addr));
3942       operands[0] = replace_equiv_address (operands[0], operands[4]);
3943     }
3944 }")
3945
3946 (define_insn "clrmemsi_postreload"
3947   [(set (mem:BLK (match_operand:SI 0 "register_operand" "+r,r"))
3948         (const_int 0))
3949    (clobber (match_operand:SI 1 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3950    (clobber (match_dup 0))
3951    (use (match_operand:SI 2 "arith_operand" "J,1"))      ;byte count
3952    (use (match_operand:SI 3 "const_int_operand" "n,n"))  ;alignment
3953    (const_int 0)]
3954   "!TARGET_64BIT && reload_completed"
3955   "* return output_block_clear (operands, !which_alternative);"
3956   [(set_attr "type" "multi,multi")])
3957
3958 (define_expand "setmemdi"
3959   [(parallel [(set (match_operand:BLK 0 "" "")
3960                    (match_operand 2 "const_int_operand" ""))
3961               (clobber (match_dup 4))
3962               (clobber (match_dup 5))
3963               (use (match_operand:DI 1 "arith_operand" ""))
3964               (use (match_operand:DI 3 "const_int_operand" ""))])]
3965   "TARGET_64BIT && optimize > 0"
3966   "
3967 {
3968   int size, align;
3969
3970   /* If value to set is not zero, use the library routine.  */
3971   if (operands[2] != const0_rtx)
3972     FAIL;
3973
3974   /* Undetermined size, use the library routine.  */
3975   if (GET_CODE (operands[1]) != CONST_INT)
3976     FAIL;
3977
3978   size = INTVAL (operands[1]);
3979   align = INTVAL (operands[3]);
3980   align = align > 8 ? 8 : align;
3981
3982   /* If size/alignment is large, then use the library routines.  */
3983   if (size / align > 16)
3984     FAIL;
3985
3986   /* This does happen, but not often enough to worry much about.  */
3987   if (size / align < MOVE_RATIO)
3988     FAIL;
3989
3990   /* Fall through means we're going to use our block clear pattern.  */
3991   operands[0]
3992     = replace_equiv_address (operands[0],
3993                              copy_to_mode_reg (DImode, XEXP (operands[0], 0)));
3994   operands[4] = gen_reg_rtx (DImode);
3995   operands[5] = gen_reg_rtx (DImode);
3996 }")
3997
3998 (define_insn "clrmemdi_prereload"
3999   [(set (mem:BLK (match_operand:DI 0 "register_operand" "r,r"))
4000         (const_int 0))
4001    (clobber (match_operand:DI 1 "register_operand" "=&r,&r"))   ;loop cnt/tmp
4002    (clobber (match_operand:DI 4 "register_operand" "=&r,&r"))   ;item tmp1
4003    (use (match_operand:DI 2 "arith_operand" "J,1"))      ;byte count
4004    (use (match_operand:DI 3 "const_int_operand" "n,n"))] ;alignment
4005   "TARGET_64BIT"
4006   "#"
4007   [(set_attr "type" "multi,multi")])
4008
4009 (define_split
4010   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
4011                    (const_int 0))
4012               (clobber (match_operand:DI 1 "register_operand" ""))
4013               (clobber (match_operand:DI 4 "register_operand" ""))
4014               (use (match_operand:DI 2 "arith_operand" ""))
4015               (use (match_operand:DI 3 "const_int_operand" ""))])]
4016   "TARGET_64BIT && reload_completed && !flag_peephole2
4017    && GET_CODE (operands[0]) == MEM
4018    && register_operand (XEXP (operands[0], 0), DImode)"
4019   [(set (match_dup 4) (match_dup 5))
4020    (parallel [(set (match_dup 0) (const_int 0))
4021               (clobber (match_dup 1))
4022               (clobber (match_dup 4))
4023               (use (match_dup 2))
4024               (use (match_dup 3))
4025               (const_int 0)])]
4026   "
4027 {
4028   operands[5] = XEXP (operands[0], 0);
4029   operands[0] = replace_equiv_address (operands[0], operands[4]);
4030 }")
4031
4032 (define_peephole2
4033   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
4034                    (const_int 0))