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")])