gcc/config/rs6000/rs6000.md

   1 ;; Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
   2 ;; Copyright (C) 1990, 91-96, 1997 Free Software Foundation, Inc.
   3 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   4
   5 ;; This file is part of GNU CC.
   6
   7 ;; GNU CC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 2, or (at your option)
  10 ;; any later version.
  11
  12 ;; GNU CC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GNU CC; see the file COPYING.  If not, write to
  19 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  20 ;; Boston, MA 02111-1307, USA.
  21
  22 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  23 \f
  24 ;; Define an insn type attribute.  This is used in function unit delay
  25 ;; computations.
  26 (define_attr "type" "integer,load,store,fpload,fpstore,imul,idiv,branch,compare,delayed_compare,fpcompare,mtjmpr,fp,dmul,sdiv,ddiv,ssqrt,dsqrt,jmpreg"
  27   (const_string "integer"))
  28
  29 ;; Length (in bytes).
  30 (define_attr "length" ""
  31   (if_then_else (eq_attr "type" "branch")
  32                 (if_then_else (and (ge (minus (pc) (match_dup 0))
  33                                        (const_int -32768))
  34                                    (lt (minus (pc) (match_dup 0))
  35                                        (const_int 32767)))
  36                               (const_int 8)
  37                               (const_int 12))
  38                 (const_int 4)))
  39
  40 ;; Processor type -- this attribute must exactly match the processor_type
  41 ;; enumeration in rs6000.h.
  42
  43 (define_attr "cpu" "rios1,rios2,mpccore,ppc403,ppc601,ppc603,ppc604,ppc620"
  44   (const (symbol_ref "rs6000_cpu_attr")))
  45
  46 ; (define_function_unit NAME MULTIPLICITY SIMULTANEITY
  47 ;                       TEST READY-DELAY ISSUE-DELAY [CONFLICT-LIST])
  48
  49 ; Load/Store Unit -- pure PowerPC only
  50 ; (POWER and 601 use Integer Unit)
  51 (define_function_unit "lsu" 1 0
  52   (and (eq_attr "type" "load")
  53        (eq_attr "cpu" "mpccore,ppc603,ppc604,ppc620"))
  54   2 1)
  55
  56 (define_function_unit "lsu" 1 0
  57   (and (eq_attr "type" "store,fpstore")
  58        (eq_attr "cpu" "mpccore,ppc603,ppc604,ppc620"))
  59   1 1)
  60
  61 (define_function_unit "lsu" 1 0
  62   (and (eq_attr "type" "fpload")
  63        (eq_attr "cpu" "mpccore,ppc603"))
  64   2 1)
  65
  66 (define_function_unit "lsu" 1 0
  67   (and (eq_attr "type" "fpload")
  68        (eq_attr "cpu" "ppc604,ppc620"))
  69   3 1)
  70
  71 (define_function_unit "iu" 1 0
  72   (and (eq_attr "type" "load")
  73        (eq_attr "cpu" "rios1,ppc403,ppc601"))
  74   2 1)
  75
  76 (define_function_unit "iu" 1 0
  77   (and (eq_attr "type" "store,fpstore")
  78        (eq_attr "cpu" "rios1,ppc403,ppc601"))
  79   1 1)
  80
  81 (define_function_unit "fpu" 1 0
  82   (and (eq_attr "type" "fpstore")
  83        (eq_attr "cpu" "rios1,ppc601"))
  84   0 1)
  85
  86 (define_function_unit "iu" 1 0
  87   (and (eq_attr "type" "fpload")
  88        (eq_attr "cpu" "rios1"))
  89   2 1)
  90
  91 (define_function_unit "iu" 1 0
  92   (and (eq_attr "type" "fpload")
  93        (eq_attr "cpu" "ppc601"))
  94   3 1)
  95
  96 (define_function_unit "iu2" 2 0
  97   (and (eq_attr "type" "load,fpload")
  98        (eq_attr "cpu" "rios2"))
  99   2 1)
 100
 101 (define_function_unit "iu2" 2 0
 102   (and (eq_attr "type" "store,fpstore")
 103        (eq_attr "cpu" "rios2"))
 104   1 1)
 105
 106 ; Integer Unit (RIOS1, PPC601, PPC603)
 107 (define_function_unit "iu" 1 0
 108   (and (eq_attr "type" "integer")
 109        (eq_attr "cpu" "rios1,mpccore,ppc403,ppc601,ppc603"))
 110   1 1)
 111
 112 (define_function_unit "iu" 1 0
 113   (and (eq_attr "type" "imul")
 114        (eq_attr "cpu" "ppc403"))
 115   4 4)
 116
 117 (define_function_unit "iu" 1 0
 118   (and (eq_attr "type" "imul")
 119        (eq_attr "cpu" "rios1,ppc601,ppc603"))
 120   5 5)
 121
 122 (define_function_unit "iu" 1 0
 123   (and (eq_attr "type" "idiv")
 124        (eq_attr "cpu" "rios1"))
 125   19 19)
 126
 127 (define_function_unit "iu" 1 0
 128   (and (eq_attr "type" "idiv")
 129        (eq_attr "cpu" "ppc403"))
 130   33 33)
 131
 132 (define_function_unit "iu" 1 0
 133   (and (eq_attr "type" "idiv")
 134        (eq_attr "cpu" "ppc601"))
 135   36 36)
 136
 137 (define_function_unit "iu" 1 0
 138   (and (eq_attr "type" "idiv")
 139        (eq_attr "cpu" "ppc603"))
 140   37 36)
 141
 142 ; RIOS2 has two integer units: a primary one which can perform all
 143 ; operations and a secondary one which is fed in lock step with the first
 144 ; and can perform "simple" integer operations.
 145 ; To catch this we define a 'dummy' imuldiv-unit that is also needed
 146 ; for the complex insns.
 147 (define_function_unit "iu2" 2 0
 148   (and (eq_attr "type" "integer")
 149        (eq_attr "cpu" "rios2"))
 150   1 1)
 151
 152 (define_function_unit "iu2" 2 0
 153   (and (eq_attr "type" "imul")
 154        (eq_attr "cpu" "rios2"))
 155   2 2)
 156
 157 (define_function_unit "iu2" 2 0
 158   (and (eq_attr "type" "idiv")
 159        (eq_attr "cpu" "rios2"))
 160   13 13)
 161
 162 (define_function_unit "imuldiv" 1 0
 163   (and (eq_attr "type" "imul")
 164        (eq_attr "cpu" "rios2"))
 165   2 2)
 166
 167 (define_function_unit "imuldiv" 1 0
 168   (and (eq_attr "type" "idiv")
 169        (eq_attr "cpu" "rios2"))
 170   13 13)
 171
 172 ; MPCCORE has separate IMUL/IDIV unit for multicycle instructions
 173 ; Divide latency varies greatly from 2-11, use 6 as average
 174 (define_function_unit "imuldiv" 1 0
 175   (and (eq_attr "type" "imul")
 176        (eq_attr "cpu" "mpccore"))
 177   2 1)
 178
 179 (define_function_unit "imuldiv" 1 0
 180   (and (eq_attr "type" "idiv")
 181        (eq_attr "cpu" "mpccore"))
 182   6 6)
 183
 184 ; PPC604 has two units that perform integer operations
 185 ; and one unit for divide/multiply operations (and move
 186 ; from/to spr).
 187 (define_function_unit "iu2" 2 0
 188   (and (eq_attr "type" "integer")
 189        (eq_attr "cpu" "ppc604,ppc620"))
 190   1 1)
 191
 192 (define_function_unit "imuldiv" 1 0
 193   (and (eq_attr "type" "imul")
 194        (eq_attr "cpu" "ppc604,ppc620"))
 195   4 2)
 196
 197 (define_function_unit "imuldiv" 1 0
 198   (and (eq_attr "type" "idiv")
 199        (eq_attr "cpu" "ppc604,ppc620"))
 200   20 19)
 201
 202 ; compare is done on integer unit, but feeds insns which
 203 ; execute on the branch unit.
 204 (define_function_unit "iu" 1 0
 205   (and (eq_attr "type" "compare")
 206        (eq_attr "cpu" "rios1"))
 207   4 1)
 208
 209 (define_function_unit "iu" 1 0
 210   (and (eq_attr "type" "delayed_compare")
 211        (eq_attr "cpu" "rios1"))
 212   5 1)
 213
 214 (define_function_unit "iu" 1 0
 215   (and (eq_attr "type" "compare,delayed_compare")
 216        (eq_attr "cpu" "mpccore,ppc403,ppc601,ppc603,ppc604,ppc620"))
 217   3 1)
 218
 219 (define_function_unit "iu2" 2 0
 220   (and (eq_attr "type" "compare,delayed_compare")
 221        (eq_attr "cpu" "rios2"))
 222   3 1)
 223
 224 (define_function_unit "iu2" 2 0
 225   (and (eq_attr "type" "compare,delayed_compare")
 226        (eq_attr "cpu" "ppc604,ppc620"))
 227   1 1)
 228
 229 ; fp compare uses fp unit
 230 (define_function_unit "fpu" 1 0
 231   (and (eq_attr "type" "fpcompare")
 232        (eq_attr "cpu" "rios1"))
 233   9 1)
 234
 235 ; rios1 and rios2 have different fpcompare delays
 236 (define_function_unit "fpu2" 2 0
 237   (and (eq_attr "type" "fpcompare")
 238        (eq_attr "cpu" "rios2"))
 239   5 1)
 240
 241 ; on ppc601 and ppc603, fpcompare takes also 2 cycles from
 242 ; the integer unit
 243 ; here we do not define delays, just occupy the unit. The dependencies
 244 ; will be assigned by the fpcompare definition in the fpu.
 245 (define_function_unit "iu" 1 0
 246   (and (eq_attr "type" "fpcompare")
 247        (eq_attr "cpu" "ppc601,ppc603"))
 248   0 2)
 249
 250 ; fp compare uses fp unit
 251 (define_function_unit "fpu" 1 0
 252   (and (eq_attr "type" "fpcompare")
 253        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
 254   5 1)
 255
 256 (define_function_unit "fpu" 1 0
 257   (and (eq_attr "type" "fpcompare")
 258        (eq_attr "cpu" "mpccore"))
 259   1 1)
 260
 261 (define_function_unit "bpu" 1 0
 262   (and (eq_attr "type" "mtjmpr")
 263        (eq_attr "cpu" "rios1,rios2"))
 264   5 1)
 265
 266 (define_function_unit "bpu" 1 0
 267   (and (eq_attr "type" "mtjmpr")
 268        (eq_attr "cpu" "mpccore,ppc403,ppc601,ppc603,ppc604,ppc620"))
 269   4 1)
 270
 271 ; all jumps/branches are executing on the bpu, in 1 cycle, for all machines.
 272 (define_function_unit "bpu" 1 0
 273   (eq_attr "type" "jmpreg")
 274   1 1)
 275
 276 (define_function_unit "bpu" 1 0
 277   (eq_attr "type" "branch")
 278   1 1)
 279
 280 ; Floating Point Unit
 281 (define_function_unit "fpu" 1 0
 282   (and (eq_attr "type" "fp,dmul")
 283        (eq_attr "cpu" "rios1"))
 284   2 1)
 285
 286 (define_function_unit "fpu" 1 0
 287   (and (eq_attr "type" "fp")
 288        (eq_attr "cpu" "mpccore"))
 289   4 4)
 290
 291 (define_function_unit "fpu" 1 0
 292   (and (eq_attr "type" "fp")
 293        (eq_attr "cpu" "ppc601"))
 294   4 1)
 295
 296 (define_function_unit "fpu" 1 0
 297   (and (eq_attr "type" "fp")
 298        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
 299   3 1)
 300
 301 (define_function_unit "fpu" 1 0
 302   (and (eq_attr "type" "dmul")
 303        (eq_attr "cpu" "mpccore"))
 304   5 5)
 305
 306 (define_function_unit "fpu" 1 0
 307   (and (eq_attr "type" "dmul")
 308        (eq_attr "cpu" "ppc601"))
 309   5 2)
 310
 311 ; is this true?
 312 (define_function_unit "fpu" 1 0
 313   (and (eq_attr "type" "dmul")
 314        (eq_attr "cpu" "ppc603"))
 315   4 2)
 316
 317 (define_function_unit "fpu" 1 0
 318   (and (eq_attr "type" "dmul")
 319        (eq_attr "cpu" "ppc604,ppc620"))
 320   3 1)
 321
 322 (define_function_unit "fpu" 1 0
 323   (and (eq_attr "type" "sdiv,ddiv")
 324        (eq_attr "cpu" "rios1"))
 325   19 19)
 326
 327 (define_function_unit "fpu" 1 0
 328   (and (eq_attr "type" "sdiv")
 329        (eq_attr "cpu" "ppc601"))
 330   17 17)
 331
 332 (define_function_unit "fpu" 1 0
 333   (and (eq_attr "type" "sdiv")
 334        (eq_attr "cpu" "mpccore"))
 335   10 10)
 336
 337 (define_function_unit "fpu" 1 0
 338   (and (eq_attr "type" "sdiv")
 339        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
 340   18 18)
 341
 342 (define_function_unit "fpu" 1 0
 343   (and (eq_attr "type" "ddiv")
 344        (eq_attr "cpu" "mpccore"))
 345   17 17)
 346
 347 (define_function_unit "fpu" 1 0
 348   (and (eq_attr "type" "ddiv")
 349        (eq_attr "cpu" "ppc601,ppc604,ppc620"))
 350   31 31)
 351
 352 (define_function_unit "fpu" 1 0
 353   (and (eq_attr "type" "ddiv")
 354        (eq_attr "cpu" "ppc603"))
 355   33 33)
 356
 357 (define_function_unit "fpu" 1 0
 358   (and (eq_attr "type" "ssqrt")
 359        (eq_attr "cpu" "ppc620"))
 360   31 31)
 361
 362 (define_function_unit "fpu" 1 0
 363   (and (eq_attr "type" "dsqrt")
 364        (eq_attr "cpu" "ppc620"))
 365   31 31)
 366
 367 ; RIOS2 has two symmetric FPUs.
 368 (define_function_unit "fpu2" 2 0
 369   (and (eq_attr "type" "fp")
 370        (eq_attr "cpu" "rios2"))
 371   2 1)
 372
 373 (define_function_unit "fpu2" 2 0
 374   (and (eq_attr "type" "dmul")
 375        (eq_attr "cpu" "rios2"))
 376   2 1)
 377
 378 (define_function_unit "fpu2" 2 0
 379   (and (eq_attr "type" "sdiv,ddiv")
 380        (eq_attr "cpu" "rios2"))
 381   17 17)
 382
 383 (define_function_unit "fpu2" 2 0
 384   (and (eq_attr "type" "ssqrt,dsqrt")
 385        (eq_attr "cpu" "rios2"))
 386   26 26)
 387
 388 \f
 389 ;; Start with fixed-point load and store insns.  Here we put only the more
 390 ;; complex forms.  Basic data transfer is done later.
 391
 392 (define_expand "zero_extendqidi2"
 393   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 394         (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "")))]
 395   "TARGET_POWERPC64"
 396   "")
 397
 398 (define_insn ""
 399   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 400         (zero_extend:DI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
 401   "TARGET_POWERPC64"
 402   "@
 403    lbz%U1%X1 %0,%1
 404    rldicl %0,%1,0,56"
 405   [(set_attr "type" "load,*")])
 406
 407 (define_insn ""
 408   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 409         (compare:CC (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
 410                     (const_int 0)))
 411    (clobber (match_scratch:DI 2 "=r"))]
 412   "TARGET_POWERPC64"
 413   "rldicl. %2,%1,0,56"
 414   [(set_attr "type" "compare")])
 415
 416 (define_insn ""
 417   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 418         (compare:CC (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
 419                     (const_int 0)))
 420    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 421         (zero_extend:DI (match_dup 1)))]
 422   "TARGET_POWERPC64"
 423   "rldicl. %0,%1,0,56"
 424   [(set_attr "type" "compare")])
 425
 426 (define_insn "extendqidi2"
 427   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
 428         (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 429   "TARGET_POWERPC64"
 430   "extsb %0,%1")
 431
 432 (define_insn ""
 433   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 434         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
 435                     (const_int 0)))
 436    (clobber (match_scratch:DI 2 "=r"))]
 437   "TARGET_POWERPC64"
 438   "extsb. %2,%1"
 439   [(set_attr "type" "compare")])
 440
 441 (define_insn ""
 442   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 443         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
 444                     (const_int 0)))
 445    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 446         (sign_extend:DI (match_dup 1)))]
 447   "TARGET_POWERPC64"
 448   "extsb. %0,%1"
 449   [(set_attr "type" "compare")])
 450
 451 (define_expand "zero_extendhidi2"
 452   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 453         (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
 454   "TARGET_POWERPC64"
 455   "")
 456
 457 (define_insn ""
 458   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 459         (zero_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 460   "TARGET_POWERPC64"
 461   "@
 462    lhz%U1%X1 %0,%1
 463    rldicl %0,%1,0,48"
 464   [(set_attr "type" "load,*")])
 465
 466 (define_insn ""
 467   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 468         (compare:CC (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
 469                     (const_int 0)))
 470    (clobber (match_scratch:DI 2 "=r"))]
 471   "TARGET_POWERPC64"
 472   "rldicl. %2,%1,0,48"
 473   [(set_attr "type" "compare")])
 474
 475 (define_insn ""
 476   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 477         (compare:CC (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
 478                     (const_int 0)))
 479    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 480         (zero_extend:DI (match_dup 1)))]
 481   "TARGET_POWERPC64"
 482   "rldicl. %0,%1,0,48"
 483   [(set_attr "type" "compare")])
 484
 485 (define_expand "extendhidi2"
 486   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 487         (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
 488   "TARGET_POWERPC64"
 489   "")
 490
 491 (define_insn ""
 492   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 493         (sign_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 494   "TARGET_POWERPC64"
 495   "@
 496    lha%U1%X1 %0,%1
 497    extsh %0,%1"
 498   [(set_attr "type" "load,*")])
 499
 500 (define_insn ""
 501   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 502         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
 503                     (const_int 0)))
 504    (clobber (match_scratch:DI 2 "=r"))]
 505   "TARGET_POWERPC64"
 506   "extsh. %2,%1"
 507   [(set_attr "type" "compare")])
 508
 509 (define_insn ""
 510   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 511         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
 512                     (const_int 0)))
 513    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 514         (sign_extend:DI (match_dup 1)))]
 515   "TARGET_POWERPC64"
 516   "extsh. %0,%1"
 517   [(set_attr "type" "compare")])
 518
 519 (define_expand "zero_extendsidi2"
 520   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 521         (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
 522   "TARGET_POWERPC64"
 523   "")
 524
 525 (define_insn ""
 526   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 527         (zero_extend:DI (match_operand:SI 1 "reg_or_mem_operand" "m,r")))]
 528   "TARGET_POWERPC64"
 529   "@
 530    lwz%U1%X1 %0,%1
 531    rldicl %0,%1,0,32"
 532   [(set_attr "type" "load,*")])
 533
 534 (define_insn ""
 535   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 536         (compare:CC (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
 537                     (const_int 0)))
 538    (clobber (match_scratch:DI 2 "=r"))]
 539   "TARGET_POWERPC64"
 540   "rldicl. %2,%1,0,32"
 541   [(set_attr "type" "compare")])
 542
 543 (define_insn ""
 544   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 545         (compare:CC (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
 546                     (const_int 0)))
 547    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 548         (zero_extend:DI (match_dup 1)))]
 549   "TARGET_POWERPC64"
 550   "rldicl. %0,%1,0,32"
 551   [(set_attr "type" "compare")])
 552
 553 (define_expand "extendsidi2"
 554   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 555         (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
 556   "TARGET_POWERPC64"
 557   "")
 558
 559 (define_insn ""
 560   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 561         (sign_extend:DI (match_operand:SI 1 "lwa_operand" "m,r")))]
 562   "TARGET_POWERPC64"
 563   "@
 564    lwa%U1%X1 %0,%1
 565    extsw %0,%1"
 566   [(set_attr "type" "load,*")])
 567
 568 (define_insn ""
 569   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 570         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
 571                     (const_int 0)))
 572    (clobber (match_scratch:DI 2 "=r"))]
 573   "TARGET_POWERPC64"
 574   "extsw. %2,%1"
 575   [(set_attr "type" "compare")])
 576
 577 (define_insn ""
 578   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 579         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
 580                     (const_int 0)))
 581    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
 582         (sign_extend:DI (match_dup 1)))]
 583   "TARGET_POWERPC64"
 584   "extsw. %0,%1"
 585   [(set_attr "type" "compare")])
 586
 587 (define_expand "zero_extendqisi2"
 588   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 589         (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
 590   ""
 591   "")
 592
 593 (define_insn ""
 594   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 595         (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
 596   ""
 597   "@
 598    lbz%U1%X1 %0,%1
 599    {rlinm|rlwinm} %0,%1,0,0xff"
 600   [(set_attr "type" "load,*")])
 601
 602 (define_insn ""
 603   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 604         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
 605                     (const_int 0)))
 606    (clobber (match_scratch:SI 2 "=r"))]
 607   ""
 608   "{andil.|andi.} %2,%1,0xff"
 609   [(set_attr "type" "compare")])
 610
 611 (define_insn ""
 612   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 613         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
 614                     (const_int 0)))
 615    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 616         (zero_extend:SI (match_dup 1)))]
 617   ""
 618   "{andil.|andi.} %0,%1,0xff"
 619   [(set_attr "type" "compare")])
 620
 621 (define_expand "extendqisi2"
 622   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
 623    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
 624   ""
 625   "
 626 {
 627   if (TARGET_POWERPC)
 628     emit_insn (gen_extendqisi2_ppc (operands[0], operands[1]));
 629   else if (TARGET_POWER)
 630     emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
 631   else
 632     emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
 633   DONE;
 634 }")
 635
 636 (define_insn "extendqisi2_ppc"
 637   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 638         (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 639   "TARGET_POWERPC"
 640   "extsb %0,%1")
 641
 642 (define_insn ""
 643   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 644         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
 645                     (const_int 0)))
 646    (clobber (match_scratch:SI 2 "=r"))]
 647   "TARGET_POWERPC"
 648   "extsb. %2,%1"
 649   [(set_attr "type" "compare")])
 650
 651 (define_insn ""
 652   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 653         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
 654                     (const_int 0)))
 655    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 656         (sign_extend:SI (match_dup 1)))]
 657   "TARGET_POWERPC"
 658   "extsb. %0,%1"
 659   [(set_attr "type" "compare")])
 660
 661 (define_expand "extendqisi2_power"
 662   [(parallel [(set (match_dup 2)
 663                    (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 664                               (const_int 24)))
 665               (clobber (scratch:SI))])
 666    (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
 667                    (ashiftrt:SI (match_dup 2)
 668                                 (const_int 24)))
 669               (clobber (scratch:SI))])]
 670   "TARGET_POWER"
 671   "
 672 { operands[1] = gen_lowpart (SImode, operands[1]);
 673   operands[2] = gen_reg_rtx (SImode); }")
 674
 675 (define_expand "extendqisi2_no_power"
 676   [(set (match_dup 2)
 677         (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 678                    (const_int 24)))
 679    (set (match_operand:SI 0 "gpc_reg_operand" "")
 680         (ashiftrt:SI (match_dup 2)
 681                      (const_int 24)))]
 682   "! TARGET_POWER && ! TARGET_POWERPC"
 683   "
 684 { operands[1] = gen_lowpart (SImode, operands[1]);
 685   operands[2] = gen_reg_rtx (SImode); }")
 686
 687 (define_expand "zero_extendqihi2"
 688   [(set (match_operand:HI 0 "gpc_reg_operand" "")
 689         (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
 690   ""
 691   "")
 692
 693 (define_insn ""
 694   [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
 695         (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
 696   ""
 697   "@
 698    lbz%U1%X1 %0,%1
 699    {rlinm|rlwinm} %0,%1,0,0xff"
 700   [(set_attr "type" "load,*")])
 701
 702 (define_insn ""
 703   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 704         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
 705                     (const_int 0)))
 706    (clobber (match_scratch:HI 2 "=r"))]
 707   ""
 708   "{andil.|andi.} %2,%1,0xff"
 709   [(set_attr "type" "compare")])
 710
 711 (define_insn ""
 712   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 713         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
 714                     (const_int 0)))
 715    (set (match_operand:HI 0 "gpc_reg_operand" "=r")
 716         (zero_extend:HI (match_dup 1)))]
 717   ""
 718   "{andil.|andi.} %0,%1,0xff"
 719   [(set_attr "type" "compare")])
 720
 721 (define_expand "extendqihi2"
 722   [(use (match_operand:HI 0 "gpc_reg_operand" ""))
 723    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
 724   ""
 725   "
 726 {
 727   if (TARGET_POWERPC)
 728     emit_insn (gen_extendqihi2_ppc (operands[0], operands[1]));
 729   else if (TARGET_POWER)
 730     emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
 731   else
 732     emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
 733   DONE;
 734 }")
 735
 736 (define_insn "extendqihi2_ppc"
 737   [(set (match_operand:HI 0 "gpc_reg_operand" "=r")
 738         (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 739   "TARGET_POWERPC"
 740   "extsb %0,%1")
 741
 742 (define_insn ""
 743   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 744         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
 745                     (const_int 0)))
 746    (clobber (match_scratch:HI 2 "=r"))]
 747   "TARGET_POWERPC"
 748   "extsb. %2,%1"
 749   [(set_attr "type" "compare")])
 750
 751 (define_insn ""
 752   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 753         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
 754                     (const_int 0)))
 755    (set (match_operand:HI 0 "gpc_reg_operand" "=r")
 756         (sign_extend:HI (match_dup 1)))]
 757   "TARGET_POWERPC"
 758   "extsb. %0,%1"
 759   [(set_attr "type" "compare")])
 760
 761 (define_expand "extendqihi2_power"
 762   [(parallel [(set (match_dup 2)
 763                    (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 764                               (const_int 24)))
 765               (clobber (scratch:SI))])
 766    (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
 767                    (ashiftrt:SI (match_dup 2)
 768                                 (const_int 24)))
 769               (clobber (scratch:SI))])]
 770   "TARGET_POWER"
 771   "
 772 { operands[0] = gen_lowpart (SImode, operands[0]);
 773   operands[1] = gen_lowpart (SImode, operands[1]);
 774   operands[2] = gen_reg_rtx (SImode); }")
 775
 776 (define_expand "extendqihi2_no_power"
 777   [(set (match_dup 2)
 778         (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 779                    (const_int 24)))
 780    (set (match_operand:HI 0 "gpc_reg_operand" "")
 781         (ashiftrt:SI (match_dup 2)
 782                      (const_int 24)))]
 783   "! TARGET_POWER && ! TARGET_POWERPC"
 784   "
 785 { operands[0] = gen_lowpart (SImode, operands[0]);
 786   operands[1] = gen_lowpart (SImode, operands[1]);
 787   operands[2] = gen_reg_rtx (SImode); }")
 788
 789 (define_expand "zero_extendhisi2"
 790   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 791         (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
 792   ""
 793   "")
 794
 795 (define_insn ""
 796   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 797         (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 798   ""
 799   "@
 800    lhz%U1%X1 %0,%1
 801    {rlinm|rlwinm} %0,%1,0,0xffff"
 802   [(set_attr "type" "load,*")])
 803
 804 (define_insn ""
 805   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 806         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
 807                     (const_int 0)))
 808    (clobber (match_scratch:SI 2 "=r"))]
 809   ""
 810   "{andil.|andi.} %2,%1,0xffff"
 811   [(set_attr "type" "compare")])
 812
 813 (define_insn ""
 814   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 815         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
 816                     (const_int 0)))
 817    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 818         (zero_extend:SI (match_dup 1)))]
 819   ""
 820   "{andil.|andi.} %0,%1,0xffff"
 821   [(set_attr "type" "compare")])
 822
 823 (define_expand "extendhisi2"
 824   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 825         (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
 826   ""
 827   "")
 828
 829 (define_insn ""
 830   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 831         (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 832   ""
 833   "@
 834    lha%U1%X1 %0,%1
 835    {exts|extsh} %0,%1"
 836   [(set_attr "type" "load,*")])
 837
 838 (define_insn ""
 839   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 840         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
 841                     (const_int 0)))
 842    (clobber (match_scratch:SI 2 "=r"))]
 843   ""
 844   "{exts.|extsh.} %2,%1"
 845   [(set_attr "type" "compare")])
 846
 847 (define_insn ""
 848   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 849         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
 850                     (const_int 0)))
 851    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 852         (sign_extend:SI (match_dup 1)))]
 853   ""
 854   "{exts.|extsh.} %0,%1"
 855   [(set_attr "type" "compare")])
 856 \f
 857 ;; Fixed-point arithmetic insns.
 858
 859 ;; Discourage ai/addic because of carry but provide it in an alternative
 860 ;; allowing register zero as source.
 861 (define_insn "addsi3"
 862   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,?r,r")
 863         (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,b,r,b")
 864                  (match_operand:SI 2 "add_operand" "r,I,I,J")))]
 865   ""
 866   "@
 867    {cax|add} %0,%1,%2
 868    {cal %0,%2(%1)|addi %0,%1,%2}
 869    {ai|addic} %0,%1,%2
 870    {cau|addis} %0,%1,%v2")
 871
 872 (define_insn ""
 873   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
 874         (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
 875                              (match_operand:SI 2 "reg_or_short_operand" "r,I"))
 876                     (const_int 0)))
 877    (clobber (match_scratch:SI 3 "=r,r"))]
 878   ""
 879   "@
 880    {cax.|add.} %3,%1,%2
 881    {ai.|addic.} %3,%1,%2"
 882   [(set_attr "type" "compare")])
 883
 884 (define_insn ""
 885   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
 886         (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
 887                              (match_operand:SI 2 "reg_or_short_operand" "r,I"))
 888                     (const_int 0)))
 889    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 890         (plus:SI (match_dup 1) (match_dup 2)))]
 891   ""
 892   "@
 893    {cax.|add.} %0,%1,%2
 894    {ai.|addic.} %0,%1,%2"
 895   [(set_attr "type" "compare")])
 896
 897 ;; Split an add that we can't do in one insn into two insns, each of which
 898 ;; does one 16-bit part.  This is used by combine.  Note that the low-order
 899 ;; add should be last in case the result gets used in an address.
 900
 901 (define_split
 902   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 903         (plus:SI (match_operand:SI 1 "gpc_reg_operand" "")
 904                  (match_operand:SI 2 "non_add_cint_operand" "")))]
 905   ""
 906   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
 907    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
 908 "
 909 {
 910   HOST_WIDE_INT low = INTVAL (operands[2]) & 0xffff;
 911   HOST_WIDE_INT high = INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff);
 912
 913   if (low & 0x8000)
 914     high += 0x10000, low |= ((HOST_WIDE_INT) -1) << 16;
 915
 916   operands[3] = GEN_INT (high);
 917   operands[4] = GEN_INT (low);
 918 }")
 919
 920 (define_insn "one_cmplsi2"
 921   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 922         (not:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
 923   ""
 924   "nor %0,%1,%1")
 925
 926 (define_insn ""
 927   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 928         (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
 929                     (const_int 0)))
 930    (clobber (match_scratch:SI 2 "=r"))]
 931   ""
 932   "nor. %2,%1,%1"
 933   [(set_attr "type" "compare")])
 934
 935 (define_insn ""
 936   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
 937         (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
 938                     (const_int 0)))
 939    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 940         (not:SI (match_dup 1)))]
 941   ""
 942   "nor. %0,%1,%1"
 943   [(set_attr "type" "compare")])
 944
 945 (define_insn ""
 946   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 947         (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
 948                   (match_operand:SI 2 "gpc_reg_operand" "r")))]
 949   "! TARGET_POWERPC"
 950   "{sf%I1|subf%I1c} %0,%2,%1")
 951
 952 (define_insn ""
 953   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 954         (minus:SI (match_operand:SI 1 "reg_or_short_operand" "r,I")
 955                   (match_operand:SI 2 "gpc_reg_operand" "r,r")))]
 956   "TARGET_POWERPC"
 957   "@
 958    subf %0,%2,%1
 959    subfic %0,%2,%1")
 960
 961 (define_insn ""
 962   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 963         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
 964                               (match_operand:SI 2 "gpc_reg_operand" "r"))
 965                     (const_int 0)))
 966    (clobber (match_scratch:SI 3 "=r"))]
 967   "! TARGET_POWERPC"
 968   "{sf.|subfc.} %3,%2,%1"
 969   [(set_attr "type" "compare")])
 970
 971 (define_insn ""
 972   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
 973         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
 974                               (match_operand:SI 2 "gpc_reg_operand" "r"))
 975                     (const_int 0)))
 976    (clobber (match_scratch:SI 3 "=r"))]
 977   "TARGET_POWERPC"
 978   "subf. %3,%2,%1"
 979   [(set_attr "type" "compare")])
 980
 981 (define_insn ""
 982   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
 983         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
 984                               (match_operand:SI 2 "gpc_reg_operand" "r"))
 985                     (const_int 0)))
 986    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 987         (minus:SI (match_dup 1) (match_dup 2)))]
 988   "! TARGET_POWERPC"
 989   "{sf.|subfc.} %0,%2,%1"
 990   [(set_attr "type" "compare")])
 991
 992 (define_insn ""
 993   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
 994         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
 995                               (match_operand:SI 2 "gpc_reg_operand" "r"))
 996                     (const_int 0)))
 997    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 998         (minus:SI (match_dup 1) (match_dup 2)))]
 999   "TARGET_POWERPC"
1000   "subf. %0,%2,%1"
1001   [(set_attr "type" "compare")])
1002
1003 (define_expand "subsi3"
1004   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1005         (minus:SI (match_operand:SI 1 "reg_or_short_operand" "")
1006                   (match_operand:SI 2 "reg_or_cint_operand" "")))]
1007   ""
1008   "
1009 {
1010   if (GET_CODE (operands[2]) == CONST_INT)
1011     {
1012       emit_insn (gen_addsi3 (operands[0], operands[1],
1013                              negate_rtx (SImode, operands[2])));
1014       DONE;
1015     }
1016 }")
1017
1018 ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
1019 ;; instruction and some auxiliary computations.  Then we just have a single
1020 ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
1021 ;; combine.
1022
1023 (define_expand "sminsi3"
1024   [(set (match_dup 3)
1025         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1026                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1027                          (const_int 0)
1028                          (minus:SI (match_dup 2) (match_dup 1))))
1029    (set (match_operand:SI 0 "gpc_reg_operand" "")
1030         (minus:SI (match_dup 2) (match_dup 3)))]
1031   "TARGET_POWER"
1032   "
1033 { operands[3] = gen_reg_rtx (SImode); }")
1034
1035 (define_split
1036   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1037         (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
1038                  (match_operand:SI 2 "reg_or_short_operand" "")))
1039    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1040   "TARGET_POWER"
1041   [(set (match_dup 3)
1042         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1043                          (const_int 0)
1044                          (minus:SI (match_dup 2) (match_dup 1))))
1045    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
1046   "")
1047
1048 (define_expand "smaxsi3"
1049   [(set (match_dup 3)
1050         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1051                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1052                          (const_int 0)
1053                          (minus:SI (match_dup 2) (match_dup 1))))
1054    (set (match_operand:SI 0 "gpc_reg_operand" "")
1055         (plus:SI (match_dup 3) (match_dup 1)))]
1056   "TARGET_POWER"
1057   "
1058 { operands[3] = gen_reg_rtx (SImode); }")
1059
1060 (define_split
1061   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1062         (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
1063                  (match_operand:SI 2 "reg_or_short_operand" "")))
1064    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1065   "TARGET_POWER"
1066   [(set (match_dup 3)
1067         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1068                          (const_int 0)
1069                          (minus:SI (match_dup 2) (match_dup 1))))
1070    (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
1071   "")
1072
1073 (define_expand "uminsi3"
1074   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1075                               (match_dup 5)))
1076    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1077                               (match_dup 5)))
1078    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1079                                        (const_int 0)
1080                                        (minus:SI (match_dup 4) (match_dup 3))))
1081    (set (match_operand:SI 0 "gpc_reg_operand" "")
1082         (minus:SI (match_dup 2) (match_dup 3)))]
1083   "TARGET_POWER"
1084   "
1085 {
1086   operands[3] = gen_reg_rtx (SImode);
1087   operands[4] = gen_reg_rtx (SImode);
1088   operands[5] = GEN_INT (-2147483647 - 1);
1089 }")
1090
1091 (define_expand "umaxsi3"
1092   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1093                               (match_dup 5)))
1094    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1095                               (match_dup 5)))
1096    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1097                                        (const_int 0)
1098                                        (minus:SI (match_dup 4) (match_dup 3))))
1099    (set (match_operand:SI 0 "gpc_reg_operand" "")
1100         (plus:SI (match_dup 3) (match_dup 1)))]
1101   "TARGET_POWER"
1102   "
1103 {
1104   operands[3] = gen_reg_rtx (SImode);
1105   operands[4] = gen_reg_rtx (SImode);
1106   operands[5] = GEN_INT (-2147483647 - 1);
1107 }")
1108
1109 (define_insn ""
1110   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1111         (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1112                              (match_operand:SI 2 "reg_or_short_operand" "rI"))
1113                          (const_int 0)
1114                          (minus:SI (match_dup 2) (match_dup 1))))]
1115   "TARGET_POWER"
1116   "doz%I2 %0,%1,%2")
1117
1118 (define_insn ""
1119   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1120         (compare:CC
1121          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1122                               (match_operand:SI 2 "reg_or_short_operand" "rI"))
1123                           (const_int 0)
1124                           (minus:SI (match_dup 2) (match_dup 1)))
1125          (const_int 0)))
1126    (clobber (match_scratch:SI 3 "=r"))]
1127   "TARGET_POWER"
1128   "doz%I2. %3,%1,%2"
1129   [(set_attr "type" "delayed_compare")])
1130
1131 (define_insn ""
1132   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1133         (compare:CC
1134          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1135                               (match_operand:SI 2 "reg_or_short_operand" "rI"))
1136                           (const_int 0)
1137                           (minus:SI (match_dup 2) (match_dup 1)))
1138          (const_int 0)))
1139    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1140         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1141                          (const_int 0)
1142                          (minus:SI (match_dup 2) (match_dup 1))))]
1143   "TARGET_POWER"
1144   "doz%I2. %0,%1,%2"
1145   [(set_attr "type" "delayed_compare")])
1146
1147 ;; We don't need abs with condition code because such comparisons should
1148 ;; never be done.
1149 (define_expand "abssi2"
1150   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1151         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
1152   ""
1153   "
1154 {
1155   if (!TARGET_POWER)
1156     {
1157       emit_insn (gen_abssi2_nopower (operands[0], operands[1]));
1158       DONE;
1159     }
1160 }")
1161
1162 (define_insn "abssi2_power"
1163   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1164         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
1165   "TARGET_POWER"
1166   "abs %0,%1")
1167
1168 (define_insn "abssi2_nopower"
1169   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1170         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
1171    (clobber (match_scratch:SI 2 "=&r,&r"))]
1172   "!TARGET_POWER"
1173   "*
1174 {
1175   return (TARGET_POWERPC)
1176     ? \"{srai|srawi} %2,%1,31\;xor %0,%2,%1\;subf %0,%2,%0\"
1177     : \"{srai|srawi} %2,%1,31\;xor %0,%2,%1\;{sf|subfc} %0,%2,%0\";
1178 }"
1179   [(set_attr "length" "12")])
1180
1181 (define_split
1182   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1183         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
1184    (clobber (match_scratch:SI 2 "=&r,&r"))]
1185   "!TARGET_POWER && reload_completed"
1186   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
1187    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
1188    (set (match_dup 0) (minus:SI (match_dup 0) (match_dup 2)))]
1189   "")
1190
1191 (define_insn ""
1192   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1193         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
1194   "TARGET_POWER"
1195   "nabs %0,%1")
1196
1197 (define_insn ""
1198   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1199         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
1200    (clobber (match_scratch:SI 2 "=&r,&r"))]
1201   "!TARGET_POWER"
1202   "*
1203 {
1204   return (TARGET_POWERPC)
1205     ? \"{srai|srawi} %2,%1,31\;xor %0,%2,%1\;subf %0,%0,%2\"
1206     : \"{srai|srawi} %2,%1,31\;xor %0,%2,%1\;{sf|subfc} %0,%0,%2\";
1207 }"
1208   [(set_attr "length" "12")])
1209
1210 (define_split
1211   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
1212         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
1213    (clobber (match_scratch:SI 2 "=&r,&r"))]
1214   "!TARGET_POWER && reload_completed"
1215   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
1216    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
1217    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 0)))]
1218   "")
1219
1220 (define_insn "negsi2"
1221   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1222         (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
1223   ""
1224   "neg %0,%1")
1225
1226 (define_insn ""
1227   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1228         (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1229                     (const_int 0)))
1230    (clobber (match_scratch:SI 2 "=r"))]
1231   ""
1232   "neg. %2,%1"
1233   [(set_attr "type" "compare")])
1234
1235 (define_insn ""
1236   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
1237         (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1238                     (const_int 0)))
1239    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1240         (neg:SI (match_dup 1)))]
1241   ""
1242   "neg. %0,%1"
1243   [(set_attr "type" "compare")])
1244
1245 (define_insn "ffssi2"
1246   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r")
1247         (ffs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
1248   ""
1249   "neg %0,%1\;and %0,%0,%1\;{cntlz|cntlzw} %0,%0\;{sfi|subfic} %0,%0,32"
1250   [(set_attr "length" "16")])
1251
1252 (define_expand "mulsi3"
1253   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
1254    (use (match_operand:SI 1 "gpc_reg_operand" ""))
1255    (use (match_operand:SI 2 "reg_or_short_operand" ""))]
1256   ""
1257   "
1258 {
1259   if (TARGET_POWER)
1260     emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
1261   else
1262     emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
1263   DONE;
1264 }")
1265
1266 (define_insn "mulsi3_mq"
1267   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1268         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1269                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))
1270    (clobber (match_scratch:SI 3 "=q,q"))]
1271   "TARGET_POWER"
1272   "@
1273    {muls|mullw} %0,%1,%2
1274    {muli|mulli} %0,%1,%2"
1275    [(set_attr "type" "imul")])
1276
1277 (define_insn "mulsi3_no_mq"
1278   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1279         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
1280                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
1281   "! TARGET_POWER"
1282   "@
1283    {muls|mullw} %0,%1,%2
1284    {muli|mulli} %0,%1,%2"
1285    [(set_attr "type" "imul")])
1286
1287 (define_insn ""
1288   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1289         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1290                              (match_operand:SI 2 "gpc_reg_operand" "r"))
1291                     (const_int 0)))
1292    (clobber (match_scratch:SI 3 "=r"))
1293    (clobber (match_scratch:SI 4 "=q"))]
1294   "TARGET_POWER"
1295   "{muls.|mullw.} %3,%1,%2"
1296   [(set_attr "type" "delayed_compare")])
1297
1298 (define_insn ""
1299   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1300         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1301                              (match_operand:SI 2 "gpc_reg_operand" "r"))
1302                     (const_int 0)))
1303    (clobber (match_scratch:SI 3 "=r"))]
1304   "! TARGET_POWER"
1305   "{muls.|mullw.} %3,%1,%2"
1306   [(set_attr "type" "delayed_compare")])
1307
1308 (define_insn ""
1309   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1310         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1311                              (match_operand:SI 2 "gpc_reg_operand" "r"))
1312                     (const_int 0)))
1313    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1314         (mult:SI (match_dup 1) (match_dup 2)))
1315    (clobber (match_scratch:SI 4 "=q"))]
1316   "TARGET_POWER"
1317   "{muls.|mullw.} %0,%1,%2"
1318   [(set_attr "type" "delayed_compare")])
1319
1320 (define_insn ""
1321   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1322         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1323                              (match_operand:SI 2 "gpc_reg_operand" "r"))
1324                     (const_int 0)))
1325    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1326         (mult:SI (match_dup 1) (match_dup 2)))]
1327   "! TARGET_POWER"
1328   "{muls.|mullw.} %0,%1,%2"
1329   [(set_attr "type" "delayed_compare")])
1330
1331 ;; Operand 1 is divided by operand 2; quotient goes to operand
1332 ;; 0 and remainder to operand 3.
1333 ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
1334
1335 (define_expand "divmodsi4"
1336   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
1337                    (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
1338                            (match_operand:SI 2 "gpc_reg_operand" "")))
1339               (set (match_operand:SI 3 "gpc_reg_operand" "")
1340                    (mod:SI (match_dup 1) (match_dup 2)))])]
1341   "TARGET_POWER || (! TARGET_POWER && ! TARGET_POWERPC)"
1342   "
1343 {
1344   if (! TARGET_POWER && ! TARGET_POWERPC)
1345     {
1346       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
1347       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
1348       emit_insn (gen_divss_call ());
1349       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
1350       emit_move_insn (operands[3], gen_rtx (REG, SImode, 4));
1351       DONE;
1352     }
1353 }")
1354
1355 (define_insn ""
1356   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1357         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1358                 (match_operand:SI 2 "gpc_reg_operand" "r")))
1359    (set (match_operand:SI 3 "gpc_reg_operand" "=q")
1360         (mod:SI (match_dup 1) (match_dup 2)))]
1361   "TARGET_POWER"
1362   "divs %0,%1,%2"
1363   [(set_attr "type" "idiv")])
1364
1365 (define_insn ""
1366   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1367         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1368                 (match_operand:SI 2 "gpc_reg_operand" "r")))]
1369   "TARGET_POWERPC"
1370   "divw %0,%1,%2"
1371   [(set_attr "type" "idiv")])
1372
1373 (define_expand "udivsi3"
1374   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1375         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
1376                  (match_operand:SI 2 "gpc_reg_operand" "")))]
1377   "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
1378   "
1379 {
1380   if (! TARGET_POWER && ! TARGET_POWERPC)
1381     {
1382       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
1383       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
1384       emit_insn (gen_quous_call ());
1385       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
1386       DONE;
1387     }
1388 }")
1389
1390 (define_insn ""
1391   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1392         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1393                  (match_operand:SI 2 "gpc_reg_operand" "r")))]
1394   "TARGET_POWERPC"
1395   "divwu %0,%1,%2"
1396   [(set_attr "type" "idiv")])
1397
1398 ;; For powers of two we can do srai/aze for divide and then adjust for
1399 ;; modulus.  If it isn't a power of two, FAIL on POWER so divmodsi4 will be
1400 ;; used; for PowerPC, force operands into register and do a normal divide;
1401 ;; for AIX common-mode, use quoss call on register operands.
1402 (define_expand "divsi3"
1403   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1404         (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
1405                 (match_operand:SI 2 "reg_or_cint_operand" "")))]
1406   ""
1407   "
1408 {
1409   if (GET_CODE (operands[2]) == CONST_INT
1410       && exact_log2 (INTVAL (operands[2])) >= 0)
1411     ;
1412   else if (TARGET_POWERPC)
1413     operands[2] = force_reg (SImode, operands[2]);
1414   else if (TARGET_POWER)
1415     FAIL;
1416   else
1417     {
1418       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
1419       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
1420       emit_insn (gen_quoss_call ());
1421       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
1422       DONE;
1423     }
1424 }")
1425
1426 (define_expand "modsi3"
1427   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
1428    (use (match_operand:SI 1 "gpc_reg_operand" ""))
1429    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
1430   ""
1431   "
1432 {
1433   int i = exact_log2 (INTVAL (operands[2]));
1434   rtx temp1;
1435   rtx temp2;
1436
1437   if (GET_CODE (operands[2]) != CONST_INT || i < 0)
1438     FAIL;
1439
1440   temp1 = gen_reg_rtx (SImode);
1441   temp2 = gen_reg_rtx (SImode);
1442
1443   emit_insn (gen_divsi3 (temp1, operands[1], operands[2]));
1444   emit_insn (gen_ashlsi3 (temp2, temp1, GEN_INT (i)));
1445   emit_insn (gen_subsi3 (operands[0], operands[1], temp2));
1446   DONE;
1447 }")
1448
1449 (define_insn ""
1450   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1451         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1452                 (match_operand:SI 2 "const_int_operand" "N")))]
1453   "exact_log2 (INTVAL (operands[2])) >= 0"
1454   "{srai|srawi} %0,%1,%p2\;{aze|addze} %0,%0"
1455   [(set_attr "length" "8")])
1456
1457 (define_insn ""
1458   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1459         (compare:CC (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1460                             (match_operand:SI 2 "const_int_operand" "N"))
1461                     (const_int 0)))
1462    (clobber (match_scratch:SI 3 "=r"))]
1463   "exact_log2 (INTVAL (operands[2])) >= 0"
1464   "{srai|srawi} %3,%1,%p2\;{aze.|addze.} %3,%3"
1465   [(set_attr "type" "compare")
1466    (set_attr "length" "8")])
1467
1468 (define_insn ""
1469   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1470         (compare:CC (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
1471                             (match_operand:SI 2 "const_int_operand" "N"))
1472                     (const_int 0)))
1473    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1474         (div:SI (match_dup 1) (match_dup 2)))]
1475   "exact_log2 (INTVAL (operands[2])) >= 0"
1476   "{srai|srawi} %0,%1,%p2\;{aze.|addze.} %0,%0"
1477   [(set_attr "type" "compare")
1478    (set_attr "length" "8")])
1479
1480 (define_insn ""
1481   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1482         (udiv:SI
1483          (plus:DI (ashift:DI
1484                    (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
1485                    (const_int 32))
1486                   (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
1487          (match_operand:SI 3 "gpc_reg_operand" "r")))
1488    (set (match_operand:SI 2 "register_operand" "=*q")
1489         (umod:SI
1490          (plus:DI (ashift:DI
1491                    (zero_extend:DI (match_dup 1)) (const_int 32))
1492                   (zero_extend:DI (match_dup 4)))
1493          (match_dup 3)))]
1494   "TARGET_POWER"
1495   "div %0,%1,%3"
1496   [(set_attr "type" "idiv")])
1497
1498 ;; To do unsigned divide we handle the cases of the divisor looking like a
1499 ;; negative number.  If it is a constant that is less than 2**31, we don't
1500 ;; have to worry about the branches.  So make a few subroutines here.
1501 ;;
1502 ;; First comes the normal case.
1503 (define_expand "udivmodsi4_normal"
1504   [(set (match_dup 4) (const_int 0))
1505    (parallel [(set (match_operand:SI 0 "" "")
1506                    (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
1507                                                 (const_int 32))
1508                                      (zero_extend:DI (match_operand:SI 1 "" "")))
1509                             (match_operand:SI 2 "" "")))
1510               (set (match_operand:SI 3 "" "")
1511                    (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
1512                                                 (const_int 32))
1513                                      (zero_extend:DI (match_dup 1)))
1514                             (match_dup 2)))])]
1515   "TARGET_POWER"
1516   "
1517 { operands[4] = gen_reg_rtx (SImode); }")
1518
1519 ;; This handles the branches.
1520 (define_expand "udivmodsi4_tests"
1521   [(set (match_operand:SI 0 "" "") (const_int 0))
1522    (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
1523    (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
1524    (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
1525                            (label_ref (match_operand:SI 4 "" "")) (pc)))
1526    (set (match_dup 0) (const_int 1))
1527    (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
1528    (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
1529    (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
1530                            (label_ref (match_dup 4)) (pc)))]
1531   "TARGET_POWER"
1532   "
1533 { operands[5] = gen_reg_rtx (CCUNSmode);
1534   operands[6] = gen_reg_rtx (CCmode);
1535 }")
1536
1537 (define_expand "udivmodsi4"
1538   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
1539                    (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
1540                             (match_operand:SI 2 "reg_or_cint_operand" "")))
1541               (set (match_operand:SI 3 "gpc_reg_operand" "")
1542                    (umod:SI (match_dup 1) (match_dup 2)))])]
1543   ""
1544   "
1545 {
1546   rtx label = 0;
1547
1548   if (! TARGET_POWER)
1549     if (! TARGET_POWERPC)
1550       {
1551         emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
1552         emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
1553         emit_insn (gen_divus_call ());
1554         emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
1555         emit_move_insn (operands[3], gen_rtx (REG, SImode, 4));
1556         DONE;
1557       }
1558     else
1559       FAIL;
1560
1561   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
1562     {
1563       operands[2] = force_reg (SImode, operands[2]);
1564       label = gen_label_rtx ();
1565       emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
1566                                   operands[3], label));
1567     }
1568   else
1569     operands[2] = force_reg (SImode, operands[2]);
1570
1571   emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
1572                                operands[3]));
1573   if (label)
1574     emit_label (label);
1575
1576   DONE;
1577 }")
1578
1579 ;; AIX architecture-independent common-mode multiply (DImode),
1580 ;; divide/modulus, and quotient subroutine calls.  Input operands in R3 and
1581 ;; R4; results in R3 and sometimes R4; link register always clobbered by bla
1582 ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
1583 ;; assumed unused if generating common-mode, so ignore.
1584 (define_insn "mulh_call"
1585   [(set (reg:SI 3)
1586         (truncate:SI
1587          (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
1588                                (sign_extend:DI (reg:SI 4)))
1589                       (const_int 32))))
1590    (clobber (match_scratch:SI 0 "=l"))]
1591   "! TARGET_POWER && ! TARGET_POWERPC"
1592   "bla __mulh"
1593   [(set_attr "type" "imul")])
1594
1595 (define_insn "mull_call"
1596   [(set (reg:DI 3)
1597         (mult:DI (sign_extend:DI (reg:SI 3))
1598                  (sign_extend:DI (reg:SI 4))))
1599    (clobber (match_scratch:SI 0 "=l"))
1600    (clobber (reg:SI 0))]
1601   "! TARGET_POWER && ! TARGET_POWERPC"
1602   "bla __mull"
1603   [(set_attr "type" "imul")])
1604
1605 (define_insn "divss_call"
1606   [(set (reg:SI 3)
1607         (div:SI (reg:SI 3) (reg:SI 4)))
1608    (set (reg:SI 4)
1609         (mod:SI (reg:SI 3) (reg:SI 4)))
1610    (clobber (match_scratch:SI 0 "=l"))
1611    (clobber (reg:SI 0))]
1612   "! TARGET_POWER && ! TARGET_POWERPC"
1613   "bla __divss"
1614   [(set_attr "type" "idiv")])
1615
1616 (define_insn "divus_call"
1617   [(set (reg:SI 3)
1618         (udiv:SI (reg:SI 3) (reg:SI 4)))
1619    (set (reg:SI 4)
1620         (umod:SI (reg:SI 3) (reg:SI 4)))
1621    (clobber (match_scratch:SI 0 "=l"))
1622    (clobber (reg:SI 0))
1623    (clobber (match_scratch:CC 1 "=x"))
1624    (clobber (reg:CC 69))]
1625   "! TARGET_POWER && ! TARGET_POWERPC"
1626   "bla __divus"
1627   [(set_attr "type" "idiv")])
1628
1629 (define_insn "quoss_call"
1630   [(set (reg:SI 3)
1631         (div:SI (reg:SI 3) (reg:SI 4)))
1632    (clobber (match_scratch:SI 0 "=l"))]
1633   "! TARGET_POWER && ! TARGET_POWERPC"
1634   "bla __quoss"
1635   [(set_attr "type" "idiv")])
1636
1637 (define_insn "quous_call"
1638   [(set (reg:SI 3)
1639         (udiv:SI (reg:SI 3) (reg:SI 4)))
1640    (clobber (match_scratch:SI 0 "=l"))
1641    (clobber (reg:SI 0))
1642    (clobber (match_scratch:CC 1 "=x"))
1643    (clobber (reg:CC 69))]
1644   "! TARGET_POWER && ! TARGET_POWERPC"
1645   "bla __quous"
1646   [(set_attr "type" "idiv")])
1647 \f
1648 (define_insn "andsi3"
1649   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
1650         (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
1651                 (match_operand:SI 2 "and_operand" "?r,L,K,J")))
1652    (clobber (match_scratch:CC 3 "=X,X,x,x"))]
1653   ""
1654   "@
1655    and %0,%1,%2
1656    {rlinm|rlwinm} %0,%1,0,%m2,%M2
1657    {andil.|andi.} %0,%1,%b2
1658    {andiu.|andis.} %0,%1,%u2")
1659
1660 (define_insn ""
1661   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x")
1662         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
1663                             (match_operand:SI 2 "and_operand" "r,K,J,L"))
1664                     (const_int 0)))
1665    (clobber (match_scratch:SI 3 "=r,r,r,r"))]
1666   ""
1667   "@
1668    and. %3,%1,%2
1669    {andil.|andi.} %3,%1,%b2
1670    {andiu.|andis.} %3,%1,%u2
1671    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2"
1672   [(set_attr "type" "compare,compare,compare,delayed_compare")])
1673
1674 (define_insn ""
1675   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x")
1676         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
1677                             (match_operand:SI 2 "and_operand" "r,K,J,L"))
1678                     (const_int 0)))
1679    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
1680         (and:SI (match_dup 1) (match_dup 2)))]
1681   ""
1682   "@
1683    and. %0,%1,%2
1684    {andil.|andi.} %0,%1,%b2
1685    {andiu.|andis.} %0,%1,%u2
1686    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2"
1687   [(set_attr "type" "compare,compare,compare,delayed_compare")])
1688
1689 ;; Take a AND with a constant that cannot be done in a single insn and try to
1690 ;; split it into two insns.  This does not verify that the insns are valid
1691 ;; since this need not be done as combine will do it.
1692
1693 (define_split
1694   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1695         (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
1696                 (match_operand:SI 2 "non_and_cint_operand" "")))]
1697   ""
1698   [(set (match_dup 0) (and:SI (match_dup 1) (match_dup 3)))
1699    (set (match_dup 0) (and:SI (match_dup 0) (match_dup 4)))]
1700   "
1701 {
1702   int maskval = INTVAL (operands[2]);
1703   int i, transitions, last_bit_value;
1704   int orig = maskval, first_c = maskval, second_c;
1705
1706   /* We know that MASKVAL must have more than 2 bit-transitions.  Start at
1707      the low-order bit and count for the third transition.  When we get there,
1708      make a first mask that has everything to the left of that position
1709      a one.  Then make the second mask to turn off whatever else is needed.  */
1710
1711   for (i = 1, transitions = 0, last_bit_value = maskval & 1; i < 32; i++)
1712     {
1713       if (((maskval >>= 1) & 1) != last_bit_value)
1714         last_bit_value ^= 1, transitions++;
1715
1716       if (transitions > 2)
1717         {
1718           first_c |= (~0) << i;
1719           break;
1720         }
1721     }
1722
1723   second_c = orig | ~ first_c;
1724
1725   operands[3] = gen_rtx (CONST_INT, VOIDmode, first_c);
1726   operands[4] = gen_rtx (CONST_INT, VOIDmode, second_c);
1727 }")
1728
1729 (define_insn "iorsi3"
1730   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
1731         (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
1732                 (match_operand:SI 2 "logical_operand" "r,K,J")))]
1733   ""
1734   "@
1735    or %0,%1,%2
1736    {oril|ori} %0,%1,%b2
1737    {oriu|oris} %0,%1,%u2")
1738
1739 (define_insn ""
1740   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1741         (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1742                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1743                     (const_int 0)))
1744    (clobber (match_scratch:SI 3 "=r"))]
1745   ""
1746   "or. %3,%1,%2"
1747   [(set_attr "type" "compare")])
1748
1749 (define_insn ""
1750   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1751         (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1752                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1753                     (const_int 0)))
1754    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1755         (ior:SI (match_dup 1) (match_dup 2)))]
1756   ""
1757   "or. %0,%1,%2"
1758   [(set_attr "type" "compare")])
1759
1760 ;; Split an IOR that we can't do in one insn into two insns, each of which
1761 ;; does one 16-bit part.  This is used by combine.
1762
1763 (define_split
1764   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1765         (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
1766                 (match_operand:SI 2 "non_logical_cint_operand" "")))]
1767   ""
1768   [(set (match_dup 0) (ior:SI (match_dup 1) (match_dup 3)))
1769    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 4)))]
1770 "
1771 {
1772   operands[3] = gen_rtx (CONST_INT, VOIDmode,
1773                          INTVAL (operands[2]) & 0xffff0000);
1774   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
1775 }")
1776
1777 (define_insn "xorsi3"
1778   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
1779         (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
1780                 (match_operand:SI 2 "logical_operand" "r,K,J")))]
1781   ""
1782   "@
1783    xor %0,%1,%2
1784    {xoril|xori} %0,%1,%b2
1785    {xoriu|xoris} %0,%1,%u2")
1786
1787 (define_insn ""
1788   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1789         (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1790                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1791                     (const_int 0)))
1792    (clobber (match_scratch:SI 3 "=r"))]
1793   ""
1794   "xor. %3,%1,%2"
1795   [(set_attr "type" "compare")])
1796
1797 (define_insn ""
1798   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1799         (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1800                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1801                     (const_int 0)))
1802    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1803         (xor:SI (match_dup 1) (match_dup 2)))]
1804   ""
1805   "xor. %0,%1,%2"
1806   [(set_attr "type" "compare")])
1807
1808 ;; Split an XOR that we can't do in one insn into two insns, each of which
1809 ;; does one 16-bit part.  This is used by combine.
1810
1811 (define_split
1812   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1813         (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1814                 (match_operand:SI 2 "non_logical_cint_operand" "")))]
1815   ""
1816   [(set (match_dup 0) (xor:SI (match_dup 1) (match_dup 3)))
1817    (set (match_dup 0) (xor:SI (match_dup 0) (match_dup 4)))]
1818 "
1819 {
1820   operands[3] = gen_rtx (CONST_INT, VOIDmode,
1821                          INTVAL (operands[2]) & 0xffff0000);
1822   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
1823 }")
1824
1825 (define_insn ""
1826   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1827         (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1828                         (match_operand:SI 2 "gpc_reg_operand" "r"))))]
1829    ""
1830    "eqv %0,%1,%2")
1831
1832 (define_insn ""
1833   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1834         (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1835                                     (match_operand:SI 2 "gpc_reg_operand" "r")))
1836                     (const_int 0)))
1837    (clobber (match_scratch:SI 3 "=r"))]
1838    ""
1839    "eqv. %3,%1,%2"
1840    [(set_attr "type" "compare")])
1841
1842 (define_insn ""
1843   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1844         (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
1845                                     (match_operand:SI 2 "gpc_reg_operand" "r")))
1846                     (const_int 0)))
1847    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1848         (not:SI (xor:SI (match_dup 1) (match_dup 2))))]
1849    ""
1850    "eqv. %0,%1,%2"
1851    [(set_attr "type" "compare")])
1852
1853 (define_insn ""
1854   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1855         (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1856                 (match_operand:SI 2 "gpc_reg_operand" "r")))]
1857   ""
1858   "andc %0,%2,%1")
1859
1860 (define_insn ""
1861   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1862         (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1863                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1864                     (const_int 0)))
1865    (clobber (match_scratch:SI 3 "=r"))]
1866   ""
1867   "andc. %3,%2,%1"
1868   [(set_attr "type" "compare")])
1869
1870 (define_insn ""
1871   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1872         (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1873                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1874                     (const_int 0)))
1875    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1876         (and:SI (not:SI (match_dup 1)) (match_dup 2)))]
1877   ""
1878   "andc. %0,%2,%1"
1879   [(set_attr "type" "compare")])
1880
1881 (define_insn ""
1882   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1883         (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1884                 (match_operand:SI 2 "gpc_reg_operand" "r")))]
1885   ""
1886   "orc %0,%2,%1")
1887
1888 (define_insn ""
1889   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1890         (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1891                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1892                     (const_int 0)))
1893    (clobber (match_scratch:SI 3 "=r"))]
1894   ""
1895   "orc. %3,%2,%1"
1896   [(set_attr "type" "compare")])
1897
1898 (define_insn ""
1899   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1900         (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
1901                             (match_operand:SI 2 "gpc_reg_operand" "r"))
1902                     (const_int 0)))
1903    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1904         (ior:SI (not:SI (match_dup 1)) (match_dup 2)))]
1905   ""
1906   "orc. %0,%2,%1"
1907   [(set_attr "type" "compare")])
1908
1909 (define_insn ""
1910   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1911         (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1912                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
1913   ""
1914   "nand %0,%1,%2")
1915
1916 (define_insn ""
1917   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1918         (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1919                             (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
1920                     (const_int 0)))
1921    (clobber (match_scratch:SI 3 "=r"))]
1922   ""
1923   "nand. %3,%1,%2"
1924   [(set_attr "type" "compare")])
1925
1926 (define_insn ""
1927   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1928         (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1929                             (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
1930                     (const_int 0)))
1931    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1932         (ior:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
1933   ""
1934   "nand. %0,%1,%2"
1935   [(set_attr "type" "compare")])
1936
1937 (define_insn ""
1938   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1939         (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1940                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
1941   ""
1942   "nor %0,%1,%2")
1943
1944 (define_insn ""
1945   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
1946         (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1947                             (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
1948                     (const_int 0)))
1949    (clobber (match_scratch:SI 3 "=r"))]
1950   ""
1951   "nor. %3,%1,%2"
1952   [(set_attr "type" "compare")])
1953
1954 (define_insn ""
1955   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1956         (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
1957                             (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
1958                     (const_int 0)))
1959    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1960         (and:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
1961   ""
1962   "nor. %0,%1,%2"
1963   [(set_attr "type" "compare")])
1964
1965 ;; maskir insn.  We need four forms because things might be in arbitrary
1966 ;; orders.  Don't define forms that only set CR fields because these
1967 ;; would modify an input register.
1968
1969 (define_insn ""
1970   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1971         (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
1972                         (match_operand:SI 1 "gpc_reg_operand" "0"))
1973                 (and:SI (match_dup 2)
1974                         (match_operand:SI 3 "gpc_reg_operand" "r"))))]
1975   "TARGET_POWER"
1976   "maskir %0,%3,%2")
1977
1978 (define_insn ""
1979   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1980         (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
1981                         (match_operand:SI 1 "gpc_reg_operand" "0"))
1982                 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
1983                         (match_dup 2))))]
1984   "TARGET_POWER"
1985   "maskir %0,%3,%2")
1986
1987 (define_insn ""
1988   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1989         (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
1990                         (match_operand:SI 3 "gpc_reg_operand" "r"))
1991                 (and:SI (not:SI (match_dup 2))
1992                         (match_operand:SI 1 "gpc_reg_operand" "0"))))]
1993   "TARGET_POWER"
1994   "maskir %0,%3,%2")
1995
1996 (define_insn ""
1997   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1998         (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
1999                         (match_operand:SI 2 "gpc_reg_operand" "r"))
2000                 (and:SI (not:SI (match_dup 2))
2001                         (match_operand:SI 1 "gpc_reg_operand" "0"))))]
2002   "TARGET_POWER"
2003   "maskir %0,%3,%2")
2004
2005 (define_insn ""
2006   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2007         (compare:CC
2008          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
2009                          (match_operand:SI 1 "gpc_reg_operand" "0"))
2010                  (and:SI (match_dup 2)
2011                          (match_operand:SI 3 "gpc_reg_operand" "r")))
2012          (const_int 0)))
2013    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2014         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2015                 (and:SI (match_dup 2) (match_dup 3))))]
2016   "TARGET_POWER"
2017   "maskir. %0,%3,%2"
2018   [(set_attr "type" "compare")])
2019
2020 (define_insn ""
2021   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2022         (compare:CC
2023          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
2024                          (match_operand:SI 1 "gpc_reg_operand" "0"))
2025                  (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2026                          (match_dup 2)))
2027          (const_int 0)))
2028    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2029         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
2030                 (and:SI (match_dup 3) (match_dup 2))))]
2031   "TARGET_POWER"
2032   "maskir. %0,%3,%2"
2033   [(set_attr "type" "compare")])
2034
2035 (define_insn ""
2036   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2037         (compare:CC
2038          (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
2039                          (match_operand:SI 3 "gpc_reg_operand" "r"))
2040                  (and:SI (not:SI (match_dup 2))
2041                          (match_operand:SI 1 "gpc_reg_operand" "0")))
2042          (const_int 0)))
2043    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2044         (ior:SI (and:SI (match_dup 2) (match_dup 3))
2045                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2046   "TARGET_POWER"
2047   "maskir. %0,%3,%2"
2048   [(set_attr "type" "compare")])
2049
2050 (define_insn ""
2051   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2052         (compare:CC
2053          (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2054                          (match_operand:SI 2 "gpc_reg_operand" "r"))
2055                  (and:SI (not:SI (match_dup 2))
2056                          (match_operand:SI 1 "gpc_reg_operand" "0")))
2057          (const_int 0)))
2058    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2059         (ior:SI (and:SI (match_dup 3) (match_dup 2))
2060                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
2061   "TARGET_POWER"
2062   "maskir. %0,%3,%2"
2063   [(set_attr "type" "compare")])
2064 \f
2065 ;; Rotate and shift insns, in all their variants.  These support shifts,
2066 ;; field inserts and extracts, and various combinations thereof.
2067 (define_expand "insv"
2068   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2069                          (match_operand:SI 1 "const_int_operand" "i")
2070                          (match_operand:SI 2 "const_int_operand" "i"))
2071         (match_operand:SI 3 "gpc_reg_operand" "r"))]
2072   ""
2073   "
2074 {
2075   /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
2076      the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
2077      compiler if the address of the structure is taken later.  */
2078   if (GET_CODE (operands[0]) == SUBREG
2079       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
2080     FAIL;
2081 }")
2082
2083 (define_insn ""
2084   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2085                          (match_operand:SI 1 "const_int_operand" "i")
2086                          (match_operand:SI 2 "const_int_operand" "i"))
2087         (match_operand:SI 3 "gpc_reg_operand" "r"))]
2088   ""
2089   "*
2090 {
2091   int start = INTVAL (operands[2]) & 31;
2092   int size = INTVAL (operands[1]) & 31;
2093
2094   operands[4] = gen_rtx (CONST_INT, VOIDmode, 32 - start - size);
2095   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
2096   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2097 }")
2098
2099 (define_insn ""
2100   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2101                          (match_operand:SI 1 "const_int_operand" "i")
2102                          (match_operand:SI 2 "const_int_operand" "i"))
2103         (ashift:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2104                    (match_operand:SI 4 "const_int_operand" "i")))]
2105   ""
2106   "*
2107 {
2108   int shift = INTVAL (operands[4]) & 31;
2109   int start = INTVAL (operands[2]) & 31;
2110   int size = INTVAL (operands[1]) & 31;
2111
2112   operands[4] = gen_rtx (CONST_INT, VOIDmode, shift - start - size);
2113   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
2114   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2115 }")
2116
2117 (define_insn ""
2118   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2119                          (match_operand:SI 1 "const_int_operand" "i")
2120                          (match_operand:SI 2 "const_int_operand" "i"))
2121         (ashiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2122                      (match_operand:SI 4 "const_int_operand" "i")))]
2123   ""
2124   "*
2125 {
2126   int shift = INTVAL (operands[4]) & 31;
2127   int start = INTVAL (operands[2]) & 31;
2128   int size = INTVAL (operands[1]) & 31;
2129
2130   operands[4] = gen_rtx (CONST_INT, VOIDmode, 32 - shift - start - size);
2131   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
2132   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2133 }")
2134
2135 (define_insn ""
2136   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2137                          (match_operand:SI 1 "const_int_operand" "i")
2138                          (match_operand:SI 2 "const_int_operand" "i"))
2139         (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2140                      (match_operand:SI 4 "const_int_operand" "i")))]
2141   ""
2142   "*
2143 {
2144   int shift = INTVAL (operands[4]) & 31;
2145   int start = INTVAL (operands[2]) & 31;
2146   int size = INTVAL (operands[1]) & 31;
2147
2148   operands[4] = gen_rtx (CONST_INT, VOIDmode, 32 - shift - start - size);
2149   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
2150   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
2151 }")
2152
2153 (define_insn ""
2154   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2155                          (match_operand:SI 1 "const_int_operand" "i")
2156                          (match_operand:SI 2 "const_int_operand" "i"))
2157         (zero_extract:SI (match_operand:SI 3 "gpc_reg_operand" "r")
2158                          (match_operand:SI 4 "const_int_operand" "i")
2159                          (match_operand:SI 5 "const_int_operand" "i")))]
2160   "INTVAL (operands[4]) >= INTVAL (operands[1])"
2161   "*
2162 {
2163   int extract_start = INTVAL (operands[5]) & 31;
2164   int extract_size = INTVAL (operands[4]) & 31;
2165   int insert_start = INTVAL (operands[2]) & 31;
2166   int insert_size = INTVAL (operands[1]) & 31;
2167
2168 /* Align extract field with insert field */
2169   operands[5] = gen_rtx (CONST_INT, VOIDmode,
2170                          extract_start + extract_size - insert_start - insert_size);
2171   operands[1] = gen_rtx (CONST_INT, VOIDmode, insert_start + insert_size - 1);
2172   return \"{rlimi|rlwimi} %0,%3,%h5,%h2,%h1\";
2173 }")
2174
2175 (define_insn ""
2176   [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
2177                          (match_operand:DI 1 "const_int_operand" "i")
2178                          (match_operand:DI 2 "const_int_operand" "i"))
2179         (match_operand:DI 3 "gpc_reg_operand" "r"))]
2180   "TARGET_POWERPC64"
2181   "*
2182 {
2183   int start = INTVAL (operands[2]) & 63;
2184   int size = INTVAL (operands[1]) & 63;
2185
2186   operands[2] = gen_rtx (CONST_INT, VOIDmode, 64 - start - size);
2187   return \"rldimi %0,%3,%H2,%H1\";
2188 }")
2189
2190 (define_expand "extzv"
2191   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2192         (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2193                          (match_operand:SI 2 "const_int_operand" "i")
2194                          (match_operand:SI 3 "const_int_operand" "i")))]
2195   ""
2196   "
2197 {
2198   /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
2199      the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
2200      compiler if the address of the structure is taken later.  */
2201   if (GET_CODE (operands[0]) == SUBREG
2202       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
2203     FAIL;
2204 }")
2205
2206 (define_insn ""
2207   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2208         (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2209                          (match_operand:SI 2 "const_int_operand" "i")
2210                          (match_operand:SI 3 "const_int_operand" "i")))]
2211   ""
2212   "*
2213 {
2214   int start = INTVAL (operands[3]) & 31;
2215   int size = INTVAL (operands[2]) & 31;
2216
2217   if (start + size >= 32)
2218     operands[3] = const0_rtx;
2219   else
2220     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2221   return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
2222 }")
2223
2224 (define_insn ""
2225   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2226         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2227                          (match_operand:SI 2 "const_int_operand" "i")
2228                          (match_operand:SI 3 "const_int_operand" "i"))
2229                     (const_int 0)))
2230    (clobber (match_scratch:SI 4 "=r"))]
2231   ""
2232   "*
2233 {
2234   int start = INTVAL (operands[3]) & 31;
2235   int size = INTVAL (operands[2]) & 31;
2236
2237   /* If the bitfield being tested fits in the upper or lower half of a
2238      word, it is possible to use andiu. or andil. to test it.  This is
2239      useful because the condition register set-use delay is smaller for
2240      andi[ul]. than for rlinm.  This doesn't work when the starting bit
2241      position is 0 because the LT and GT bits may be set wrong.  */
2242
2243   if ((start > 0 && start + size <= 16) || start >= 16)
2244     {
2245       operands[3] = gen_rtx (CONST_INT, VOIDmode,
2246                              ((1 << (16 - (start & 15)))
2247                               - (1 << (16 - (start & 15) - size))));
2248       if (start < 16)
2249         return \"{andiu.|andis.} %4,%1,%3\";
2250       else
2251         return \"{andil.|andi.} %4,%1,%3\";
2252     }
2253
2254   if (start + size >= 32)
2255     operands[3] = const0_rtx;
2256   else
2257     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2258   return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
2259 }"
2260   [(set_attr "type" "compare")])
2261
2262 (define_insn ""
2263   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2264         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2265                          (match_operand:SI 2 "const_int_operand" "i")
2266                          (match_operand:SI 3 "const_int_operand" "i"))
2267                     (const_int 0)))
2268    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2269         (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
2270   ""
2271   "*
2272 {
2273   int start = INTVAL (operands[3]) & 31;
2274   int size = INTVAL (operands[2]) & 31;
2275
2276   if (start >= 16 && start + size == 32)
2277     {
2278       operands[3] = gen_rtx (CONST_INT, VOIDmode, (1 << (32 - start)) - 1);
2279       return \"{andil.|andi.} %0,%1,%3\";
2280     }
2281
2282   if (start + size >= 32)
2283     operands[3] = const0_rtx;
2284   else
2285     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2286   return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
2287 }"
2288   [(set_attr "type" "delayed_compare")])
2289
2290 (define_insn ""
2291   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
2292         (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
2293                          (match_operand:DI 2 "const_int_operand" "i")
2294                          (match_operand:DI 3 "const_int_operand" "i")))]
2295   "TARGET_POWERPC64"
2296   "*
2297 {
2298   int start = INTVAL (operands[3]) & 63;
2299   int size = INTVAL (operands[2]) & 63;
2300
2301   if (start + size >= 64)
2302     operands[3] = const0_rtx;
2303   else
2304     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2305   operands[2] = gen_rtx (CONST_INT, VOIDmode, 64 - size);
2306   return \"rldicl %0,%1,%3,%2\";
2307 }")
2308
2309 (define_insn ""
2310   [(set (match_operand:CC 0 "gpc_reg_operand" "=x")
2311         (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
2312                          (match_operand:DI 2 "const_int_operand" "i")
2313                          (match_operand:DI 3 "const_int_operand" "i"))
2314                     (const_int 0)))
2315    (clobber (match_scratch:DI 4 "=r"))]
2316   "TARGET_POWERPC64"
2317   "*
2318 {
2319   int start = INTVAL (operands[3]) & 63;
2320   int size = INTVAL (operands[2]) & 63;
2321
2322   if (start + size >= 64)
2323     operands[3] = const0_rtx;
2324   else
2325     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2326   operands[2] = gen_rtx (CONST_INT, VOIDmode, 64 - size);
2327   return \"rldicl. %4,%1,%3,%2\";
2328 }")
2329
2330 (define_insn ""
2331   [(set (match_operand:CC 4 "gpc_reg_operand" "=x")
2332         (compare:CC (zero_extract:DI (match_operand:DI 1 "gpc_reg_operand" "r")
2333                          (match_operand:DI 2 "const_int_operand" "i")
2334                          (match_operand:DI 3 "const_int_operand" "i"))
2335                     (const_int 0)))
2336    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
2337         (zero_extract:DI (match_dup 1) (match_dup 2) (match_dup 3)))]
2338   "TARGET_POWERPC64"
2339   "*
2340 {
2341   int start = INTVAL (operands[3]) & 63;
2342   int size = INTVAL (operands[2]) & 63;
2343
2344   if (start + size >= 64)
2345     operands[3] = const0_rtx;
2346   else
2347     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
2348   operands[2] = gen_rtx (CONST_INT, VOIDmode, 64 - size);
2349   return \"rldicl. %0,%1,%3,%2\";
2350 }")
2351
2352 (define_insn "rotlsi3"
2353   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2354         (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2355                    (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
2356   ""
2357   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffffffff")
2358
2359 (define_insn ""
2360   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2361         (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2362                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2363                     (const_int 0)))
2364    (clobber (match_scratch:SI 3 "=r"))]
2365   ""
2366   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffffffff"
2367   [(set_attr "type" "delayed_compare")])
2368
2369 (define_insn ""
2370   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2371         (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2372                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2373                     (const_int 0)))
2374    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2375         (rotate:SI (match_dup 1) (match_dup 2)))]
2376   ""
2377   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffffffff"
2378   [(set_attr "type" "delayed_compare")])
2379
2380 (define_insn ""
2381   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2382         (and:SI (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2383                            (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2384                 (match_operand:SI 3 "mask_operand" "L")))]
2385   ""
2386   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,%m3,%M3")
2387
2388 (define_insn ""
2389   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2390         (compare:CC (and:SI
2391                      (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2392                                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2393                      (match_operand:SI 3 "mask_operand" "L"))
2394                     (const_int 0)))
2395    (clobber (match_scratch:SI 4 "=r"))]
2396   ""
2397   "{rl%I2nm.|rlw%I2nm.} %4,%1,%h2,%m3,%M3"
2398   [(set_attr "type" "delayed_compare")])
2399
2400 (define_insn ""
2401   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2402         (compare:CC (and:SI
2403                      (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2404                                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2405                      (match_operand:SI 3 "mask_operand" "L"))
2406                     (const_int 0)))
2407    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2408         (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
2409   ""
2410   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,%m3,%M3"
2411   [(set_attr "type" "delayed_compare")])
2412
2413 (define_insn ""
2414   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2415         (zero_extend:SI
2416          (subreg:QI
2417           (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2418                      (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
2419   ""
2420   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xff")
2421
2422 (define_insn ""
2423   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2424         (compare:CC (zero_extend:SI
2425                      (subreg:QI
2426                       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2427                                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
2428                     (const_int 0)))
2429    (clobber (match_scratch:SI 3 "=r"))]
2430   ""
2431   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xff"
2432   [(set_attr "type" "delayed_compare")])
2433
2434 (define_insn ""
2435   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2436         (compare:CC (zero_extend:SI
2437                      (subreg:QI
2438                       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2439                                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
2440                     (const_int 0)))
2441    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2442         (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
2443   ""
2444   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xff"
2445   [(set_attr "type" "delayed_compare")])
2446
2447 (define_insn ""
2448   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2449         (zero_extend:SI
2450          (subreg:HI
2451           (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2452                      (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
2453   ""
2454   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffff")
2455
2456 (define_insn ""
2457   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2458         (compare:CC (zero_extend:SI
2459                      (subreg:HI
2460                       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2461                                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
2462                     (const_int 0)))
2463    (clobber (match_scratch:SI 3 "=r"))]
2464   ""
2465   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffff"
2466   [(set_attr "type" "delayed_compare")])
2467
2468 (define_insn ""
2469   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2470         (compare:CC (zero_extend:SI
2471                      (subreg:HI
2472                       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2473                                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
2474                     (const_int 0)))
2475    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2476         (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
2477   ""
2478   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffff"
2479   [(set_attr "type" "delayed_compare")])
2480
2481 ;; Note that we use "sle." instead of "sl." so that we can set
2482 ;; SHIFT_COUNT_TRUNCATED.
2483
2484 (define_expand "ashlsi3"
2485   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
2486    (use (match_operand:SI 1 "gpc_reg_operand" ""))
2487    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
2488   ""
2489   "
2490 {
2491   if (TARGET_POWER)
2492     emit_insn (gen_ashlsi3_power (operands[0], operands[1], operands[2]));
2493   else
2494     emit_insn (gen_ashlsi3_no_power (operands[0], operands[1], operands[2]));
2495   DONE;
2496 }")
2497
2498 (define_insn "ashlsi3_power"
2499   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2500         (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2501                    (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
2502    (clobber (match_scratch:SI 3 "=q,X"))]
2503   "TARGET_POWER"
2504   "@
2505    sle %0,%1,%2
2506    {sli|slwi} %0,%1,%h2"
2507   [(set_attr "length" "8")])
2508
2509 (define_insn "ashlsi3_no_power"
2510   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2511         (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2512                    (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
2513   "! TARGET_POWER"
2514   "{sl|slw}%I2 %0,%1,%h2"
2515   [(set_attr "length" "8")])
2516
2517 (define_insn ""
2518   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
2519         (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2520                                (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
2521                     (const_int 0)))
2522    (clobber (match_scratch:SI 3 "=r,r"))
2523    (clobber (match_scratch:SI 4 "=q,X"))]
2524   "TARGET_POWER"
2525   "@
2526    sle. %3,%1,%2
2527    {sli.|slwi.} %3,%1,%h2"
2528   [(set_attr "type" "delayed_compare")])
2529
2530 (define_insn ""
2531   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2532         (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2533                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2534                     (const_int 0)))
2535    (clobber (match_scratch:SI 3 "=r"))]
2536   "! TARGET_POWER"
2537   "{sl|slw}%I2. %3,%1,%h2"
2538   [(set_attr "type" "delayed_compare")])
2539
2540 (define_insn ""
2541   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
2542         (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2543                                (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
2544                     (const_int 0)))
2545    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2546         (ashift:SI (match_dup 1) (match_dup 2)))
2547    (clobber (match_scratch:SI 4 "=q,X"))]
2548   "TARGET_POWER"
2549   "@
2550    sle. %0,%1,%2
2551    {sli.|slwi.} %0,%1,%h2"
2552   [(set_attr "type" "delayed_compare")])
2553
2554 (define_insn ""
2555   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2556         (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2557                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2558                     (const_int 0)))
2559    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2560         (ashift:SI (match_dup 1) (match_dup 2)))]
2561   "! TARGET_POWER"
2562   "{sl|slw}%I2. %0,%1,%h2"
2563   [(set_attr "type" "delayed_compare")])
2564
2565 (define_insn ""
2566   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2567         (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2568                            (match_operand:SI 2 "const_int_operand" "i"))
2569                 (match_operand:SI 3 "mask_operand" "L")))]
2570   "includes_lshift_p (operands[2], operands[3])"
2571   "{rlinm|rlwinm} %0,%1,%h2,%m3,%M3")
2572
2573 (define_insn ""
2574   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2575         (compare:CC
2576          (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2577                             (match_operand:SI 2 "const_int_operand" "i"))
2578                  (match_operand:SI 3 "mask_operand" "L"))
2579          (const_int 0)))
2580    (clobber (match_scratch:SI 4 "=r"))]
2581   "includes_lshift_p (operands[2], operands[3])"
2582   "{rlinm.|rlwinm.} %4,%1,%h2,%m3,%M3"
2583   [(set_attr "type" "delayed_compare")])
2584
2585 (define_insn ""
2586   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2587         (compare:CC
2588          (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2589                             (match_operand:SI 2 "const_int_operand" "i"))
2590                  (match_operand:SI 3 "mask_operand" "L"))
2591          (const_int 0)))
2592    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2593         (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
2594   "includes_lshift_p (operands[2], operands[3])"
2595   "{rlinm.|rlwinm.} %0,%1,%h2,%m3,%M3"
2596   [(set_attr "type" "delayed_compare")])
2597
2598 ;; The AIX assembler mis-handles "sri x,x,0", so write that case as
2599 ;; "sli x,x,0".
2600 (define_expand "lshrsi3"
2601   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
2602    (use (match_operand:SI 1 "gpc_reg_operand" ""))
2603    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
2604   ""
2605   "
2606 {
2607   if (TARGET_POWER)
2608     emit_insn (gen_lshrsi3_power (operands[0], operands[1], operands[2]));
2609   else
2610     emit_insn (gen_lshrsi3_no_power (operands[0], operands[1], operands[2]));
2611   DONE;
2612 }")
2613
2614 (define_insn "lshrsi3_power"
2615   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
2616         (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
2617                      (match_operand:SI 2 "reg_or_cint_operand" "r,O,i")))
2618    (clobber (match_scratch:SI 3 "=q,X,X"))]
2619   "TARGET_POWER"
2620   "@
2621   sre %0,%1,%2
2622   mr %0,%1
2623   {s%A2i|s%A2wi} %0,%1,%h2")
2624
2625 (define_insn "lshrsi3_no_power"
2626   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2627         (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2628                      (match_operand:SI 2 "reg_or_cint_operand" "O,ri")))]
2629   "! TARGET_POWER"
2630   "@
2631   mr %0,%1
2632   {sr|srw}%I2 %0,%1,%h2")
2633
2634 (define_insn ""
2635   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x")
2636         (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
2637                                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,i"))
2638                     (const_int 0)))
2639    (clobber (match_scratch:SI 3 "=r,X,r"))
2640    (clobber (match_scratch:SI 4 "=q,X,X"))]
2641   "TARGET_POWER"
2642   "@
2643   sre. %3,%1,%2
2644   mr. %1,%1
2645   {s%A2i.|s%A2wi.} %3,%1,%h2"
2646   [(set_attr "type" "delayed_compare")])
2647
2648 (define_insn ""
2649   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
2650         (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2651                                  (match_operand:SI 2 "reg_or_cint_operand" "O,ri"))
2652                     (const_int 0)))
2653    (clobber (match_scratch:SI 3 "=X,r"))]
2654   "! TARGET_POWER"
2655   "@
2656    mr. %1,%1
2657    {sr|srw}%I2. %3,%1,%h2"
2658   [(set_attr "type" "delayed_compare")])
2659
2660 (define_insn ""
2661   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x")
2662         (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
2663                                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,i"))
2664                     (const_int 0)))
2665    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
2666         (lshiftrt:SI (match_dup 1) (match_dup 2)))
2667    (clobber (match_scratch:SI 4 "=q,X,X"))]
2668   "TARGET_POWER"
2669   "@
2670   sre. %0,%1,%2
2671   mr. %0,%1
2672   {s%A2i.|s%A2wi.} %0,%1,%h2"
2673   [(set_attr "type" "delayed_compare")])
2674
2675 (define_insn ""
2676   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
2677         (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2678                                  (match_operand:SI 2 "reg_or_cint_operand" "O,ri"))
2679                     (const_int 0)))
2680    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2681         (lshiftrt:SI (match_dup 1) (match_dup 2)))]
2682   "! TARGET_POWER"
2683   "@
2684    mr. %0,%1
2685    {sr|srw}%I2. %0,%1,%h2"
2686   [(set_attr "type" "delayed_compare")])
2687
2688 (define_insn ""
2689   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2690         (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2691                              (match_operand:SI 2 "const_int_operand" "i"))
2692                 (match_operand:SI 3 "mask_operand" "L")))]
2693   "includes_rshift_p (operands[2], operands[3])"
2694   "{rlinm|rlwinm} %0,%1,%s2,%m3,%M3")
2695
2696 (define_insn ""
2697   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2698         (compare:CC
2699          (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2700                               (match_operand:SI 2 "const_int_operand" "i"))
2701                  (match_operand:SI 3 "mask_operand" "L"))
2702          (const_int 0)))
2703    (clobber (match_scratch:SI 4 "=r"))]
2704   "includes_rshift_p (operands[2], operands[3])"
2705   "{rlinm.|rlwinm.} %4,%1,%s2,%m3,%M3"
2706   [(set_attr "type" "delayed_compare")])
2707
2708 (define_insn ""
2709   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
2710         (compare:CC
2711          (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2712                               (match_operand:SI 2 "const_int_operand" "i"))
2713                  (match_operand:SI 3 "mask_operand" "L"))
2714          (const_int 0)))
2715    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2716         (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
2717   "includes_rshift_p (operands[2], operands[3])"
2718   "{rlinm.|rlwinm.} %0,%1,%s2,%m3,%M3"
2719   [(set_attr "type" "delayed_compare")])
2720
2721 (define_insn ""
2722   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2723         (zero_extend:SI
2724          (subreg:QI
2725           (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2726                        (match_operand:SI 2 "const_int_operand" "i")) 0)))]
2727   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
2728   "{rlinm|rlwinm} %0,%1,%s2,0xff")
2729
2730 (define_insn ""
2731   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2732         (compare:CC
2733          (zero_extend:SI
2734           (subreg:QI
2735            (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2736                         (match_operand:SI 2 "const_int_operand" "i")) 0))
2737          (const_int 0)))
2738    (clobber (match_scratch:SI 3 "=r"))]
2739   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
2740   "{rlinm.|rlwinm.} %3,%1,%s2,0xff"
2741   [(set_attr "type" "delayed_compare")])
2742
2743 (define_insn ""
2744   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2745         (compare:CC
2746          (zero_extend:SI
2747           (subreg:QI
2748            (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2749                         (match_operand:SI 2 "const_int_operand" "i")) 0))
2750          (const_int 0)))
2751    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2752         (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
2753   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
2754   "{rlinm.|rlwinm.} %0,%1,%s2,0xff"
2755   [(set_attr "type" "delayed_compare")])
2756
2757 (define_insn ""
2758   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2759         (zero_extend:SI
2760          (subreg:HI
2761           (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2762                        (match_operand:SI 2 "const_int_operand" "i")) 0)))]
2763   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
2764   "{rlinm|rlwinm} %0,%1,%s2,0xffff")
2765
2766 (define_insn ""
2767   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2768         (compare:CC
2769          (zero_extend:SI
2770           (subreg:HI
2771            (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2772                         (match_operand:SI 2 "const_int_operand" "i")) 0))
2773          (const_int 0)))
2774    (clobber (match_scratch:SI 3 "=r"))]
2775   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
2776   "{rlinm.|rlwinm.} %3,%1,%s2,0xffff"
2777   [(set_attr "type" "delayed_compare")])
2778
2779 (define_insn ""
2780   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2781         (compare:CC
2782          (zero_extend:SI
2783           (subreg:HI
2784            (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2785                         (match_operand:SI 2 "const_int_operand" "i")) 0))
2786          (const_int 0)))
2787    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2788         (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
2789   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
2790   "{rlinm.|rlwinm.} %0,%1,%s2,0xffff"
2791   [(set_attr "type" "delayed_compare")])
2792
2793 (define_insn ""
2794   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2795                          (const_int 1)
2796                          (match_operand:SI 1 "gpc_reg_operand" "r"))
2797         (ashiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
2798                      (const_int 31)))]
2799   "TARGET_POWER"
2800   "rrib %0,%1,%2")
2801
2802 (define_insn ""
2803   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2804                          (const_int 1)
2805                          (match_operand:SI 1 "gpc_reg_operand" "r"))
2806         (lshiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
2807                      (const_int 31)))]
2808   "TARGET_POWER"
2809   "rrib %0,%1,%2")
2810
2811 (define_insn ""
2812   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
2813                          (const_int 1)
2814                          (match_operand:SI 1 "gpc_reg_operand" "r"))
2815         (zero_extract:SI (match_operand:SI 2 "gpc_reg_operand" "r")
2816                          (const_int 1)
2817                          (const_int 0)))]
2818   "TARGET_POWER"
2819   "rrib %0,%1,%2")
2820
2821 (define_expand "ashrsi3"
2822   [(set (match_operand:SI 0 "gpc_reg_operand" "")
2823         (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
2824                      (match_operand:SI 2 "reg_or_cint_operand" "")))]
2825   ""
2826   "
2827 {
2828   if (TARGET_POWER)
2829     emit_insn (gen_ashrsi3_power (operands[0], operands[1], operands[2]));
2830   else
2831     emit_insn (gen_ashrsi3_no_power (operands[0], operands[1], operands[2]));
2832   DONE;
2833 }")
2834
2835 (define_insn "ashrsi3_power"
2836   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2837         (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2838                      (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
2839    (clobber (match_scratch:SI 3 "=q,X"))]
2840   "TARGET_POWER"
2841   "@
2842    srea %0,%1,%2
2843    {srai|srawi} %0,%1,%h2")
2844
2845 (define_insn "ashrsi3_no_power"
2846   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2847         (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2848                      (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
2849   "! TARGET_POWER"
2850   "{sra|sraw}%I2 %0,%1,%h2")
2851
2852 (define_insn ""
2853   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
2854         (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2855                                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
2856                     (const_int 0)))
2857    (clobber (match_scratch:SI 3 "=r,r"))
2858    (clobber (match_scratch:SI 4 "=q,X"))]
2859   "TARGET_POWER"
2860   "@
2861    srea. %3,%1,%2
2862    {srai.|srawi.} %3,%1,%h2"
2863   [(set_attr "type" "delayed_compare")])
2864
2865 (define_insn ""
2866   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
2867         (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2868                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2869                     (const_int 0)))
2870    (clobber (match_scratch:SI 3 "=r"))]
2871   "! TARGET_POWER"
2872   "{sra|sraw}%I2. %3,%1,%h2"
2873   [(set_attr "type" "delayed_compare")])
2874
2875 (define_insn ""
2876   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
2877         (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
2878                                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
2879                     (const_int 0)))
2880    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2881         (ashiftrt:SI (match_dup 1) (match_dup 2)))
2882    (clobber (match_scratch:SI 4 "=q,X"))]
2883   "TARGET_POWER"
2884   "@
2885    srea. %0,%1,%2
2886    {srai.|srawi.} %0,%1,%h2"
2887   [(set_attr "type" "delayed_compare")])
2888
2889 (define_insn ""
2890   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
2891         (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2892                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
2893                     (const_int 0)))
2894    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
2895         (ashiftrt:SI (match_dup 1) (match_dup 2)))]
2896   "! TARGET_POWER"
2897   "{sra|sraw}%I2. %0,%1,%h2"
2898   [(set_attr "type" "delayed_compare")])
2899 \f
2900 ;; Floating-point insns, excluding normal data motion.
2901 ;;
2902 ;; PowerPC has a full set of single-precision floating point instructions.
2903 ;;
2904 ;; For the POWER architecture, we pretend that we have both SFmode and
2905 ;; DFmode insns, while, in fact, all fp insns are actually done in double.
2906 ;; The only conversions we will do will be when storing to memory.  In that
2907 ;; case, we will use the "frsp" instruction before storing.
2908 ;;
2909 ;; Note that when we store into a single-precision memory location, we need to
2910 ;; use the frsp insn first.  If the register being stored isn't dead, we
2911 ;; need a scratch register for the frsp.  But this is difficult when the store
2912 ;; is done by reload.  It is not incorrect to do the frsp on the register in
2913 ;; this case, we just lose precision that we would have otherwise gotten but
2914 ;; is not guaranteed.  Perhaps this should be tightened up at some point.
2915
2916 (define_insn "extendsfdf2"
2917   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
2918         (float_extend:DF (match_operand:SF 1 "gpc_reg_operand" "f")))]
2919   "TARGET_HARD_FLOAT"
2920   "*
2921 {
2922   if (REGNO (operands[0]) == REGNO (operands[1]))
2923     return \"\";
2924   else
2925     return \"fmr %0,%1\";
2926 }"
2927   [(set_attr "type" "fp")])
2928
2929 (define_insn "truncdfsf2"
2930   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2931         (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "f")))]
2932   "TARGET_HARD_FLOAT"
2933   "frsp %0,%1"
2934   [(set_attr "type" "fp")])
2935
2936 (define_insn "aux_truncdfsf2"
2937   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2938         (unspec:SF [(match_operand:SF 1 "gpc_reg_operand" "f")] 0))]
2939   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
2940   "frsp %0,%1"
2941   [(set_attr "type" "fp")])
2942
2943 (define_insn "negsf2"
2944   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2945         (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
2946   "TARGET_HARD_FLOAT"
2947   "fneg %0,%1"
2948   [(set_attr "type" "fp")])
2949
2950 (define_insn "abssf2"
2951   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2952         (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
2953   "TARGET_HARD_FLOAT"
2954   "fabs %0,%1"
2955   [(set_attr "type" "fp")])
2956
2957 (define_insn ""
2958   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2959         (neg:SF (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f"))))]
2960   "TARGET_HARD_FLOAT"
2961   "fnabs %0,%1"
2962   [(set_attr "type" "fp")])
2963
2964 (define_expand "addsf3"
2965   [(set (match_operand:SF 0 "gpc_reg_operand" "")
2966         (plus:SF (match_operand:SF 1 "gpc_reg_operand" "")
2967                  (match_operand:SF 2 "gpc_reg_operand" "")))]
2968   "TARGET_HARD_FLOAT"
2969   "")
2970
2971 (define_insn ""
2972   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2973         (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
2974                  (match_operand:SF 2 "gpc_reg_operand" "f")))]
2975   "TARGET_POWERPC && TARGET_HARD_FLOAT"
2976   "fadds %0,%1,%2"
2977   [(set_attr "type" "fp")])
2978
2979 (define_insn ""
2980   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2981         (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
2982                  (match_operand:SF 2 "gpc_reg_operand" "f")))]
2983   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
2984   "{fa|fadd} %0,%1,%2"
2985   [(set_attr "type" "fp")])
2986
2987 (define_expand "subsf3"
2988   [(set (match_operand:SF 0 "gpc_reg_operand" "")
2989         (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
2990                   (match_operand:SF 2 "gpc_reg_operand" "")))]
2991   "TARGET_HARD_FLOAT"
2992   "")
2993
2994 (define_insn ""
2995   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
2996         (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
2997                   (match_operand:SF 2 "gpc_reg_operand" "f")))]
2998   "TARGET_POWERPC && TARGET_HARD_FLOAT"
2999   "fsubs %0,%1,%2"
3000   [(set_attr "type" "fp")])
3001
3002 (define_insn ""
3003   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3004         (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
3005                   (match_operand:SF 2 "gpc_reg_operand" "f")))]
3006   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3007   "{fs|fsub} %0,%1,%2"
3008   [(set_attr "type" "fp")])
3009
3010 (define_expand "mulsf3"
3011   [(set (match_operand:SF 0 "gpc_reg_operand" "")
3012         (mult:SF (match_operand:SF 1 "gpc_reg_operand" "")
3013                  (match_operand:SF 2 "gpc_reg_operand" "")))]
3014   "TARGET_HARD_FLOAT"
3015   "")
3016
3017 (define_insn ""
3018   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3019         (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3020                  (match_operand:SF 2 "gpc_reg_operand" "f")))]
3021   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3022   "fmuls %0,%1,%2"
3023   [(set_attr "type" "fp")])
3024
3025 (define_insn ""
3026   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3027         (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3028                  (match_operand:SF 2 "gpc_reg_operand" "f")))]
3029   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3030   "{fm|fmul} %0,%1,%2"
3031   [(set_attr "type" "dmul")])
3032
3033 (define_expand "divsf3"
3034   [(set (match_operand:SF 0 "gpc_reg_operand" "")
3035         (div:SF (match_operand:SF 1 "gpc_reg_operand" "")
3036                 (match_operand:SF 2 "gpc_reg_operand" "")))]
3037   "TARGET_HARD_FLOAT"
3038   "")
3039
3040 (define_insn ""
3041   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3042         (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
3043                 (match_operand:SF 2 "gpc_reg_operand" "f")))]
3044   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3045   "fdivs %0,%1,%2"
3046   [(set_attr "type" "sdiv")])
3047
3048 (define_insn ""
3049   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3050         (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
3051                 (match_operand:SF 2 "gpc_reg_operand" "f")))]
3052   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3053   "{fd|fdiv} %0,%1,%2"
3054   [(set_attr "type" "ddiv")])
3055
3056 (define_insn ""
3057   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3058         (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3059                           (match_operand:SF 2 "gpc_reg_operand" "f"))
3060                  (match_operand:SF 3 "gpc_reg_operand" "f")))]
3061   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3062   "fmadds %0,%1,%2,%3"
3063   [(set_attr "type" "fp")])
3064
3065 (define_insn ""
3066   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3067         (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3068                           (match_operand:SF 2 "gpc_reg_operand" "f"))
3069                  (match_operand:SF 3 "gpc_reg_operand" "f")))]
3070   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3071   "{fma|fmadd} %0,%1,%2,%3"
3072   [(set_attr "type" "dmul")])
3073
3074 (define_insn ""
3075   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3076         (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3077                            (match_operand:SF 2 "gpc_reg_operand" "f"))
3078                   (match_operand:SF 3 "gpc_reg_operand" "f")))]
3079   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3080   "fmsubs %0,%1,%2,%3"
3081   [(set_attr "type" "fp")])
3082
3083 (define_insn ""
3084   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3085         (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3086                            (match_operand:SF 2 "gpc_reg_operand" "f"))
3087                   (match_operand:SF 3 "gpc_reg_operand" "f")))]
3088   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3089   "{fms|fmsub} %0,%1,%2,%3"
3090   [(set_attr "type" "dmul")])
3091
3092 (define_insn ""
3093   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3094         (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3095                                   (match_operand:SF 2 "gpc_reg_operand" "f"))
3096                          (match_operand:SF 3 "gpc_reg_operand" "f"))))]
3097   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3098   "fnmadds %0,%1,%2,%3"
3099   [(set_attr "type" "fp")])
3100
3101 (define_insn ""
3102   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3103         (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3104                                   (match_operand:SF 2 "gpc_reg_operand" "f"))
3105                          (match_operand:SF 3 "gpc_reg_operand" "f"))))]
3106   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3107   "{fnma|fnmadd} %0,%1,%2,%3"
3108   [(set_attr "type" "dmul")])
3109
3110 (define_insn ""
3111   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3112         (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3113                                    (match_operand:SF 2 "gpc_reg_operand" "f"))
3114                           (match_operand:SF 3 "gpc_reg_operand" "f"))))]
3115   "TARGET_POWERPC && TARGET_HARD_FLOAT"
3116   "fnmsubs %0,%1,%2,%3"
3117   [(set_attr "type" "fp")])
3118
3119 (define_insn ""
3120   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3121         (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
3122                                    (match_operand:SF 2 "gpc_reg_operand" "f"))
3123                           (match_operand:SF 3 "gpc_reg_operand" "f"))))]
3124   "! TARGET_POWERPC && TARGET_HARD_FLOAT"
3125   "{fnms|fnmsub} %0,%1,%2,%3"
3126   [(set_attr "type" "dmul")])
3127
3128 (define_expand "sqrtsf2"
3129   [(set (match_operand:SF 0 "gpc_reg_operand" "")
3130         (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
3131   "(TARGET_PPC_GPOPT || TARGET_POWER2) && TARGET_HARD_FLOAT"
3132   "")
3133
3134 (define_insn ""
3135   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3136         (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
3137   "TARGET_PPC_GPOPT && TARGET_HARD_FLOAT"
3138   "fsqrts %0,%1"
3139   [(set_attr "type" "ssqrt")])
3140
3141 (define_insn ""
3142   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3143         (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
3144   "TARGET_POWER2 && TARGET_HARD_FLOAT"
3145   "fsqrt %0,%1"
3146   [(set_attr "type" "dsqrt")])
3147
3148 ;; For MIN, MAX, and conditional move, we use DEFINE_EXPAND's that involve a
3149 ;; fsel instruction and some auxiliary computations.  Then we just have a
3150 ;; single DEFINE_INSN for fsel and the define_splits to make them if made by
3151 ;; combine.
3152 (define_expand "maxsf3"
3153   [(set (match_dup 3)
3154         (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
3155                   (match_operand:SF 2 "gpc_reg_operand" "")))
3156    (set (match_operand:SF 0 "gpc_reg_operand" "")
3157         (if_then_else:SF (ge (match_dup 3)
3158                              (const_int 0))
3159                          (match_dup 1)
3160                          (match_dup 2)))]
3161   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3162   "
3163 { operands[3] = gen_reg_rtx (SFmode); }")
3164
3165 (define_split
3166   [(set (match_operand:SF 0 "gpc_reg_operand" "")
3167         (smax:SF (match_operand:SF 1 "gpc_reg_operand" "")
3168                  (match_operand:SF 2 "gpc_reg_operand" "")))
3169    (clobber (match_operand:SF 3 "gpc_reg_operand" ""))]
3170   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3171   [(set (match_dup 3)
3172         (minus:SF (match_dup 1) (match_dup 2)))
3173    (set (match_dup 0)
3174         (if_then_else:SF (ge (match_dup 3)
3175                              (const_int 0))
3176                          (match_dup 1)
3177                          (match_dup 2)))]
3178   "")
3179
3180 (define_expand "minsf3"
3181   [(set (match_dup 3)
3182         (minus:SF (match_operand:SF 2 "gpc_reg_operand" "")
3183                   (match_operand:SF 1 "gpc_reg_operand" "")))
3184    (set (match_operand:SF 0 "gpc_reg_operand" "")
3185         (if_then_else:SF (ge (match_dup 3)
3186                              (const_int 0))
3187                          (match_dup 1)
3188                          (match_dup 2)))]
3189   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3190   "
3191 { operands[3] = gen_reg_rtx (SFmode); }")
3192
3193 (define_split
3194   [(set (match_operand:SF 0 "gpc_reg_operand" "")
3195         (smin:SF (match_operand:SF 1 "gpc_reg_operand" "")
3196                  (match_operand:SF 2 "gpc_reg_operand" "")))
3197    (clobber (match_operand:SF 3 "gpc_reg_operand" ""))]
3198   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3199   [(set (match_dup 3)
3200         (minus:SF (match_dup 2) (match_dup 1)))
3201    (set (match_dup 0)
3202         (if_then_else:SF (ge (match_dup 3)
3203                              (const_int 0))
3204                          (match_dup 1)
3205                          (match_dup 2)))]
3206   "")
3207
3208 (define_expand "movsfcc"
3209    [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3210          (if_then_else:SF (match_operand 1 "comparison_operator" "")
3211                           (match_operand:SF 2 "gpc_reg_operand" "f")
3212                           (match_operand:SF 3 "gpc_reg_operand" "f")))]
3213   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3214   "
3215 {
3216   rtx temp, op0, op1;
3217   enum rtx_code code = GET_CODE (operands[1]);
3218   if (! rs6000_compare_fp_p)
3219     FAIL;
3220   switch (code)
3221     {
3222     case GE: case EQ: case NE:
3223       op0 = rs6000_compare_op0;
3224       op1 = rs6000_compare_op1;
3225       break;
3226     case GT:
3227       op0 = rs6000_compare_op1;
3228       op1 = rs6000_compare_op0;
3229       temp = operands[2]; operands[2] = operands[3]; operands[3] = temp;
3230       break;
3231     case LE:
3232       op0 = rs6000_compare_op1;
3233       op1 = rs6000_compare_op0;
3234       break;
3235     case LT:
3236       op0 = rs6000_compare_op0;
3237       op1 = rs6000_compare_op1;
3238       temp = operands[2]; operands[2] = operands[3]; operands[3] = temp;
3239       break;
3240     default:
3241       FAIL;
3242     }
3243   if (GET_MODE (rs6000_compare_op0) == DFmode)
3244     {
3245       temp = gen_reg_rtx (DFmode);
3246       emit_insn (gen_subdf3 (temp, op0, op1));
3247       emit_insn (gen_fseldfsf4 (operands[0], temp, operands[2], operands[3]));
3248       if (code == EQ)
3249         {
3250           emit_insn (gen_negdf2 (temp, temp));
3251           emit_insn (gen_fseldfsf4 (operands[0], temp, operands[0], operands[3]));
3252         }
3253       if (code == NE)
3254         {
3255           emit_insn (gen_negdf2 (temp, temp));
3256           emit_insn (gen_fseldfsf4 (operands[0], temp, operands[3], operands[0]));
3257         }
3258     }
3259   else
3260     {
3261       temp = gen_reg_rtx (SFmode);
3262       emit_insn (gen_subsf3 (temp, op0, op1));
3263       emit_insn (gen_fselsfsf4 (operands[0], temp, operands[2], operands[3]));
3264       if (code == EQ)
3265         {
3266           emit_insn (gen_negsf2 (temp, temp));
3267           emit_insn (gen_fselsfsf4 (operands[0], temp, operands[0], operands[3]));
3268         }
3269       if (code == NE)
3270         {
3271           emit_insn (gen_negsf2 (temp, temp));
3272           emit_insn (gen_fselsfsf4 (operands[0], temp, operands[3], operands[0]));
3273         }
3274     }
3275   DONE;
3276 }")
3277
3278 (define_insn "fselsfsf4"
3279   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3280         (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
3281                              (const_int 0))
3282                          (match_operand:SF 2 "gpc_reg_operand" "f")
3283                          (match_operand:SF 3 "gpc_reg_operand" "f")))]
3284   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3285   "fsel %0,%1,%2,%3"
3286   [(set_attr "type" "fp")])
3287
3288 (define_insn "fseldfsf4"
3289   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
3290         (if_then_else:SF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
3291                              (const_int 0))
3292                          (match_operand:SF 2 "gpc_reg_operand" "f")
3293                          (match_operand:SF 3 "gpc_reg_operand" "f")))]
3294   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3295   "fsel %0,%1,%2,%3"
3296   [(set_attr "type" "fp")])
3297
3298 (define_insn "negdf2"
3299   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3300         (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
3301   "TARGET_HARD_FLOAT"
3302   "fneg %0,%1"
3303   [(set_attr "type" "fp")])
3304
3305 (define_insn "absdf2"
3306   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3307         (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
3308   "TARGET_HARD_FLOAT"
3309   "fabs %0,%1"
3310   [(set_attr "type" "fp")])
3311
3312 (define_insn ""
3313   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3314         (neg:DF (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f"))))]
3315   "TARGET_HARD_FLOAT"
3316   "fnabs %0,%1"
3317   [(set_attr "type" "fp")])
3318
3319 (define_insn "adddf3"
3320   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3321         (plus:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3322                  (match_operand:DF 2 "gpc_reg_operand" "f")))]
3323   "TARGET_HARD_FLOAT"
3324   "{fa|fadd} %0,%1,%2"
3325   [(set_attr "type" "fp")])
3326
3327 (define_insn "subdf3"
3328   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3329         (minus:DF (match_operand:DF 1 "gpc_reg_operand" "f")
3330                   (match_operand:DF 2 "gpc_reg_operand" "f")))]
3331   "TARGET_HARD_FLOAT"
3332   "{fs|fsub} %0,%1,%2"
3333   [(set_attr "type" "fp")])
3334
3335 (define_insn "muldf3"
3336   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3337         (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3338                  (match_operand:DF 2 "gpc_reg_operand" "f")))]
3339   "TARGET_HARD_FLOAT"
3340   "{fm|fmul} %0,%1,%2"
3341   [(set_attr "type" "dmul")])
3342
3343 (define_insn "divdf3"
3344   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3345         (div:DF (match_operand:DF 1 "gpc_reg_operand" "f")
3346                 (match_operand:DF 2 "gpc_reg_operand" "f")))]
3347   "TARGET_HARD_FLOAT"
3348   "{fd|fdiv} %0,%1,%2"
3349   [(set_attr "type" "ddiv")])
3350
3351 (define_insn ""
3352   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3353         (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3354                           (match_operand:DF 2 "gpc_reg_operand" "f"))
3355                  (match_operand:DF 3 "gpc_reg_operand" "f")))]
3356   "TARGET_HARD_FLOAT"
3357   "{fma|fmadd} %0,%1,%2,%3"
3358   [(set_attr "type" "dmul")])
3359
3360 (define_insn ""
3361   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3362         (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3363                            (match_operand:DF 2 "gpc_reg_operand" "f"))
3364                   (match_operand:DF 3 "gpc_reg_operand" "f")))]
3365   "TARGET_HARD_FLOAT"
3366   "{fms|fmsub} %0,%1,%2,%3"
3367   [(set_attr "type" "dmul")])
3368
3369 (define_insn ""
3370   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3371         (neg:DF (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3372                                   (match_operand:DF 2 "gpc_reg_operand" "f"))
3373                          (match_operand:DF 3 "gpc_reg_operand" "f"))))]
3374   "TARGET_HARD_FLOAT"
3375   "{fnma|fnmadd} %0,%1,%2,%3"
3376   [(set_attr "type" "dmul")])
3377
3378 (define_insn ""
3379   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3380         (neg:DF (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
3381                                    (match_operand:DF 2 "gpc_reg_operand" "f"))
3382                           (match_operand:DF 3 "gpc_reg_operand" "f"))))]
3383   "TARGET_HARD_FLOAT"
3384   "{fnms|fnmsub} %0,%1,%2,%3"
3385   [(set_attr "type" "dmul")])
3386
3387 (define_insn "sqrtdf2"
3388   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3389         (sqrt:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
3390   "(TARGET_PPC_GPOPT || TARGET_POWER2) && TARGET_HARD_FLOAT"
3391   "fsqrt %0,%1"
3392   [(set_attr "type" "dsqrt")])
3393
3394 ;; For MIN, MAX, and conditional move, we use DEFINE_EXPAND's that involve a
3395 ;; fsel instruction and some auxiliary computations.  Then we just have a
3396 ;; single DEFINE_INSN for fsel and the define_splits to make them if made by
3397 ;; combine.
3398
3399 (define_expand "maxdf3"
3400   [(set (match_dup 3)
3401         (minus:DF (match_operand:DF 1 "gpc_reg_operand" "")
3402                   (match_operand:DF 2 "gpc_reg_operand" "")))
3403    (set (match_operand:DF 0 "gpc_reg_operand" "")
3404         (if_then_else:DF (ge (match_dup 3)
3405                              (const_int 0))
3406                          (match_dup 1)
3407                          (match_dup 2)))]
3408   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3409   "
3410 { operands[3] = gen_reg_rtx (DFmode); }")
3411
3412 (define_split
3413   [(set (match_operand:DF 0 "gpc_reg_operand" "")
3414         (smax:DF (match_operand:DF 1 "gpc_reg_operand" "")
3415                  (match_operand:DF 2 "gpc_reg_operand" "")))
3416    (clobber (match_operand:DF 3 "gpc_reg_operand" ""))]
3417   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3418   [(set (match_dup 3)
3419         (minus:DF (match_dup 1) (match_dup 2)))
3420    (set (match_dup 0)
3421         (if_then_else:DF (ge (match_dup 3)
3422                              (const_int 0))
3423                          (match_dup 1)
3424                          (match_dup 2)))]
3425   "")
3426
3427 (define_expand "mindf3"
3428   [(set (match_dup 3)
3429         (minus:DF (match_operand:DF 2 "gpc_reg_operand" "")
3430                   (match_operand:DF 1 "gpc_reg_operand" "")))
3431    (set (match_operand:DF 0 "gpc_reg_operand" "")
3432         (if_then_else:DF (ge (match_dup 3)
3433                              (const_int 0))
3434                          (match_dup 1)
3435                          (match_dup 2)))]
3436   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3437   "
3438 { operands[3] = gen_reg_rtx (DFmode); }")
3439
3440 (define_split
3441   [(set (match_operand:DF 0 "gpc_reg_operand" "")
3442         (smin:DF (match_operand:DF 1 "gpc_reg_operand" "")
3443                  (match_operand:DF 2 "gpc_reg_operand" "")))
3444    (clobber (match_operand:DF 3 "gpc_reg_operand" ""))]
3445   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3446   [(set (match_dup 3)
3447         (minus:DF (match_dup 2) (match_dup 1)))
3448    (set (match_dup 0)
3449         (if_then_else:DF (ge (match_dup 3)
3450                              (const_int 0))
3451                          (match_dup 1)
3452                          (match_dup 2)))]
3453   "")
3454
3455 (define_expand "movdfcc"
3456    [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3457          (if_then_else:DF (match_operand 1 "comparison_operator" "")
3458                           (match_operand:DF 2 "gpc_reg_operand" "f")
3459                           (match_operand:DF 3 "gpc_reg_operand" "f")))]
3460   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3461   "
3462 {
3463   rtx temp, op0, op1;
3464   enum rtx_code code = GET_CODE (operands[1]);
3465   if (! rs6000_compare_fp_p)
3466     FAIL;
3467   switch (code)
3468     {
3469     case GE: case EQ: case NE:
3470       op0 = rs6000_compare_op0;
3471       op1 = rs6000_compare_op1;
3472       break;
3473     case GT:
3474       op0 = rs6000_compare_op1;
3475       op1 = rs6000_compare_op0;
3476       temp = operands[2]; operands[2] = operands[3]; operands[3] = temp;
3477       break;
3478     case LE:
3479       op0 = rs6000_compare_op1;
3480       op1 = rs6000_compare_op0;
3481       break;
3482     case LT:
3483       op0 = rs6000_compare_op0;
3484       op1 = rs6000_compare_op1;
3485       temp = operands[2]; operands[2] = operands[3]; operands[3] = temp;
3486       break;
3487     default:
3488       FAIL;
3489     }
3490   if (GET_MODE (rs6000_compare_op0) == DFmode)
3491     {
3492       temp = gen_reg_rtx (DFmode);
3493       emit_insn (gen_subdf3 (temp, op0, op1));
3494       emit_insn (gen_fseldfdf4 (operands[0], temp, operands[2], operands[3]));
3495       if (code == EQ)
3496         {
3497           emit_insn (gen_negdf2 (temp, temp));
3498           emit_insn (gen_fseldfdf4 (operands[0], temp, operands[0], operands[3]));
3499         }
3500       if (code == NE)
3501         {
3502           emit_insn (gen_negdf2 (temp, temp));
3503           emit_insn (gen_fseldfdf4 (operands[0], temp, operands[3], operands[0]));
3504         }
3505     }
3506   else
3507     {
3508       temp = gen_reg_rtx (SFmode);
3509       emit_insn (gen_subsf3 (temp, op0, op1));
3510       emit_insn (gen_fselsfdf4 (operands[0], temp, operands[2], operands[3]));
3511       if (code == EQ)
3512         {
3513           emit_insn (gen_negsf2 (temp, temp));
3514           emit_insn (gen_fselsfdf4 (operands[0], temp, operands[0], operands[3]));
3515         }
3516       if (code == NE)
3517         {
3518           emit_insn (gen_negsf2 (temp, temp));
3519           emit_insn (gen_fselsfdf4 (operands[0], temp, operands[3], operands[0]));
3520         }
3521     }
3522   DONE;
3523 }")
3524
3525 (define_insn "fseldfdf4"
3526   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3527         (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
3528                              (const_int 0))
3529                          (match_operand:DF 2 "gpc_reg_operand" "f")
3530                          (match_operand:DF 3 "gpc_reg_operand" "f")))]
3531   "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT"
3532   "fsel %0,%1,%2,%3"
3533   [(set_attr "type" "fp")])
3534
3535 (define_insn "fselsfdf4"
3536   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3537         (if_then_else:DF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
3538                              (const_int 0))
3539                          (match_operand:DF 2 "gpc_reg_operand" "f")
3540                          (match_operand:DF 3 "gpc_reg_operand" "f")))]
3541   "TARGET_PPC_GFXOPT"
3542   "fsel %0,%1,%2,%3"
3543   [(set_attr "type" "fp")])
3544 \f
3545 ;; Conversions to and from floating-point.
3546
3547 (define_expand "floatsidf2"
3548   [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
3549                    (float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
3550               (use (match_dup 2))
3551               (use (match_dup 3))
3552               (clobber (match_dup 4))
3553               (clobber (match_dup 5))
3554               (clobber (reg:DF 76))])]
3555   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3556   "
3557 {
3558   operands[2] = force_reg (SImode, GEN_INT (0x43300000));
3559   operands[3] = force_reg (DFmode, rs6000_float_const (\"4503601774854144\", DFmode));
3560   operands[4] = gen_reg_rtx (SImode);
3561   operands[5] = gen_reg_rtx (Pmode);
3562 }")
3563
3564 (define_insn "*floatsidf2_internal"
3565   [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
3566         (float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
3567    (use (match_operand:SI 2 "gpc_reg_operand" "r"))
3568    (use (match_operand:DF 3 "gpc_reg_operand" "f"))
3569    (clobber (match_operand:SI 4 "gpc_reg_operand" "=r"))
3570    (clobber (match_operand:SI 5 "gpc_reg_operand" "=b"))
3571    (clobber (reg:DF 76))]
3572   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3573   "#"
3574   [(set_attr "length" "24")])
3575
3576 (define_split
3577   [(set (match_operand:DF 0 "gpc_reg_operand" "")
3578         (float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
3579    (use (match_operand:SI 2 "gpc_reg_operand" ""))
3580    (use (match_operand:DF 3 "gpc_reg_operand" ""))
3581    (clobber (match_operand:SI 4 "gpc_reg_operand" ""))
3582    (clobber (match_operand:SI 5 "gpc_reg_operand" ""))
3583    (clobber (reg:DF 76))]
3584   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3585   [(set (match_dup 4)
3586         (xor:SI (match_dup 1)
3587                 (match_dup 6)))
3588    (set (match_dup 5)
3589         (unspec [(const_int 0)] 11))
3590    (set (match_dup 7)
3591         (unspec [(match_dup 4)
3592                  (match_dup 5)] 12))    ;; low word
3593    (set (match_dup 7)
3594         (unspec [(match_dup 2)
3595                  (match_dup 5)
3596                  (match_dup 7)] 13))    ;; high word
3597    (set (match_dup 0)
3598         (unspec [(match_dup 7)
3599                  (match_dup 5)] 14))
3600    (set (match_dup 0)
3601         (minus:DF (match_dup 0)
3602                   (match_dup 3)))]
3603   "
3604 {
3605   operands[6] = GEN_INT (0x80000000);
3606   operands[7] = gen_rtx (REG, DFmode, FPMEM_REGNUM);
3607 }")
3608
3609 (define_expand "floatunssidf2"
3610   [(parallel [(set (match_operand:DF 0 "gpc_reg_operand" "")
3611                    (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
3612               (use (match_dup 2))
3613               (use (match_dup 3))
3614               (clobber (match_dup 4))
3615               (clobber (reg:DF 76))])]
3616   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3617   "
3618 {
3619   operands[2] = force_reg (SImode, GEN_INT (0x43300000));
3620   operands[3] = force_reg (DFmode, rs6000_float_const (\"4503599627370496\", DFmode));
3621   operands[4] = gen_reg_rtx (Pmode);
3622 }")
3623
3624 (define_insn "*floatunssidf2_internal"
3625   [(set (match_operand:DF 0 "gpc_reg_operand" "=&f")
3626         (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "r")))
3627    (use (match_operand:SI 2 "gpc_reg_operand" "r"))
3628    (use (match_operand:DF 3 "gpc_reg_operand" "f"))
3629    (clobber (match_operand:SI 4 "gpc_reg_operand" "=b"))
3630    (clobber (reg:DF 76))]
3631   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3632   "#"
3633   [(set_attr "length" "20")])
3634
3635 (define_split
3636   [(set (match_operand:DF 0 "gpc_reg_operand" "")
3637         (unsigned_float:DF (match_operand:SI 1 "gpc_reg_operand" "")))
3638    (use (match_operand:SI 2 "gpc_reg_operand" ""))
3639    (use (match_operand:DF 3 "gpc_reg_operand" ""))
3640    (clobber (match_operand:SI 4 "gpc_reg_operand" "=b"))
3641    (clobber (reg:DF 76))]
3642   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3643   [(set (match_dup 4)
3644         (unspec [(const_int 0)] 11))
3645    (set (match_dup 5)
3646         (unspec [(match_dup 1)
3647                  (match_dup 4)] 12))    ;; low word
3648    (set (match_dup 5)
3649         (unspec [(match_dup 2)
3650                  (match_dup 4)
3651                  (match_dup 5)] 13))    ;; high word
3652    (set (match_dup 0)
3653         (unspec [(match_dup 5)
3654                  (reg:SI 1)] 14))
3655    (set (match_dup 0)
3656         (minus:DF (match_dup 0)
3657                   (match_dup 3)))]
3658   "operands[5] = gen_rtx (REG, DFmode, FPMEM_REGNUM);")
3659
3660 ;; Load up scratch register with base address + offset if needed
3661 (define_insn "*floatsidf2_loadaddr"
3662   [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
3663         (unspec [(const_int 0)] 11))]
3664   "TARGET_HARD_FLOAT"
3665   "*
3666 {
3667   if (rs6000_fpmem_offset > 32760)
3668     {
3669       rtx xop[3];
3670
3671       xop[0] = operands[0];
3672       xop[1] = (frame_pointer_needed) ? frame_pointer_rtx : stack_pointer_rtx;
3673       xop[2] = GEN_INT ((rs6000_fpmem_offset >> 16) + ((rs6000_fpmem_offset & 0x8000) >> 15));
3674       output_asm_insn (\"{cau|addis} %0,%1,%2\", xop);
3675     }
3676   else if (rs6000_fpmem_offset < 0)
3677     abort ();
3678
3679   return \"\";
3680 }"
3681   [(set_attr "length" "4")])
3682
3683 (define_insn "*floatsidf2_store1"
3684   [(set (reg:DF 76)
3685         (unspec [(match_operand:SI 0 "gpc_reg_operand" "r")
3686                  (match_operand:SI 1 "gpc_reg_operand" "r")] 12))]
3687   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3688   "*
3689 {
3690   rtx indx;
3691
3692   if (rs6000_fpmem_offset > 32760)
3693     indx = operands[1];
3694   else if (frame_pointer_needed)
3695     indx = frame_pointer_rtx;
3696   else
3697     indx = stack_pointer_rtx;
3698
3699   operands[2] = gen_rtx (MEM, SImode,
3700                          gen_rtx (PLUS, Pmode,
3701                                   indx,
3702                                   GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
3703                                            + ((WORDS_BIG_ENDIAN != 0) * 4))));
3704
3705   return \"{st|stw} %0,%2\";
3706 }"
3707   [(set_attr "type" "store")])
3708
3709 (define_insn "*floatsidf2_store2"
3710   [(set (reg:DF 76)
3711         (unspec [(match_operand:SI 0 "gpc_reg_operand" "r")
3712                  (match_operand:SI 1 "gpc_reg_operand" "r")
3713                  (reg:DF 76)] 13))]
3714   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3715   "*
3716 {
3717   rtx indx;
3718
3719   if (rs6000_fpmem_offset > 32760)
3720     indx = operands[1];
3721   else if (frame_pointer_needed)
3722     indx = frame_pointer_rtx;
3723   else
3724     indx = stack_pointer_rtx;
3725
3726   operands[2] = gen_rtx (MEM, SImode,
3727                          gen_rtx (PLUS, Pmode,
3728                                   indx,
3729                                   GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
3730                                            + ((WORDS_BIG_ENDIAN == 0) * 4))));
3731
3732   return \"{st|stw} %0,%2\";
3733 }"
3734   [(set_attr "type" "store")])
3735
3736 (define_insn "*floatsidf2_load"
3737   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3738         (unspec [(reg:DF 76)
3739                  (match_operand:SI 1 "gpc_reg_operand" "b")] 14))]
3740   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3741   "*
3742 {
3743   rtx indx;
3744   HOST_WIDE_INT offset = rs6000_fpmem_offset;
3745
3746   if (rs6000_fpmem_offset > 32760)
3747     {
3748       indx = operands[1];
3749       offset = (((offset & 0xffff) ^ 0x8000) - 0x8000);
3750     }
3751   else if (frame_pointer_needed)
3752     indx = frame_pointer_rtx;
3753   else
3754     indx = stack_pointer_rtx;
3755
3756   operands[2] = gen_rtx (MEM, SImode,
3757                          gen_rtx (PLUS, Pmode, indx, GEN_INT (offset)));
3758
3759   return \"lfd %0,%2\";
3760 }"
3761   [(set_attr "type" "fpload")])
3762
3763 (define_expand "fix_truncdfsi2"
3764   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
3765                    (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))
3766               (clobber (match_dup 2))
3767               (clobber (match_dup 3))
3768               (clobber (match_dup 4))])]
3769   "TARGET_HARD_FLOAT"
3770   "
3771 {
3772   if (!TARGET_POWER2 && !TARGET_POWERPC)
3773     {
3774       emit_insn (gen_trunc_call (operands[0], operands[1],
3775                                  gen_rtx (SYMBOL_REF, Pmode, RS6000_ITRUNC)));
3776       DONE;
3777     }
3778
3779   operands[2] = gen_reg_rtx (DImode);
3780   operands[3] = gen_reg_rtx (Pmode);
3781   operands[4] = gen_rtx (REG, DImode, FPMEM_REGNUM);
3782 }")
3783
3784 (define_insn "*fix_truncdfsi2_internal"
3785   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3786         (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
3787    (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))
3788    (clobber (match_operand:SI 3 "gpc_reg_operand" "=b"))
3789    (clobber (reg:DI 76))]
3790   "TARGET_HARD_FLOAT"
3791   "#"
3792   [(set_attr "length" "12")])
3793
3794 (define_split
3795   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3796         (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
3797    (clobber (match_operand:DI 2 "gpc_reg_operand" ""))
3798    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))
3799    (clobber (reg:DI 76))]
3800   "TARGET_HARD_FLOAT"
3801   [(set (match_dup 2)
3802         (sign_extend:DI (fix:SI (match_operand:DF 1 "gpc_reg_operand" ""))))
3803    (set (match_dup 3)
3804         (unspec [(const_int 0)] 11))
3805    (set (match_dup 4)
3806         (unspec [(match_dup 2)
3807                  (match_dup 3)] 15))
3808    (set (match_operand:SI 0 "gpc_reg_operand" "")
3809         (unspec [(match_dup 4)
3810                  (match_dup 3)] 16))]
3811   "operands[4] = gen_rtx (REG, DImode, FPMEM_REGNUM);")
3812
3813 (define_insn "*fctiwz"
3814   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
3815         (sign_extend:DI (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f"))))]
3816   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3817   "{fcirz|fctiwz} %0,%1"
3818   [(set_attr "type" "fp")])
3819
3820 (define_insn "*fix_truncdfsi2_store"
3821   [(set (reg:DI 76)
3822         (unspec [(match_operand:DI 0 "gpc_reg_operand" "f")
3823                  (match_operand:SI 1 "gpc_reg_operand" "b")] 15))]
3824   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3825   "*
3826 {
3827   rtx indx;
3828
3829   if (rs6000_fpmem_offset > 32760)
3830     indx = operands[1];
3831   else if (frame_pointer_needed)
3832     indx = frame_pointer_rtx;
3833   else
3834     indx = stack_pointer_rtx;
3835
3836   operands[2] = gen_rtx (MEM, DFmode,
3837                          gen_rtx (PLUS, Pmode,
3838                                   indx,
3839                                   GEN_INT ((((rs6000_fpmem_offset & 0xffff)
3840                                              ^ 0x8000) - 0x8000))));
3841
3842   return \"stfd %0,%w2\";
3843 }"
3844   [(set_attr "type" "fpstore")])
3845
3846 (define_insn "*fix_truncdfsi2_load"
3847   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3848         (unspec [(reg:DI 76)
3849                  (match_operand:SI 1 "gpc_reg_operand" "b")] 16))]
3850   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3851   "*
3852 {
3853   rtx indx;
3854
3855   if (rs6000_fpmem_offset > 32760)
3856     indx = operands[1];
3857   else if (frame_pointer_needed)
3858     indx = frame_pointer_rtx;
3859   else
3860     indx = stack_pointer_rtx;
3861
3862   operands[2] = gen_rtx (MEM, DFmode,
3863                          gen_rtx (PLUS, Pmode,
3864                                   indx,
3865                                   GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
3866                                            + ((WORDS_BIG_ENDIAN) ? 4 : 0))));
3867
3868   return \"{l|lwz} %0,%2\";
3869 }"
3870   [(set_attr "type" "load")])
3871
3872 (define_expand "fixuns_truncdfsi2"
3873   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3874         (unsigned_fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
3875   "! TARGET_POWER2 && ! TARGET_POWERPC && TARGET_HARD_FLOAT"
3876   "
3877 {
3878   emit_insn (gen_trunc_call (operands[0], operands[1],
3879                              gen_rtx (SYMBOL_REF, Pmode, RS6000_UITRUNC)));
3880   DONE;
3881 }")
3882
3883 (define_expand "trunc_call"
3884   [(parallel [(set (match_operand:SI 0 "" "")
3885                    (fix:SI (match_operand:DF 1 "" "")))
3886               (use (match_operand:SI 2 "" ""))])]
3887   "TARGET_HARD_FLOAT"
3888   "
3889 {
3890   rtx insns = gen_trunc_call_rtl (operands[0], operands[1], operands[2]);
3891   rtx first = XVECEXP (insns, 0, 0);
3892   rtx last = XVECEXP (insns, 0, XVECLEN (insns, 0) - 1);
3893
3894   REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
3895                                REG_NOTES (first));
3896   REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
3897
3898   emit_insn (insns);
3899   DONE;
3900 }")
3901
3902 (define_expand "trunc_call_rtl"
3903   [(set (reg:DF 33) (match_operand:DF 1 "gpc_reg_operand" ""))
3904    (use (reg:DF 33))
3905    (parallel [(set (reg:SI 3)
3906                    (call (mem:SI (match_operand 2 "" "")) (const_int 0)))
3907               (use (const_int 0))
3908               (clobber (scratch:SI))])
3909    (set (match_operand:SI 0 "gpc_reg_operand" "")
3910         (reg:SI 3))]
3911   "TARGET_HARD_FLOAT"
3912   "
3913 {
3914   rs6000_trunc_used = 1;
3915 }")
3916
3917 (define_insn "floatdidf2"
3918   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3919         (float:DF (match_operand:DI 1 "gpc_reg_operand" "f")))]
3920   "TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3921   "fcfid %0,%1"
3922   [(set_attr "type" "fp")])
3923
3924 (define_insn "fix_truncdfdi2"
3925   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
3926         (fix:DI (match_operand:DF 1 "gpc_reg_operand" "f")))]
3927   "TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3928   "fctidz %0,%1"
3929   [(set_attr "type" "fp")])
3930 \f
3931 ;; Define the DImode operations that can be done in a small number
3932 ;; of instructions.  The & constraints are to prevent the register
3933 ;; allocator from allocating registers that overlap with the inputs
3934 ;; (for example, having an input in 7,8 and an output in 6,7).  We
3935 ;; also allow for the the output being the same as one of the inputs.
3936
3937 (define_insn "*adddi3_noppc64"
3938   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r")
3939         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,0,0")
3940                  (match_operand:DI 2 "reg_or_short_operand" "r,I,r,I")))]
3941   "! TARGET_POWERPC64"
3942   "*
3943 {
3944   if (WORDS_BIG_ENDIAN)
3945     return (GET_CODE (operands[2])) != CONST_INT
3946             ? \"{a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2\"
3947             : \"{ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1\";
3948   else
3949     return (GET_CODE (operands[2])) != CONST_INT
3950             ? \"{a|addc} %0,%1,%2\;{ae|adde} %L0,%L1,%L2\"
3951             : \"{ai|addic} %0,%1,%2\;{a%G2e|add%G2e} %L0,%L1\";
3952 }"
3953   [(set_attr "length" "8")])
3954
3955 (define_insn "*subdi3_noppc64"
3956   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r,r")
3957         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I,0,r,I")
3958                   (match_operand:DI 2 "gpc_reg_operand" "r,r,r,0,0")))]
3959   "! TARGET_POWERPC64"
3960   "*
3961 {
3962   if (WORDS_BIG_ENDIAN)
3963     return (GET_CODE (operands[1]) != CONST_INT)
3964             ? \"{sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1\"
3965             : \"{sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2\";
3966   else
3967     return (GET_CODE (operands[1]) != CONST_INT)
3968             ? \"{sf|subfc} %0,%2,%1\;{sfe|subfe} %L0,%L2,%L1\"
3969             : \"{sfi|subfic} %0,%2,%1\;{sf%G1e|subf%G1e} %L0,%L2\";
3970 }"
3971   [(set_attr "length" "8")])
3972
3973 (define_insn "*negdi2_noppc64"
3974   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
3975         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))]
3976   "! TARGET_POWERPC64"
3977   "*
3978 {
3979   return (WORDS_BIG_ENDIAN)
3980     ? \"{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1\"
3981     : \"{sfi|subfic} %0,%1,0\;{sfze|subfze} %L0,%L1\";
3982 }"
3983   [(set_attr "length" "8")])
3984
3985 (define_expand "mulsidi3"
3986   [(set (match_operand:DI 0 "gpc_reg_operand" "")
3987         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
3988                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
3989   ""
3990   "
3991 {
3992   if (! TARGET_POWER && ! TARGET_POWERPC)
3993     {
3994       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
3995       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
3996       emit_insn (gen_mull_call ());
3997       if (WORDS_BIG_ENDIAN)
3998         emit_move_insn (operands[0], gen_rtx (REG, DImode, 3));
3999       else
4000         {
4001           emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
4002                           gen_rtx (REG, SImode, 3));
4003           emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
4004                           gen_rtx (REG, SImode, 4));
4005         }
4006       DONE;
4007     }
4008   else if (TARGET_POWER)
4009     {
4010       emit_insn (gen_mulsidi3_mq (operands[0], operands[1], operands[2]));
4011       DONE;
4012     }
4013 }")
4014
4015 (define_insn "mulsidi3_mq"
4016   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4017         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4018                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
4019    (clobber (match_scratch:SI 3 "=q"))]
4020   "TARGET_POWER"
4021   "mul %0,%1,%2\;mfmq %L0"
4022   [(set_attr "type" "imul")
4023    (set_attr "length" "8")])
4024
4025 (define_insn "*mulsidi3_powerpc"
4026   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4027         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4028                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
4029   "TARGET_POWERPC && ! TARGET_POWERPC64"
4030   "*
4031 {
4032   return (WORDS_BIG_ENDIAN)
4033     ? \"mulhw %0,%1,%2\;mullw %L0,%1,%2\"
4034     : \"mulhw %L0,%1,%2\;mullw %0,%1,%2\";
4035 }"
4036   [(set_attr "type" "imul")
4037    (set_attr "length" "8")])
4038
4039 (define_split
4040   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4041         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
4042                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
4043   "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
4044   [(set (match_dup 3)
4045         (truncate:SI
4046          (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
4047                                (sign_extend:DI (match_dup 2)))
4048                       (const_int 32))))
4049    (set (match_dup 4)
4050         (mult:SI (match_dup 1)
4051                  (match_dup 2)))]
4052   "
4053 {
4054   int endian = (WORDS_BIG_ENDIAN == 0);
4055   operands[3] = operand_subword (operands[0], endian, 0, DImode);
4056   operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
4057 }")
4058
4059 (define_insn "umulsidi3"
4060   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4061         (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4062                  (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
4063   "TARGET_POWERPC && ! TARGET_POWERPC64"
4064   "*
4065 {
4066   return (WORDS_BIG_ENDIAN)
4067     ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
4068     : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
4069 }"
4070   [(set_attr "type" "imul")
4071    (set_attr "length" "8")])
4072
4073 (define_split
4074   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4075         (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
4076                  (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
4077   "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
4078   [(set (match_dup 3)
4079         (truncate:SI
4080          (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
4081                                (zero_extend:DI (match_dup 2)))
4082                       (const_int 32))))
4083    (set (match_dup 4)
4084         (mult:SI (match_dup 1)
4085                  (match_dup 2)))]
4086   "
4087 {
4088   int endian = (WORDS_BIG_ENDIAN == 0);
4089   operands[3] = operand_subword (operands[0], endian, 0, DImode);
4090   operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
4091 }")
4092
4093 (define_expand "smulsi3_highpart"
4094   [(set (match_operand:SI 0 "gpc_reg_operand" "")
4095         (truncate:SI
4096          (lshiftrt:DI (mult:DI (sign_extend:DI
4097                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4098                                (sign_extend:DI
4099                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4100                       (const_int 32))))]
4101   ""
4102   "
4103 {
4104   if (! TARGET_POWER && ! TARGET_POWERPC)
4105     {
4106       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
4107       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
4108       emit_insn (gen_mulh_call ());
4109       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
4110       DONE;
4111     }
4112   else if (TARGET_POWER)
4113     {
4114       emit_insn (gen_smulsi3_highpart_mq (operands[0], operands[1], operands[2]));
4115       DONE;
4116     }
4117 }")
4118
4119 (define_insn "smulsi3_highpart_mq"
4120   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4121         (truncate:SI
4122          (lshiftrt:DI (mult:DI (sign_extend:DI
4123                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4124                                (sign_extend:DI
4125                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4126                       (const_int 32))))
4127    (clobber (match_scratch:SI 3 "=q"))]
4128   "TARGET_POWER"
4129   "mul %0,%1,%2"
4130   [(set_attr "type" "imul")])
4131
4132 (define_insn ""
4133   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4134         (truncate:SI
4135          (lshiftrt:DI (mult:DI (sign_extend:DI
4136                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4137                                (sign_extend:DI
4138                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4139                       (const_int 32))))]
4140   "TARGET_POWERPC"
4141   "mulhw %0,%1,%2"
4142   [(set_attr "type" "imul")])
4143
4144 (define_insn "umulsi3_highpart"
4145   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4146         (truncate:SI
4147          (lshiftrt:DI (mult:DI (zero_extend:DI
4148                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4149                                (zero_extend:DI
4150                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4151                       (const_int 32))))]
4152   "TARGET_POWERPC"
4153   "mulhwu %0,%1,%2"
4154   [(set_attr "type" "imul")])
4155
4156 ;; If operands 0 and 2 are in the same register, we have a problem.  But
4157 ;; operands 0 and 1 (the usual case) can be in the same register.  That's
4158 ;; why we have the strange constraints below.
4159 (define_insn "ashldi3_power"
4160   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
4161         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
4162                    (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
4163    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
4164   "TARGET_POWER"
4165   "@
4166    {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
4167    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
4168    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
4169    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
4170   [(set_attr "length" "8")])
4171
4172 (define_insn "lshrdi3_power"
4173   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r,r,&r")
4174         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
4175                      (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
4176    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
4177   "TARGET_POWER"
4178   "@
4179    {cal %0,0(0)|li %0,0}\;{s%A2i|s%A2wi} %L0,%1,%h2
4180    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
4181    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
4182    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
4183   [(set_attr "length" "8")])
4184
4185 ;; Shift by a variable amount is too complex to be worth open-coding.  We
4186 ;; just handle shifts by constants.
4187 (define_insn "ashrdi3_power"
4188   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4189         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
4190                      (match_operand:SI 2 "const_int_operand" "M,i")))
4191    (clobber (match_scratch:SI 3 "=X,q"))]
4192   "TARGET_POWER"
4193   "@
4194    {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
4195    sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
4196   [(set_attr "length" "8")])
4197 \f
4198 ;; PowerPC64 DImode operations.
4199
4200 (define_expand "adddi3"
4201   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4202         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
4203                  (match_operand:DI 2 "add_operand" "")))]
4204   ""
4205   "
4206 {
4207   if (! TARGET_POWERPC64 && non_short_cint_operand (operands[2], DImode))
4208     FAIL;
4209 }")
4210
4211 ;; Discourage ai/addic because of carry but provide it in an alternative
4212 ;; allowing register zero as source.
4213
4214 (define_insn ""
4215   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,?r,r")
4216         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,b,r,b")
4217                  (match_operand:DI 2 "add_operand" "r,I,I,J")))]
4218   "TARGET_POWERPC64"
4219   "@
4220    add %0,%1,%2
4221    addi %0,%1,%2
4222    addic %0,%1,%2
4223    addis %0,%1,%v2")
4224
4225 (define_insn ""
4226   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
4227         (compare:CC (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
4228                              (match_operand:DI 2 "reg_or_short_operand" "r,I"))
4229                     (const_int 0)))
4230    (clobber (match_scratch:DI 3 "=r,r"))]
4231   "TARGET_POWERPC64"
4232   "@
4233    add. %3,%1,%2
4234    addic. %3,%1,%2"
4235   [(set_attr "type" "compare")])
4236
4237 (define_insn ""
4238   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
4239         (compare:CC (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
4240                              (match_operand:DI 2 "reg_or_short_operand" "r,I"))
4241                     (const_int 0)))
4242    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
4243         (plus:DI (match_dup 1) (match_dup 2)))]
4244   "TARGET_POWERPC64"
4245   "@
4246    add. %0,%1,%2
4247    addic. %0,%1,%2"
4248   [(set_attr "type" "compare")])
4249
4250 ;; Split an add that we can't do in one insn into two insns, each of which
4251 ;; does one 16-bit part.  This is used by combine.  Note that the low-order
4252 ;; add should be last in case the result gets used in an address.
4253
4254 (define_split
4255   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4256         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
4257                  (match_operand:DI 2 "non_add_cint_operand" "")))]
4258   "TARGET_POWERPC64"
4259   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 3)))
4260    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
4261 "
4262 {
4263   HOST_WIDE_INT low = INTVAL (operands[2]) & 0xffff;
4264   HOST_WIDE_INT high = INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff);
4265
4266   if (low & 0x8000)
4267     high+=0x10000, low |= ((HOST_WIDE_INT) -1) << 16;
4268
4269   operands[3] = GEN_INT (high);
4270   operands[4] = GEN_INT (low);
4271 }")
4272
4273 (define_insn "one_cmpldi2"
4274   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4275         (not:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4276   "TARGET_POWERPC64"
4277   "nor %0,%1,%1")
4278
4279 (define_insn ""
4280   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4281         (compare:CC (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4282                     (const_int 0)))
4283    (clobber (match_scratch:DI 2 "=r"))]
4284   "TARGET_POWERPC64"
4285   "nor. %2,%1,%1"
4286   [(set_attr "type" "compare")])
4287
4288 (define_insn ""
4289   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
4290         (compare:CC (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4291                     (const_int 0)))
4292    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4293         (not:DI (match_dup 1)))]
4294   "TARGET_POWERPC64"
4295   "nor. %0,%1,%1"
4296   [(set_attr "type" "compare")])
4297
4298 (define_insn ""
4299   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
4300         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
4301                   (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
4302   "TARGET_POWERPC64"
4303   "@
4304    subf %0,%2,%1
4305    subfic %0,%2,%1")
4306
4307 (define_insn ""
4308   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4309         (compare:CC (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4310                               (match_operand:DI 2 "gpc_reg_operand" "r"))
4311                     (const_int 0)))
4312    (clobber (match_scratch:DI 3 "=r"))]
4313   "TARGET_POWERPC64"
4314   "subf. %3,%2,%1"
4315   [(set_attr "type" "compare")])
4316
4317 (define_insn ""
4318   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4319         (compare:CC (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4320                               (match_operand:DI 2 "gpc_reg_operand" "r"))
4321                     (const_int 0)))
4322    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4323         (minus:DI (match_dup 1) (match_dup 2)))]
4324   "TARGET_POWERPC64"
4325   "subf. %0,%2,%1"
4326   [(set_attr "type" "compare")])
4327
4328 (define_expand "subdi3"
4329   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4330         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "")
4331                   (match_operand:DI 2 "reg_or_cint_operand" "")))]
4332   ""
4333   "
4334 {
4335   if (GET_CODE (operands[2]) == CONST_INT)
4336     {
4337       emit_insn (gen_adddi3 (operands[0], operands[1],
4338                              negate_rtx (DImode, operands[2])));
4339       DONE;
4340     }
4341 }")
4342
4343 (define_insn "absdi2"
4344   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4345         (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
4346    (clobber (match_scratch:DI 2 "=&r,&r"))]
4347   "TARGET_POWERPC64"
4348   "sradi %2,%1,31\;xor %0,%2,%1\;subf %0,%2,%0"
4349   [(set_attr "length" "12")])
4350
4351 (define_split
4352   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4353         (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
4354    (clobber (match_scratch:DI 2 "=&r,&r"))]
4355   "TARGET_POWERPC64 && reload_completed"
4356   [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 31)))
4357    (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
4358    (set (match_dup 0) (minus:DI (match_dup 2) (match_dup 0)))]
4359   "")
4360
4361 (define_insn ""
4362   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4363         (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
4364    (clobber (match_scratch:DI 2 "=&r,&r"))]
4365   "TARGET_POWERPC64"
4366   "sradi %2,%1,31\;xor %0,%2,%1\;subf %0,%0,%2"
4367   [(set_attr "length" "12")])
4368
4369 (define_split
4370   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4371         (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
4372    (clobber (match_scratch:DI 2 "=&r,&r"))]
4373   "TARGET_POWERPC64 && reload_completed"
4374   [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 31)))
4375    (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
4376    (set (match_dup 0) (minus:DI (match_dup 0) (match_dup 2)))]
4377   "")
4378
4379 (define_expand "negdi2"
4380   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4381         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "")))]
4382   ""
4383   "")
4384
4385 (define_insn ""
4386   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4387         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4388   "TARGET_POWERPC64"
4389   "neg %0,%1")
4390
4391 (define_insn ""
4392   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4393         (compare:CC (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4394                     (const_int 0)))
4395    (clobber (match_scratch:DI 2 "=r"))]
4396   "TARGET_POWERPC64"
4397   "neg. %2,%1"
4398   [(set_attr "type" "compare")])
4399
4400 (define_insn ""
4401   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
4402         (compare:CC (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4403                     (const_int 0)))
4404    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4405         (neg:DI (match_dup 1)))]
4406   "TARGET_POWERPC64"
4407   "neg. %0,%1"
4408   [(set_attr "type" "compare")])
4409
4410 (define_insn "ffsdi2"
4411   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4412         (ffs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4413   "TARGET_POWERPC64"
4414   "neg %0,%1\;and %0,%0,%1\;cntlzd %0,%0\;subfic %0,%0,64"
4415   [(set_attr "length" "16")])
4416
4417 (define_insn "muldi3"
4418   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4419         (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4420                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4421   "TARGET_POWERPC64"
4422   "mulld %0,%1,%2"
4423    [(set_attr "type" "imul")])
4424
4425 (define_insn "smuldi3_highpart"
4426   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4427         (truncate:DI
4428          (lshiftrt:TI (mult:TI (sign_extend:TI
4429                                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
4430                                (sign_extend:TI
4431                                 (match_operand:DI 2 "gpc_reg_operand" "r")))
4432                       (const_int 64))))]
4433   "TARGET_POWERPC64"
4434   "mulhd %0,%1,%2"
4435   [(set_attr "type" "imul")])
4436
4437 (define_insn "umuldi3_highpart"
4438   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4439         (truncate:DI
4440          (lshiftrt:TI (mult:TI (zero_extend:TI
4441                                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
4442                                (zero_extend:TI
4443                                 (match_operand:DI 2 "gpc_reg_operand" "r")))
4444                       (const_int 64))))]
4445   "TARGET_POWERPC64"
4446   "mulhdu %0,%1,%2"
4447   [(set_attr "type" "imul")])
4448
4449 (define_expand "divdi3"
4450   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4451         (div:DI (match_operand:DI 1 "gpc_reg_operand" "")
4452                 (match_operand:DI 2 "reg_or_cint_operand" "")))]
4453   "TARGET_POWERPC64"
4454   "
4455 {
4456   if (GET_CODE (operands[2]) == CONST_INT
4457       && exact_log2 (INTVAL (operands[2])) >= 0)
4458     ;
4459   else
4460     operands[2] = force_reg (DImode, operands[2]);
4461 }")
4462
4463 (define_expand "moddi3"
4464   [(use (match_operand:DI 0 "gpc_reg_operand" ""))
4465    (use (match_operand:DI 1 "gpc_reg_operand" ""))
4466    (use (match_operand:DI 2 "reg_or_cint_operand" ""))]
4467   "TARGET_POWERPC64"
4468   "
4469 {
4470   int i = exact_log2 (INTVAL (operands[2]));
4471   rtx temp1;
4472   rtx temp2;
4473
4474   if (GET_CODE (operands[2]) != CONST_INT || i < 0)
4475     FAIL;
4476
4477   temp1 = gen_reg_rtx (DImode);
4478   temp2 = gen_reg_rtx (DImode);
4479
4480   emit_insn (gen_divdi3 (temp1, operands[1], operands[2]));
4481   emit_insn (gen_ashldi3 (temp2, temp1, GEN_INT (i)));
4482   emit_insn (gen_subdi3 (operands[0], operands[1], temp2));
4483   DONE;
4484 }")
4485
4486 (define_insn ""
4487   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4488         (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4489                 (match_operand:DI 2 "const_int_operand" "N")))]
4490   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4491   "sradi %0,%1,%p2\;addze %0,%0"
4492   [(set_attr "length" "8")])
4493
4494 (define_insn ""
4495   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4496         (compare:CC (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4497                             (match_operand:DI 2 "const_int_operand" "N"))
4498                     (const_int 0)))
4499    (clobber (match_scratch:DI 3 "=r"))]
4500   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4501   "sradi %3,%1,%p2\;addze. %3,%3"
4502   [(set_attr "type" "compare")
4503    (set_attr "length" "8")])
4504
4505 (define_insn ""
4506   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4507         (compare:CC (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4508                             (match_operand:DI 2 "const_int_operand" "N"))
4509                     (const_int 0)))
4510    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4511         (div:DI (match_dup 1) (match_dup 2)))]
4512   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4513   "sradi %0,%1,%p2\;addze. %0,%0"
4514   [(set_attr "type" "compare")
4515    (set_attr "length" "8")])
4516
4517 (define_insn ""
4518   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4519         (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4520                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4521   "TARGET_POWERPC64"
4522   "divd %0,%1,%2"
4523   [(set_attr "type" "idiv")])
4524
4525 (define_insn "udivdi3"
4526   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4527         (udiv:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4528                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4529   "TARGET_POWERPC64"
4530   "divdu %0,%1,%2"
4531   [(set_attr "type" "idiv")])
4532
4533 (define_insn "rotldi3"
4534   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4535         (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4536                    (match_operand:DI 2 "reg_or_cint_operand" "ri")))]
4537   "TARGET_POWERPC64"
4538   "rld%I2cl %0,%1,%H2,0")
4539
4540 (define_insn ""
4541   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4542         (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4543                                (match_operand:DI 2 "reg_or_cint_operand" "ri"))
4544                     (const_int 0)))
4545    (clobber (match_scratch:DI 3 "=r"))]
4546   "TARGET_POWERPC64"
4547   "rld%I2cl. %3,%1,%H2,0"
4548   [(set_attr "type" "delayed_compare")])
4549
4550 (define_insn ""
4551   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4552         (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4553                                (match_operand:DI 2 "reg_or_cint_operand" "ri"))
4554                     (const_int 0)))
4555    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4556         (rotate:DI (match_dup 1) (match_dup 2)))]
4557   "TARGET_POWERPC64"
4558   "rld%I2cl. %0,%1,%H2,0"
4559   [(set_attr "type" "delayed_compare")])
4560
4561 (define_expand "ashldi3"
4562   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4563         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
4564                    (match_operand:SI 2 "reg_or_cint_operand" "")))]
4565   "TARGET_POWERPC64 || TARGET_POWER"
4566   "
4567 {
4568   if (TARGET_POWERPC64)
4569     ;
4570   else if (TARGET_POWER)
4571     {
4572       emit_insn (gen_ashldi3_power (operands[0], operands[1], operands[2]));
4573       DONE;
4574     }
4575   else
4576     FAIL;
4577 }")
4578
4579 (define_insn ""
4580   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4581         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4582                    (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4583   "TARGET_POWERPC64"
4584   "sld%I2 %0,%1,%H2"
4585   [(set_attr "length" "8")])
4586
4587 (define_insn ""
4588   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4589         (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4590                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4591                     (const_int 0)))
4592    (clobber (match_scratch:DI 3 "=r"))]
4593   "TARGET_POWERPC64"
4594   "sld%I2. %3,%1,%H2"
4595   [(set_attr "type" "delayed_compare")])
4596
4597 (define_insn ""
4598   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4599         (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4600                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4601                     (const_int 0)))
4602    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4603         (ashift:DI (match_dup 1) (match_dup 2)))]
4604   "TARGET_POWERPC64"
4605   "sld%I2. %0,%1,%H2"
4606   [(set_attr "type" "delayed_compare")])
4607
4608 (define_expand "lshrdi3"
4609   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4610         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
4611                      (match_operand:SI 2 "reg_or_cint_operand" "")))]
4612   "TARGET_POWERPC64 || TARGET_POWER"
4613   "
4614 {
4615   if (TARGET_POWERPC64)
4616     ;
4617   else if (TARGET_POWER)
4618     {
4619       emit_insn (gen_lshrdi3_power (operands[0], operands[1], operands[2]));
4620       DONE;
4621     }
4622   else
4623     FAIL;
4624 }")
4625
4626 (define_insn ""
4627   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4628         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4629                      (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4630   "TARGET_POWERPC64"
4631   "srd%I2 %0,%1,%H2")
4632
4633 (define_insn ""
4634   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4635         (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4636                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4637                     (const_int 0)))
4638    (clobber (match_scratch:DI 3 "=r"))]
4639   "TARGET_POWERPC64"
4640   "srd%I2. %3,%1,%H2"
4641   [(set_attr "type" "delayed_compare")])
4642
4643 (define_insn ""
4644   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4645         (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4646                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4647                     (const_int 0)))
4648    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4649         (lshiftrt:DI (match_dup 1) (match_dup 2)))]
4650   "TARGET_POWERPC64"
4651   "srd%I2. %0,%1,%H2"
4652   [(set_attr "type" "delayed_compare")])
4653
4654 (define_expand "ashrdi3"
4655   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4656         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
4657                      (match_operand:SI 2 "reg_or_cint_operand" "")))]
4658   "TARGET_POWERPC64 || TARGET_POWER"
4659   "
4660 {
4661   if (TARGET_POWERPC64)
4662     ;
4663   else if (TARGET_POWER && GET_CODE (operands[2]) == CONST_INT)
4664     {
4665       emit_insn (gen_ashrdi3_power (operands[0], operands[1], operands[2]));
4666       DONE;
4667     }
4668   else
4669     FAIL;
4670 }")
4671
4672 (define_insn ""
4673   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4674         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4675                      (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4676   "TARGET_POWERPC64"
4677   "srad%I2 %0,%1,%H2")
4678
4679 (define_insn ""
4680   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4681         (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4682                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4683                     (const_int 0)))
4684    (clobber (match_scratch:DI 3 "=r"))]
4685   "TARGET_POWERPC64"
4686   "srad%I2. %3,%1,%H2"
4687   [(set_attr "type" "delayed_compare")])
4688
4689 (define_insn ""
4690   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4691         (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4692                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4693                     (const_int 0)))
4694    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4695         (ashiftrt:DI (match_dup 1) (match_dup 2)))]
4696   "TARGET_POWERPC64"
4697   "srad%I2. %0,%1,%H2"
4698   [(set_attr "type" "delayed_compare")])
4699
4700 (define_insn "anddi3"
4701   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4702         (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4703                 (match_operand:DI 2 "and_operand" "?r,K,J")))
4704    (clobber (match_scratch:CC 3 "=X,x,x"))]
4705   "TARGET_POWERPC64"
4706   "@
4707    and %0,%1,%2
4708    andi. %0,%1,%b2
4709    andis. %0,%1,%u2")
4710
4711 (define_insn ""
4712   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x")
4713         (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4714                             (match_operand:DI 2 "and_operand" "r,K,J"))
4715                     (const_int 0)))
4716    (clobber (match_scratch:DI 3 "=r,r,r"))]
4717   "TARGET_POWERPC64"
4718   "@
4719    and. %3,%1,%2
4720    andi. %3,%1,%b2
4721    andis. %3,%1,%u2"
4722   [(set_attr "type" "compare,compare,compare")])
4723
4724 (define_insn ""
4725   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x")
4726         (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4727                             (match_operand:DI 2 "and_operand" "r,K,J"))
4728                     (const_int 0)))
4729    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4730         (and:DI (match_dup 1) (match_dup 2)))]
4731   "TARGET_POWERPC64"
4732   "@
4733    and. %0,%1,%2
4734    andi. %0,%1,%b2
4735    andis. %0,%1,%u2"
4736   [(set_attr "type" "compare,compare,compare")])
4737
4738 ;; Take a AND with a constant that cannot be done in a single insn and try to
4739 ;; split it into two insns.  This does not verify that the insns are valid
4740 ;; since this need not be done as combine will do it.
4741
4742 (define_split
4743   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4744         (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
4745                 (match_operand:DI 2 "non_and_cint_operand" "")))]
4746   "TARGET_POWERPC64"
4747   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
4748    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
4749   "
4750 {
4751   int maskval = INTVAL (operands[2]);
4752   int i, transitions, last_bit_value;
4753   int orig = maskval, first_c = maskval, second_c;
4754
4755   /* We know that MASKVAL must have more than 2 bit-transitions.  Start at
4756      the low-order bit and count for the third transition.  When we get there,
4757      make a first mask that has everything to the left of that position
4758      a one.  Then make the second mask to turn off whatever else is needed.  */
4759
4760   for (i = 1, transitions = 0, last_bit_value = maskval & 1; i < 32; i++)
4761     {
4762       if (((maskval >>= 1) & 1) != last_bit_value)
4763         last_bit_value ^= 1, transitions++;
4764
4765       if (transitions > 2)
4766         {
4767           first_c |= (~0) << i;
4768           break;
4769         }
4770     }
4771
4772   second_c = orig | ~ first_c;
4773
4774   operands[3] = gen_rtx (CONST_INT, VOIDmode, first_c);
4775   operands[4] = gen_rtx (CONST_INT, VOIDmode, second_c);
4776 }")
4777
4778 (define_insn "iordi3"
4779   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4780         (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4781                 (match_operand:DI 2 "logical_operand" "r,K,J")))]
4782   "TARGET_POWERPC64"
4783   "@
4784    or %0,%1,%2
4785    ori %0,%1,%b2
4786    oris %0,%1,%u2")
4787
4788 (define_insn ""
4789   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4790         (compare:CC (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4791                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4792                     (const_int 0)))
4793    (clobber (match_scratch:DI 3 "=r"))]
4794   "TARGET_POWERPC64"
4795   "or. %3,%1,%2"
4796   [(set_attr "type" "compare")])
4797
4798 (define_insn ""
4799   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4800         (compare:CC (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4801                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4802                     (const_int 0)))
4803    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4804         (ior:DI (match_dup 1) (match_dup 2)))]
4805   "TARGET_POWERPC64"
4806   "or. %0,%1,%2"
4807   [(set_attr "type" "compare")])
4808
4809 ;; Split an IOR that we can't do in one insn into two insns, each of which
4810 ;; does one 16-bit part.  This is used by combine.
4811
4812 (define_split
4813   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4814         (ior:DI (match_operand:DI 1 "gpc_reg_operand" "")
4815                 (match_operand:DI 2 "non_logical_cint_operand" "")))]
4816   "TARGET_POWERPC64"
4817   [(set (match_dup 0) (ior:DI (match_dup 1) (match_dup 3)))
4818    (set (match_dup 0) (ior:DI (match_dup 0) (match_dup 4)))]
4819 "
4820 {
4821   operands[3] = gen_rtx (CONST_INT, VOIDmode,
4822                          INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
4823   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
4824 }")
4825
4826 (define_insn "xordi3"
4827   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4828         (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4829                 (match_operand:DI 2 "logical_operand" "r,K,J")))]
4830   "TARGET_POWERPC64"
4831   "@
4832    xor %0,%1,%2
4833    xori %0,%1,%b2
4834    xoris %0,%1,%u2")
4835
4836 (define_insn ""
4837   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4838         (compare:CC (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4839                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4840                     (const_int 0)))
4841    (clobber (match_scratch:DI 3 "=r"))]
4842   "TARGET_POWERPC64"
4843   "xor. %3,%1,%2"
4844   [(set_attr "type" "compare")])
4845
4846 (define_insn ""
4847   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4848         (compare:CC (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4849                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4850                     (const_int 0)))
4851    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4852         (xor:DI (match_dup 1) (match_dup 2)))]
4853   "TARGET_POWERPC64"
4854   "xor. %0,%1,%2"
4855   [(set_attr "type" "compare")])
4856
4857 ;; Split an XOR that we can't do in one insn into two insns, each of which
4858 ;; does one 16-bit part.  This is used by combine.
4859
4860 (define_split
4861   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4862         (xor:DI (match_operand:DI 1 "gpc_reg_operand" "")
4863                 (match_operand:DI 2 "non_logical_cint_operand" "")))]
4864   "TARGET_POWERPC64"
4865   [(set (match_dup 0) (xor:DI (match_dup 1) (match_dup 3)))
4866    (set (match_dup 0) (xor:DI (match_dup 0) (match_dup 4)))]
4867 "
4868 {
4869   operands[3] = gen_rtx (CONST_INT, VOIDmode,
4870                          INTVAL (operands[2]) & 0xffff0000);
4871   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
4872 }")
4873
4874 (define_insn ""
4875   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4876         (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4877                         (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4878    "TARGET_POWERPC64"
4879    "eqv %0,%1,%2")
4880
4881 (define_insn ""
4882   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4883         (compare:CC (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4884                                     (match_operand:DI 2 "gpc_reg_operand" "r")))
4885                     (const_int 0)))
4886    (clobber (match_scratch:DI 3 "=r"))]
4887    "TARGET_POWERPC64"
4888    "eqv. %3,%1,%2"
4889    [(set_attr "type" "compare")])
4890
4891 (define_insn ""
4892   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4893         (compare:CC (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4894                                     (match_operand:DI 2 "gpc_reg_operand" "r")))
4895                     (const_int 0)))
4896    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4897         (not:DI (xor:DI (match_dup 1) (match_dup 2))))]
4898    "TARGET_POWERPC64"
4899    "eqv. %0,%1,%2"
4900    [(set_attr "type" "compare")])
4901
4902 (define_insn ""
4903   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4904         (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4905                 (match_operand:DI 2 "gpc_reg_operand" "r")))]
4906   "TARGET_POWERPC64"
4907   "andc %0,%2,%1")
4908
4909 (define_insn ""
4910   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4911         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4912                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4913                     (const_int 0)))
4914    (clobber (match_scratch:DI 3 "=r"))]
4915   "TARGET_POWERPC64"
4916   "andc. %3,%2,%1"
4917   [(set_attr "type" "compare")])
4918
4919 (define_insn ""
4920   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4921         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4922                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4923                     (const_int 0)))
4924    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4925         (and:DI (not:DI (match_dup 1)) (match_dup 2)))]
4926   "TARGET_POWERPC64"
4927   "andc. %0,%2,%1"
4928   [(set_attr "type" "compare")])
4929
4930 (define_insn ""
4931   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4932         (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4933                 (match_operand:DI 2 "gpc_reg_operand" "r")))]
4934   "TARGET_POWERPC64"
4935   "orc %0,%2,%1")
4936
4937 (define_insn ""
4938   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4939         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4940                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4941                     (const_int 0)))
4942    (clobber (match_scratch:DI 3 "=r"))]
4943   "TARGET_POWERPC64"
4944   "orc. %3,%2,%1"
4945   [(set_attr "type" "compare")])
4946
4947 (define_insn ""
4948   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4949         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4950                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4951                     (const_int 0)))
4952    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4953         (ior:DI (not:DI (match_dup 1)) (match_dup 2)))]
4954   "TARGET_POWERPC64"
4955   "orc. %0,%2,%1"
4956   [(set_attr "type" "compare")])
4957
4958 (define_insn ""
4959   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4960         (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4961                 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4962   "TARGET_POWERPC64"
4963   "nand %0,%1,%2")
4964
4965 (define_insn ""
4966   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4967         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4968                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4969                     (const_int 0)))
4970    (clobber (match_scratch:DI 3 "=r"))]
4971   "TARGET_POWERPC64"
4972   "nand. %3,%1,%2"
4973   [(set_attr "type" "compare")])
4974
4975 (define_insn ""
4976   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4977         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4978                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4979                     (const_int 0)))
4980    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4981         (ior:DI (not:DI (match_dup 1)) (not:DI (match_dup 2))))]
4982   "TARGET_POWERPC64"
4983   "nand. %0,%1,%2"
4984   [(set_attr "type" "compare")])
4985
4986 (define_insn ""
4987   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4988         (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4989                 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4990   "TARGET_POWERPC64"
4991   "nor %0,%1,%2")
4992
4993 (define_insn ""
4994   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4995         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4996                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4997                     (const_int 0)))
4998    (clobber (match_scratch:DI 3 "=r"))]
4999   "TARGET_POWERPC64"
5000   "nor. %3,%1,%2"
5001   [(set_attr "type" "compare")])
5002
5003 (define_insn ""
5004   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
5005         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
5006                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
5007                     (const_int 0)))
5008    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
5009         (and:DI (not:DI (match_dup 1)) (not:DI (match_dup 2))))]
5010   "TARGET_POWERPC64"
5011   "nor. %0,%1,%2"
5012   [(set_attr "type" "compare")])
5013 \f
5014 ;; Now define ways of moving data around.
5015
5016 ;; Elf specific ways of loading addresses for non-PIC code.
5017 ;; The output of this could be r0, but we limit it to base
5018 ;; registers, since almost all uses of this will need it
5019 ;; in a base register shortly.
5020 (define_insn "elf_high"
5021   [(set (match_operand:SI 0 "register_operand" "=b")
5022         (high:SI (match_operand 1 "" "")))]
5023   "TARGET_ELF && !TARGET_64BIT"
5024   "{cau|addis} %0,0,%1@ha")
5025
5026 (define_insn "elf_low"
5027   [(set (match_operand:SI 0 "register_operand" "=r")
5028         (lo_sum:SI (match_operand:SI 1 "register_operand" "b")
5029                    (match_operand 2 "" "")))]
5030    "TARGET_ELF && !TARGET_64BIT"
5031    "{cal %0,%a2@l(%1)|addi %0,%1,%2@l}")
5032
5033 ;; Set up a register with a value from the GOT table
5034
5035 (define_expand "movsi_got"
5036   [(set (match_operand:SI 0 "register_operand" "")
5037         (unspec [(match_operand:SI 1 "got_operand" "")
5038                  (match_dup 2)] 8))]
5039   "(DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS) && flag_pic == 1"
5040   "
5041 {
5042   operands[2] = rs6000_got_register (operands[1]);
5043 }")
5044
5045 (define_insn "*movsi_got_internal"
5046   [(set (match_operand:SI 0 "register_operand" "=r")
5047         (unspec [(match_operand:SI 1 "got_operand" "")
5048                  (match_operand:SI 2 "register_operand" "b")] 8))]
5049   "(DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS) && flag_pic == 1"
5050   "{l|lwz} %0,%a1@got(%2)"
5051   [(set_attr "type" "load")])
5052
5053 ;; For SI, we special-case integers that can't be loaded in one insn.  We
5054 ;; do the load 16-bits at a time.  We could do this by loading from memory,
5055 ;; and this is even supposed to be faster, but it is simpler not to get
5056 ;; integers in the TOC.
5057 (define_expand "movsi"
5058   [(set (match_operand:SI 0 "general_operand" "")
5059         (match_operand:SI 1 "any_operand" ""))]
5060   ""
5061   "
5062 {
5063   if (GET_CODE (operands[0]) != REG)
5064     operands[1] = force_reg (SImode, operands[1]);
5065
5066   /* Convert a move of a CONST_DOUBLE into a CONST_INT */
5067   if (GET_CODE (operands[1]) == CONST_DOUBLE)
5068     operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
5069
5070   /* Use default pattern for address of ELF small data */
5071   if (TARGET_ELF
5072       && (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
5073       && (GET_CODE (operands[1]) == SYMBOL_REF || GET_CODE (operands[1]) == CONST)
5074       && small_data_operand (operands[1], SImode))
5075     {
5076       emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1]));
5077       DONE;
5078     }
5079
5080   if ((DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
5081       && flag_pic == 1 && got_operand (operands[1], SImode))
5082     {
5083       emit_insn (gen_movsi_got (operands[0], operands[1]));
5084       DONE;
5085     }
5086
5087   if (TARGET_ELF && TARGET_NO_TOC && !TARGET_64BIT
5088       && !flag_pic
5089       && CONSTANT_P (operands[1])
5090       && GET_CODE (operands[1]) != HIGH
5091       && GET_CODE (operands[1]) != CONST_INT)
5092     {
5093       rtx target = (reload_completed || reload_in_progress)
5094                         ? operands[0] : gen_reg_rtx (SImode);
5095
5096       /* If this is a function address on -mcall-aixdesc or -mcall-nt,
5097          convert it to the address of the descriptor.  */
5098       if ((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
5099           && GET_CODE (operands[1]) == SYMBOL_REF
5100           && XSTR (operands[1], 0)[0] == '.')
5101         {
5102           char *name = XSTR (operands[1], 0);
5103           rtx new_ref;
5104           while (*name == '.')
5105             name++;
5106           new_ref = gen_rtx (SYMBOL_REF, Pmode, name);
5107           CONSTANT_POOL_ADDRESS_P (new_ref) = CONSTANT_POOL_ADDRESS_P (operands[1]);
5108           SYMBOL_REF_FLAG (new_ref) = SYMBOL_REF_FLAG (operands[1]);
5109           SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
5110           operands[1] = new_ref;
5111         }
5112
5113       emit_insn (gen_elf_high (target, operands[1]));
5114       emit_insn (gen_elf_low (operands[0], target, operands[1]));
5115       DONE;
5116     }
5117
5118   if (GET_CODE (operands[1]) == CONST
5119       && DEFAULT_ABI == ABI_NT
5120       && !side_effects_p (operands[0]))
5121     {
5122       rtx const_term = const0_rtx;
5123       rtx sym = eliminate_constant_term (XEXP (operands[1], 0), &const_term);
5124       if (sym && GET_CODE (const_term) == CONST_INT
5125           && (GET_CODE (sym) == SYMBOL_REF || GET_CODE (sym) == LABEL_REF))
5126         {
5127           unsigned HOST_WIDE_INT value = INTVAL (const_term);
5128           int new_reg_p = (flag_expensive_optimizations
5129                            && !reload_completed
5130                            && !reload_in_progress);
5131           rtx tmp1 = (new_reg_p && value != 0) ? gen_reg_rtx (SImode) : operands[0];
5132
5133           emit_insn (gen_movsi (tmp1, sym));
5134           if (INTVAL (const_term) != 0)
5135             {
5136               if (value + 0x8000 < 0x10000)
5137                 emit_insn (gen_addsi3 (operands[0], tmp1, GEN_INT (value)));
5138
5139               else
5140                 {
5141                   HOST_WIDE_INT high_int = value & (~ (HOST_WIDE_INT) 0xffff);
5142                   HOST_WIDE_INT low_int = value & 0xffff;
5143                   rtx tmp2 = (!new_reg_p || !low_int) ? operands[0] : gen_reg_rtx (Pmode);
5144
5145                   if (low_int & 0x8000)
5146                     high_int += 0x10000, low_int |= ((HOST_WIDE_INT) -1) << 16;
5147
5148                   emit_insn (gen_addsi3 (tmp2, tmp1, GEN_INT (high_int)));
5149                   if (low_int)
5150                     emit_insn (gen_addsi3 (operands[0], tmp2, GEN_INT (low_int)));
5151                 }
5152             }
5153           DONE;
5154         }
5155       else
5156         fatal_insn (\"bad address\", operands[1]);
5157     }
5158
5159   if ((!TARGET_WINDOWS_NT || DEFAULT_ABI != ABI_NT)
5160       && CONSTANT_P (operands[1])
5161       && GET_CODE (operands[1]) != CONST_INT
5162       && GET_CODE (operands[1]) != HIGH
5163       && ! LEGITIMATE_CONSTANT_POOL_ADDRESS_P (operands[1]))
5164     {
5165       /* Emit a USE operation so that the constant isn't deleted if
5166          expensive optimizations are turned on because nobody
5167          references it.  This should only be done for operands that
5168          contain SYMBOL_REFs with CONSTANT_POOL_ADDRESS_P set.
5169          This should not be done for operands that contain LABEL_REFs.
5170          For now, we just handle the obvious case.  */
5171       if (GET_CODE (operands[1]) != LABEL_REF)
5172         emit_insn (gen_rtx (USE, VOIDmode, operands[1]));
5173
5174       /* If we are to limit the number of things we put in the TOC and
5175          this is a symbol plus a constant we can add in one insn,
5176          just put the symbol in the TOC and add the constant.  Don't do
5177          this if reload is in progress.  */
5178       if (GET_CODE (operands[1]) == CONST
5179           && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
5180           && GET_CODE (XEXP (operands[1], 0)) == PLUS
5181           && add_operand (XEXP (XEXP (operands[1], 0), 1), SImode)
5182           && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
5183               || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
5184           && ! side_effects_p (operands[0]))
5185         {
5186           rtx sym = force_const_mem (SImode, XEXP (XEXP (operands[1], 0), 0));
5187           rtx other = XEXP (XEXP (operands[1], 0), 1);
5188
5189           emit_insn (gen_addsi3 (operands[0], force_reg (SImode, sym), other));
5190           DONE;
5191         }
5192
5193       operands[1] = force_const_mem (SImode, operands[1]);
5194       if (! memory_address_p (SImode, XEXP (operands[1], 0))
5195           && ! reload_in_progress)
5196         operands[1] = change_address (operands[1], SImode,
5197                                       XEXP (operands[1], 0));
5198     }
5199 }")
5200
5201 (define_insn ""
5202   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,m,r,r,r,r,r,*q,*c*l,*h")
5203         (match_operand:SI 1 "input_operand" "r,S,T,U,m,r,I,J,n,R,*h,r,r,0"))]
5204   "gpc_reg_operand (operands[0], SImode)
5205    || gpc_reg_operand (operands[1], SImode)"
5206   "@
5207    mr %0,%1
5208    {l|lwz} %0,[toc]%1(2)
5209    {l|lwz} %0,[toc]%l1(2)
5210    {cal|la} %0,%a1
5211    {l%U1%X1|lwz%U1%X1} %0,%1
5212    {st%U0%X0|stw%U0%X0} %1,%0
5213    {lil|li} %0,%1
5214    {liu|lis} %0,%v1
5215    #
5216    {cal|la} %0,%1(%*)
5217    mf%1 %0
5218    mt%0 %1
5219    mt%0 %1
5220    cror 0,0,0"
5221   [(set_attr "type" "*,load,load,*,load,store,*,*,*,*,*,*,mtjmpr,*")
5222    (set_attr "length" "4,4,4,4,4,4,4,4,8,4,4,4,4,4")])
5223
5224 ;; Split a load of a large constant into the appropriate two-insn
5225 ;; sequence.
5226
5227 (define_split
5228   [(set (match_operand:SI 0 "gpc_reg_operand" "")
5229         (match_operand:SI 1 "const_int_operand" ""))]
5230   "(unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
5231    && (INTVAL (operands[1]) & 0xffff) != 0"
5232   [(set (match_dup 0)
5233         (match_dup 2))
5234    (set (match_dup 0)
5235         (ior:SI (match_dup 0)
5236                 (match_dup 3)))]
5237   "
5238 {
5239   operands[2] = gen_rtx (CONST_INT, VOIDmode,
5240                          INTVAL (operands[1]) & 0xffff0000);
5241   operands[3] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[1]) & 0xffff);
5242 }")
5243
5244 (define_insn ""
5245   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
5246         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
5247                     (const_int 0)))
5248    (set (match_operand:SI 0 "gpc_reg_operand" "=r") (match_dup 1))]
5249   ""
5250   "mr. %0,%1"
5251   [(set_attr "type" "compare")])
5252 \f
5253 (define_expand "movhi"
5254   [(set (match_operand:HI 0 "general_operand" "")
5255         (match_operand:HI 1 "any_operand" ""))]
5256   ""
5257   "
5258 {
5259   if (GET_CODE (operands[0]) != REG)
5260     operands[1] = force_reg (HImode, operands[1]);
5261
5262   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
5263     {
5264       operands[1] = force_const_mem (HImode, operands[1]);
5265       if (! memory_address_p (HImode, XEXP (operands[1], 0))
5266           && ! reload_in_progress)
5267         operands[1] = change_address (operands[1], HImode,
5268                                       XEXP (operands[1], 0));
5269     }
5270 }")
5271
5272 (define_insn ""
5273   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
5274         (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
5275   "gpc_reg_operand (operands[0], HImode)
5276    || gpc_reg_operand (operands[1], HImode)"
5277   "@
5278    mr %0,%1
5279    lhz%U1%X1 %0,%1
5280    sth%U0%X0 %1,%0
5281    {lil|li} %0,%w1
5282    mf%1 %0
5283    mt%0 %1
5284    mt%0 %1
5285    cror 0,0,0"
5286   [(set_attr "type" "*,load,store,*,*,*,mtjmpr,*")])
5287
5288 (define_expand "movqi"
5289   [(set (match_operand:QI 0 "general_operand" "")
5290         (match_operand:QI 1 "any_operand" ""))]
5291   ""
5292   "
5293 {
5294   if (GET_CODE (operands[0]) != REG)
5295     operands[1] = force_reg (QImode, operands[1]);
5296
5297   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
5298     {
5299       operands[1] = force_const_mem (QImode, operands[1]);
5300       if (! memory_address_p (QImode, XEXP (operands[1], 0))
5301           && ! reload_in_progress)
5302         operands[1] = change_address (operands[1], QImode,
5303                                       XEXP (operands[1], 0));
5304     }
5305 }")
5306
5307 (define_insn ""
5308   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
5309         (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
5310   "gpc_reg_operand (operands[0], QImode)
5311    || gpc_reg_operand (operands[1], QImode)"
5312   "@
5313    mr %0,%1
5314    lbz%U1%X1 %0,%1
5315    stb%U0%X0 %1,%0
5316    {lil|li} %0,%1
5317    mf%1 %0
5318    mt%0 %1
5319    mt%0 %1
5320    cror 0,0,0"
5321   [(set_attr "type" "*,load,store,*,*,*,mtjmpr,*")])
5322 \f
5323 ;; Here is how to move condition codes around.  When we store CC data in
5324 ;; an integer register or memory, we store just the high-order 4 bits.
5325 ;; This lets us not shift in the most common case of CR0.
5326 (define_expand "movcc"
5327   [(set (match_operand:CC 0 "nonimmediate_operand" "")
5328         (match_operand:CC 1 "nonimmediate_operand" ""))]
5329   ""
5330   "")
5331
5332 (define_insn ""
5333   [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,y,r,r,r,r,m")
5334         (match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,m,r"))]
5335   "register_operand (operands[0], CCmode)
5336    || register_operand (operands[1], CCmode)"
5337   "@
5338    mcrf %0,%1
5339    mtcrf 128,%1
5340    {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
5341    mfcr %0
5342    mfcr %0\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
5343    mr %0,%1
5344    {l%U1%X1|lwz%U1%X1} %0,%1
5345    {st%U0%U1|stw%U0%U1} %1,%0"
5346   [(set_attr "type" "*,*,*,compare,*,*,load,store")
5347    (set_attr "length" "*,*,12,*,8,*,*,*")])
5348 \f
5349 ;; For floating-point, we normally deal with the floating-point registers
5350 ;; unless -msoft-float is used.  The sole exception is that parameter passing
5351 ;; can produce floating-point values in fixed-point registers.  Unless the
5352 ;; value is a simple constant or already in memory, we deal with this by
5353 ;; allocating memory and copying the value explicitly via that memory location.
5354 (define_expand "movsf"
5355   [(set (match_operand:SF 0 "nonimmediate_operand" "")
5356         (match_operand:SF 1 "any_operand" ""))]
5357   ""
5358   "
5359 {
5360   /* If we are called from reload, we might be getting a SUBREG of a hard
5361      reg.  So expand it.  */
5362   if (GET_CODE (operands[0]) == SUBREG
5363       && GET_CODE (SUBREG_REG (operands[0])) == REG
5364       && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER)
5365     operands[0] = alter_subreg (operands[0]);
5366   if (GET_CODE (operands[1]) == SUBREG
5367       && GET_CODE (SUBREG_REG (operands[1])) == REG
5368       && REGNO (SUBREG_REG (operands[1])) < FIRST_PSEUDO_REGISTER)
5369     operands[1] = alter_subreg (operands[1]);
5370
5371   if (TARGET_SOFT_FLOAT && GET_CODE (operands[0]) == MEM)
5372     operands[1] = force_reg (SFmode, operands[1]);
5373
5374   else if (TARGET_HARD_FLOAT)
5375     {
5376       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 32)
5377         {
5378           /* If this is a store to memory or another integer register do the
5379              move directly.  Otherwise store to a temporary stack slot and
5380              load from there into a floating point register.  */
5381
5382           if (GET_CODE (operands[0]) == MEM
5383               || (GET_CODE (operands[0]) == REG
5384                   && (REGNO (operands[0]) < 32
5385                       || (reload_in_progress
5386                           && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))))
5387             {
5388               emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
5389                               operand_subword (operands[1], 0, 0, SFmode));
5390               DONE;
5391             }
5392           else
5393             {
5394               rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
5395
5396               emit_move_insn (stack_slot, operands[1]);
5397               emit_move_insn (operands[0], stack_slot);
5398               DONE;
5399             }
5400         }
5401
5402       if (GET_CODE (operands[0]) == MEM)
5403         {
5404           /* If operands[1] is a register, it may have double-precision data
5405              in it, so truncate it to single precision.  We need not do
5406              this for POWERPC.  */
5407           if (! TARGET_POWERPC && TARGET_HARD_FLOAT
5408               && GET_CODE (operands[1]) == REG)
5409             {
5410               rtx newreg
5411                 = reload_in_progress ? operands[1] : gen_reg_rtx (SFmode);
5412               emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
5413               operands[1] = newreg;
5414             }
5415
5416           operands[1] = force_reg (SFmode, operands[1]);
5417         }
5418
5419       if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) < 32)
5420         {
5421           if (GET_CODE (operands[1]) == MEM
5422 #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && ! defined(REAL_IS_NOT_DOUBLE)
5423               || GET_CODE (operands[1]) == CONST_DOUBLE
5424 #endif
5425               || (GET_CODE (operands[1]) == REG
5426                   && (REGNO (operands[1]) < 32
5427                       || (reload_in_progress
5428                           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER))))
5429             {
5430               emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
5431                               operand_subword (operands[1], 0, 0, SFmode));
5432               DONE;
5433             }
5434           else
5435             {
5436               rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
5437
5438               emit_move_insn (stack_slot, operands[1]);
5439               emit_move_insn (operands[0], stack_slot);
5440               DONE;
5441             }
5442         }
5443     }
5444
5445   if (CONSTANT_P (operands[1]) && TARGET_HARD_FLOAT)
5446     {
5447       operands[1] = force_const_mem (SFmode, operands[1]);
5448       if (! memory_address_p (SFmode, XEXP (operands[1], 0))
5449           && ! reload_in_progress)
5450         operands[1] = change_address (operands[1], SFmode,
5451                                       XEXP (operands[1], 0));
5452     }
5453 }")
5454
5455 (define_split
5456   [(set (match_operand:SF 0 "gpc_reg_operand" "")
5457         (match_operand:SF 1 "const_double_operand" ""))]
5458   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], SFmode) <= 1
5459    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5460        || (GET_CODE (operands[0]) == SUBREG
5461            && GET_CODE (SUBREG_REG (operands[0])) == REG
5462            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5463   [(set (match_dup 2) (match_dup 3))]
5464   "
5465 {
5466   long l;
5467   REAL_VALUE_TYPE rv;
5468
5469   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
5470   REAL_VALUE_TO_TARGET_SINGLE (rv, l);
5471
5472   operands[2] = operand_subword (operands[0], 0, 0, SFmode);
5473   operands[3] = GEN_INT(l);
5474 }")
5475
5476 (define_split
5477   [(set (match_operand:SF 0 "gpc_reg_operand" "")
5478         (match_operand:SF 1 "const_double_operand" ""))]
5479   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], SFmode) == 2
5480    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5481        || (GET_CODE (operands[0]) == SUBREG
5482            && GET_CODE (SUBREG_REG (operands[0])) == REG
5483            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5484   [(set (match_dup 2) (match_dup 3))
5485    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 4)))]
5486   "
5487 {
5488   long l;
5489   REAL_VALUE_TYPE rv;
5490
5491   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
5492   REAL_VALUE_TO_TARGET_SINGLE (rv, l);
5493
5494   operands[2] = operand_subword (operands[0], 0, 0, SFmode);
5495   operands[3] = GEN_INT(l & 0xffff0000);
5496   operands[4] = GEN_INT(l & 0x0000ffff);
5497 }")
5498
5499 (define_insn "*movsf_hardfloat"
5500   [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,m,!r,!r")
5501         (match_operand:SF 1 "input_operand" "f,m,f,G,Fn"))]
5502   "(gpc_reg_operand (operands[0], SFmode)
5503    || gpc_reg_operand (operands[1], SFmode)) && TARGET_HARD_FLOAT"
5504   "@
5505    fmr %0,%1
5506    lfs%U1%X1 %0,%1
5507    stfs%U0%X0 %1,%0
5508    #
5509    #"
5510   [(set_attr "type" "fp,fpload,fpstore,*,*")
5511    (set_attr "length" "4,4,4,4,8")])
5512
5513 (define_insn "*movsf_softfloat"
5514   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,r")
5515         (match_operand:SF 1 "input_operand" "r,m,r,I,J,R,G,Fn"))]
5516   "(gpc_reg_operand (operands[0], SFmode)
5517    || gpc_reg_operand (operands[1], SFmode)) && TARGET_SOFT_FLOAT"
5518   "@
5519    mr %0,%1
5520    {l%U1%X1|lwz%U1%X1} %0,%1
5521    {st%U0%X0|stw%U0%X0} %1,%0
5522    {lil|li} %0,%1
5523    {liu|lis} %0,%v1
5524    {cal|la} %0,%1(%*)
5525    #
5526    #"
5527   [(set_attr "type" "*,load,store,*,*,*,*,*")
5528    (set_attr "length" "4,4,4,4,4,4,4,8")])
5529
5530 \f
5531 (define_expand "movdf"
5532   [(set (match_operand:DF 0 "nonimmediate_operand" "")
5533         (match_operand:DF 1 "any_operand" ""))]
5534   ""
5535   "
5536 {
5537   if (GET_CODE (operands[0]) != REG)
5538     operands[1] = force_reg (DFmode, operands[1]);
5539
5540       /* Stores between FPR and any non-FPR registers must go through a
5541          temporary stack slot.  */
5542
5543   if (TARGET_POWERPC64
5544       && GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
5545       && ((FP_REGNO_P (REGNO (operands[0]))
5546            && ! FP_REGNO_P (REGNO (operands[1])))
5547           || (FP_REGNO_P (REGNO (operands[1]))
5548               && ! FP_REGNO_P (REGNO (operands[0])))))
5549     {
5550       rtx stack_slot = assign_stack_temp (DFmode, 8, 0);
5551
5552       emit_move_insn (stack_slot, operands[1]);
5553       emit_move_insn (operands[0], stack_slot);
5554       DONE;
5555     }
5556
5557   if (CONSTANT_P (operands[1]) && ! easy_fp_constant (operands[1], DFmode))
5558     {
5559       operands[1] = force_const_mem (DFmode, operands[1]);
5560       if (! memory_address_p (DFmode, XEXP (operands[1], 0))
5561           && ! reload_in_progress)
5562         operands[1] = change_address (operands[1], DFmode,
5563                                       XEXP (operands[1], 0));
5564     }
5565 }")
5566
5567 (define_split
5568   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5569         (match_operand:DF 1 "const_int_operand" ""))]
5570   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) <= 1
5571    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5572        || (GET_CODE (operands[0]) == SUBREG
5573            && GET_CODE (SUBREG_REG (operands[0])) == REG
5574            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5575   [(set (match_dup 2) (match_dup 4))
5576    (set (match_dup 3) (match_dup 1))]
5577   "
5578 {
5579   int endian = (WORDS_BIG_ENDIAN == 0);
5580   operands[2] = operand_subword (operands[0], endian, 0, DFmode);
5581   operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
5582   operands[4] = (INTVAL (operands[1]) & 0x80000000) ? constm1_rtx : const0_rtx;
5583 }")
5584
5585 (define_split
5586   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5587         (match_operand:DF 1 "const_int_operand" ""))]
5588   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) >= 2
5589    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5590        || (GET_CODE (operands[0]) == SUBREG
5591            && GET_CODE (SUBREG_REG (operands[0])) == REG
5592            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5593   [(set (match_dup 3) (match_dup 5))
5594    (set (match_dup 2) (match_dup 4))
5595    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 6)))]
5596   "
5597 {
5598   HOST_WIDE_INT value = INTVAL (operands[1]);
5599   int endian = (WORDS_BIG_ENDIAN == 0);
5600   operands[2] = operand_subword (operands[0], endian, 0, DFmode);
5601   operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
5602   operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
5603   operands[5] = GEN_INT (value & 0xffff0000);
5604   operands[6] = GEN_INT (value & 0x0000ffff);
5605 }")
5606
5607 (define_split
5608   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5609         (match_operand:DF 1 "const_double_operand" ""))]
5610   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) <= 2
5611    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5612        || (GET_CODE (operands[0]) == SUBREG
5613            && GET_CODE (SUBREG_REG (operands[0])) == REG
5614            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5615   [(set (match_dup 2) (match_dup 4))
5616    (set (match_dup 3) (match_dup 5))]
5617   "
5618 {
5619   int endian = (WORDS_BIG_ENDIAN == 0);
5620   operands[2] = operand_subword (operands[0], endian, 0, DFmode);
5621   operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
5622
5623 #ifdef HOST_WORDS_BIG_ENDIAN
5624   operands[4] = GEN_INT (CONST_DOUBLE_LOW  (operands[1]));
5625   operands[5] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
5626 #else
5627   operands[4] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
5628   operands[5] = GEN_INT (CONST_DOUBLE_LOW  (operands[1]));
5629 #endif
5630 }")
5631
5632 (define_split
5633   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5634         (match_operand:DF 1 "const_double_operand" ""))]
5635   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) == 3
5636    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5637        || (GET_CODE (operands[0]) == SUBREG
5638            && GET_CODE (SUBREG_REG (operands[0])) == REG
5639            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5640   [(set (match_dup 2) (match_dup 4))
5641    (set (match_dup 3) (match_dup 5))
5642    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))]
5643   "
5644 {
5645   HOST_WIDE_INT high;
5646   HOST_WIDE_INT low;
5647   int endian = (WORDS_BIG_ENDIAN == 0);
5648   rtx high_reg = operand_subword (operands[0], endian, 0, DFmode);
5649   rtx low_reg  = operand_subword (operands[0], 1 - endian, 0, DFmode);
5650
5651 #ifdef HOST_WORDS_BIG_ENDIAN
5652   high = CONST_DOUBLE_LOW  (operands[1]);
5653   low  = CONST_DOUBLE_HIGH (operands[1]);
5654 #else
5655   high = CONST_DOUBLE_HIGH (operands[1]);
5656   low  = CONST_DOUBLE_LOW  (operands[1]);
5657 #endif
5658
5659   if (((unsigned HOST_WIDE_INT) (low + 0x8000) < 0x10000)
5660       || (low & 0xffff) == 0)
5661     {
5662       operands[2] = high_reg;
5663       operands[3] = low_reg;
5664       operands[4] = GEN_INT (high & 0xffff0000);
5665       operands[5] = GEN_INT (low);
5666       operands[6] = GEN_INT (high & 0x0000ffff);
5667     }
5668   else
5669     {
5670       operands[2] = low_reg;
5671       operands[3] = high_reg;
5672       operands[4] = GEN_INT (low & 0xffff0000);
5673       operands[5] = GEN_INT (high);
5674       operands[6] = GEN_INT (low & 0x0000ffff);
5675     }
5676 }")
5677
5678 (define_split
5679   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5680         (match_operand:DF 1 "const_double_operand" ""))]
5681   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) >= 4
5682    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5683        || (GET_CODE (operands[0]) == SUBREG
5684            && GET_CODE (SUBREG_REG (operands[0])) == REG
5685            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5686   [(set (match_dup 2) (match_dup 4))
5687    (set (match_dup 3) (match_dup 5))
5688    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))
5689    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 7)))]
5690   "
5691 {
5692   HOST_WIDE_INT high = CONST_DOUBLE_HIGH (operands[1]);
5693   HOST_WIDE_INT low  = CONST_DOUBLE_LOW  (operands[1]);
5694   int endian = (WORDS_BIG_ENDIAN == 0);
5695
5696   operands[2] = operand_subword (operands[0], endian, 0, DFmode);
5697   operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode);
5698   operands[4] = GEN_INT (high & 0xffff0000);
5699   operands[5] = GEN_INT (low  & 0xffff0000);
5700   operands[6] = GEN_INT (high & 0x0000ffff);
5701   operands[7] = GEN_INT (low  & 0x0000ffff);
5702 }")
5703
5704 (define_split
5705   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5706         (match_operand:DF 1 "easy_fp_constant" ""))]
5707   "TARGET_64BIT && reload_completed
5708    && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31)
5709        || (GET_CODE (operands[0]) == SUBREG
5710            && GET_CODE (SUBREG_REG (operands[0])) == REG
5711            && REGNO (SUBREG_REG (operands[0])) <= 31))"
5712   [(set (match_dup 2) (subreg:DI (match_dup 1) 0))]
5713   "
5714 { operands[2] = gen_lowpart (DImode, operands[0]); }")
5715
5716 ;; Don't have reload use general registers to load a constant.  First,
5717 ;; it might not work if the output operand has is the equivalent of
5718 ;; a non-offsettable memref, but also it is less efficient than loading
5719 ;; the constant into an FP register, since it will probably be used there.
5720 ;; The "??" is a kludge until we can figure out a more reasonable way
5721 ;; of handling these non-offsettable values.
5722 (define_insn "*movdf_hardfloat32"
5723   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,!r,!r,f,f,m")
5724         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F,f,m,f"))]
5725   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT
5726    && (register_operand (operands[0], DFmode)
5727        || register_operand (operands[1], DFmode))"
5728   "*
5729 {
5730   switch (which_alternative)
5731     {
5732     case 0:
5733       /* We normally copy the low-numbered register first.  However, if
5734          the first register operand 0 is the same as the second register of
5735          operand 1, we must copy in the opposite order.  */
5736       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5737         return \"mr %L0,%L1\;mr %0,%1\";
5738       else
5739         return \"mr %0,%1\;mr %L0,%L1\";
5740     case 1:
5741       /* If the low-address word is used in the address, we must load it
5742          last.  Otherwise, load it first.  Note that we cannot have
5743          auto-increment in that case since the address register is known to be
5744          dead.  */
5745       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5746                              operands [1], 0))
5747         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5748       else
5749         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5750     case 2:
5751       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5752     case 3:
5753     case 4:
5754     case 5:
5755       return \"#\";
5756     case 6:
5757       return \"fmr %0,%1\";
5758     case 7:
5759       return \"lfd%U1%X1 %0,%1\";
5760     case 8:
5761       return \"stfd%U0%X0 %1,%0\";
5762     }
5763 }"
5764   [(set_attr "type" "*,load,store,*,*,*,fp,fpload,fpstore")
5765    (set_attr "length" "8,8,8,8,12,16,*,*,*")])
5766
5767 (define_insn "*movdf_softfloat32"
5768   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,o,r,r,r")
5769         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F"))]
5770   "! TARGET_POWERPC64 && TARGET_SOFT_FLOAT
5771    && (register_operand (operands[0], DFmode)
5772        || register_operand (operands[1], DFmode))"
5773   "*
5774 {
5775   switch (which_alternative)
5776     {
5777     case 0:
5778       /* We normally copy the low-numbered register first.  However, if
5779          the first register operand 0 is the same as the second register of
5780          operand 1, we must copy in the opposite order.  */
5781       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5782         return \"mr %L0,%L1\;mr %0,%1\";
5783       else
5784         return \"mr %0,%1\;mr %L0,%L1\";
5785     case 1:
5786       /* If the low-address word is used in the address, we must load it
5787          last.  Otherwise, load it first.  Note that we cannot have
5788          auto-increment in that case since the address register is known to be
5789          dead.  */
5790       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5791                              operands [1], 0))
5792         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5793       else
5794         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5795     case 2:
5796       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5797     case 3:
5798     case 4:
5799     case 5:
5800       return \"#\";
5801     }
5802 }"
5803   [(set_attr "type" "*,load,store,*,*,*")
5804    (set_attr "length" "8,8,8,8,12,16")])
5805
5806 (define_insn "*movdf_hardfloat64"
5807   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,!r,!r,f,f,m")
5808         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F,f,m,f"))]
5809   "TARGET_POWERPC64 && TARGET_HARD_FLOAT
5810    && (register_operand (operands[0], DFmode)
5811        || register_operand (operands[1], DFmode))"
5812   "@
5813    mr %0,%1
5814    ld%U1%X1 %0,%1
5815    std%U0%X0 %1,%0
5816    #
5817    #
5818    #
5819    fmr %0,%1
5820    lfd%U1%X1 %0,%1
5821    stfd%U0%X0 %1,%0"
5822   [(set_attr "type" "*,load,store,*,*,*,fp,fpload,fpstore")
5823    (set_attr "length" "4,4,4,8,12,16,4,4,4")])
5824
5825 (define_insn "*movdf_softfloat64"
5826   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,o,r,r,r")
5827         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F"))]
5828   "TARGET_POWERPC64 && TARGET_SOFT_FLOAT
5829    && (register_operand (operands[0], DFmode)
5830        || register_operand (operands[1], DFmode))"
5831   "@
5832    mr %0,%1
5833    ld%U1%X1 %0,%1
5834    std%U0%X0 %1,%0
5835    #
5836    #
5837    #"
5838   [(set_attr "type" "*,load,store,*,*,*")
5839    (set_attr "length" "*,*,*,8,12,16")])
5840 \f
5841 ;; Next come the multi-word integer load and store and the load and store
5842 ;; multiple insns.
5843 (define_expand "movdi"
5844   [(set (match_operand:DI 0 "general_operand" "")
5845         (match_operand:DI 1 "any_operand" ""))]
5846   ""
5847   "
5848 {
5849   if (GET_CODE (operands[0]) != REG)
5850     operands[1] = force_reg (DImode, operands[1]);
5851
5852   if (TARGET_64BIT
5853       && (GET_CODE (operands[1]) == CONST_DOUBLE
5854           || GET_CODE (operands[1]) == CONST_INT))
5855     {
5856       HOST_WIDE_INT low;
5857       HOST_WIDE_INT high;
5858
5859       if (GET_CODE (operands[1]) == CONST_DOUBLE)
5860         {
5861           low = CONST_DOUBLE_LOW (operands[1]);
5862           high = CONST_DOUBLE_HIGH (operands[1]);
5863         }
5864       else
5865 #if HOST_BITS_PER_WIDE_INT == 32
5866         {
5867           low = INTVAL (operands[1]);
5868           high = (low < 0) ? ~0 : 0;
5869         }
5870 #else
5871         {
5872           low = INTVAL (operands[1]) & 0xffffffff;
5873           high = (HOST_WIDE_INT) INTVAL (operands[1]) >> 32;
5874         }
5875 #endif
5876
5877         if (high)
5878           {
5879             emit_move_insn (operands[0], GEN_INT (high));
5880             emit_insn (gen_ashldi3 (operands[0], operands[0], GEN_INT(32)));
5881             if (low)
5882               {
5883                 HOST_WIDE_INT low_low = low & 0xffff;
5884                 HOST_WIDE_INT low_high = low & (~ (HOST_WIDE_INT) 0xffff);
5885                 if (low_high)
5886                   emit_insn (gen_iordi3 (operands[0], operands[0],
5887                                          GEN_INT (low_high)));
5888                 if (low_low)
5889                   emit_insn (gen_iordi3 (operands[0], operands[0],
5890                                          GEN_INT (low_low)));
5891               }
5892               DONE;
5893           }
5894     }
5895
5896       /* Stores between FPR and any non-FPR registers must go through a
5897          temporary stack slot.  */
5898
5899   if (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
5900       && ((FP_REGNO_P (REGNO (operands[0]))
5901            && ! FP_REGNO_P (REGNO (operands[1])))
5902           || (FP_REGNO_P (REGNO (operands[1]))
5903               && ! FP_REGNO_P (REGNO (operands[0])))))
5904     {
5905       rtx stack_slot = assign_stack_temp (DImode, 8, 0);
5906
5907       emit_move_insn (stack_slot, operands[1]);
5908       emit_move_insn (operands[0], stack_slot);
5909       DONE;
5910     }
5911 }")
5912
5913 (define_insn "*movdi_32"
5914   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,f,f,m,r,r,r,r,r")
5915         (match_operand:DI 1 "input_operand" "r,m,r,f,m,f,IJK,n,G,H,F"))]
5916   "TARGET_32BIT
5917    && (gpc_reg_operand (operands[0], DImode)
5918        || gpc_reg_operand (operands[1], DImode))"
5919   "*
5920 {
5921   switch (which_alternative)
5922     {
5923     case 0:
5924       /* We normally copy the low-numbered register first.  However, if
5925          the first register operand 0 is the same as the second register of
5926          operand 1, we must copy in the opposite order.  */
5927       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5928         return \"mr %L0,%L1\;mr %0,%1\";
5929       else
5930         return \"mr %0,%1\;mr %L0,%L1\";
5931     case 1:
5932       /* If the low-address word is used in the address, we must load it
5933          last.  Otherwise, load it first.  Note that we cannot have
5934          auto-increment in that case since the address register is known to be
5935          dead.  */
5936       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5937                              operands [1], 0))
5938         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5939       else
5940         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5941     case 2:
5942       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5943     case 3:
5944       return \"fmr %0,%1\";
5945     case 4:
5946       return \"lfd%U1%X1 %0,%1\";
5947     case 5:
5948       return \"stfd%U0%X0 %1,%0\";
5949     case 6:
5950     case 7:
5951     case 8:
5952     case 9:
5953     case 10:
5954       return \"#\";
5955     }
5956 }"
5957   [(set_attr "type" "*,load,store,fp,fpload,fpstore,*,*,*,*,*")
5958    (set_attr "length" "8,8,8,*,*,*,8,12,8,12,16")])
5959
5960 (define_split
5961   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5962         (match_operand:DI 1 "const_int_operand" ""))]
5963   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) <= 1"
5964   [(set (match_dup 2) (match_dup 4))
5965    (set (match_dup 3) (match_dup 1))]
5966   "
5967 {
5968   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5969   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5970   operands[4] = (INTVAL (operands[1]) & 0x80000000) ? constm1_rtx : const0_rtx;
5971 }")
5972
5973 (define_split
5974   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5975         (match_operand:DI 1 "const_int_operand" ""))]
5976   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) >= 2"
5977   [(set (match_dup 3) (match_dup 5))
5978    (set (match_dup 2) (match_dup 4))
5979    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 6)))]
5980   "
5981 {
5982   HOST_WIDE_INT value = INTVAL (operands[1]);
5983   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5984   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5985   operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
5986   operands[5] = GEN_INT (value & 0xffff0000);
5987   operands[6] = GEN_INT (value & 0x0000ffff);
5988 }")
5989
5990 (define_split
5991   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5992         (match_operand:DI 1 "const_double_operand" ""))]
5993   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) <= 2"
5994   [(set (match_dup 2) (match_dup 4))
5995    (set (match_dup 3) (match_dup 5))]
5996   "
5997 {
5998   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5999   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
6000   operands[4] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
6001   operands[5] = GEN_INT (CONST_DOUBLE_LOW  (operands[1]));
6002 }")
6003
6004 (define_split
6005   [(set (match_operand:DI 0 "gpc_reg_operand" "")
6006         (match_operand:DI 1 "const_double_operand" ""))]
6007   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) == 3"
6008   [(set (match_dup 2) (match_dup 4))
6009    (set (match_dup 3) (match_dup 5))
6010    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))]
6011   "
6012 {
6013   HOST_WIDE_INT high = CONST_DOUBLE_HIGH (operands[1]);
6014   HOST_WIDE_INT low  = CONST_DOUBLE_LOW  (operands[1]);
6015   rtx high_reg = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
6016   rtx low_reg  = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
6017
6018   if (((unsigned HOST_WIDE_INT) (low + 0x8000) < 0x10000)
6019       || (low & 0xffff) == 0)
6020     {
6021       operands[2] = high_reg;
6022       operands[3] = low_reg;
6023       operands[4] = GEN_INT (high & 0xffff0000);
6024       operands[5] = GEN_INT (low);
6025       operands[6] = GEN_INT (high & 0x0000ffff);
6026     }
6027   else
6028     {
6029       operands[2] = low_reg;
6030       operands[3] = high_reg;
6031       operands[4] = GEN_INT (low & 0xffff0000);
6032       operands[5] = GEN_INT (high);
6033       operands[6] = GEN_INT (low & 0x0000ffff);
6034     }
6035 }")
6036
6037 (define_split
6038   [(set (match_operand:DI 0 "gpc_reg_operand" "")
6039         (match_operand:DI 1 "const_double_operand" ""))]
6040   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) >= 4"
6041   [(set (match_dup 2) (match_dup 4))
6042    (set (match_dup 3) (match_dup 5))
6043    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))
6044    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 7)))]
6045   "
6046 {
6047   HOST_WIDE_INT high = CONST_DOUBLE_HIGH (operands[1]);
6048   HOST_WIDE_INT low  = CONST_DOUBLE_LOW  (operands[1]);
6049
6050   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
6051   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
6052   operands[4] = GEN_INT (high & 0xffff0000);
6053   operands[5] = GEN_INT (low  & 0xffff0000);
6054   operands[6] = GEN_INT (high & 0x0000ffff);
6055   operands[7] = GEN_INT (low  & 0x0000ffff);
6056 }")
6057
6058 (define_insn "*movdi_64"
6059   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,f,f,m,r,*h,*h")
6060         (match_operand:DI 1 "input_operand" "r,m,r,I,J,nF,R,f,m,f,*h,r,0"))]
6061   "TARGET_64BIT
6062    && (gpc_reg_operand (operands[0], DImode)
6063        || gpc_reg_operand (operands[1], DImode))"
6064   "@
6065    mr %0,%1
6066    ld%U1%X1 %0,%1
6067    std%U0%X0 %1,%0
6068    li %0,%1
6069    lis %0,%v1
6070    #
6071    {cal|la} %0,%1(%*)
6072    fmr %0,%1
6073    lfd%U1%X1 %0,%1
6074    stfd%U0%X0 %1,%0
6075    mf%1 %0
6076    mt%0 %1
6077    cror 0,0,0"
6078   [(set_attr "type" "*,load,store,*,*,*,*,fp,fpload,fpstore,*,mtjmpr,*")
6079    (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4")])
6080
6081 ;; Split a load of a large constant into the appropriate five-instruction
6082 ;; sequence.  The expansion in movdi tries to perform the minimum number of
6083 ;; steps, but here we have to handle anything in a constant number of insns.
6084
6085 (define_split
6086   [(set (match_operand:DI 0 "gpc_reg_operand" "")
6087         (match_operand:DI 1 "const_double_operand" ""))]
6088   "TARGET_64BIT && num_insns_constant (operands[1], DImode) > 1"
6089   [(set (match_dup 0)
6090         (match_dup 2))
6091    (set (match_dup 0)
6092         (ior:DI (match_dup 0)
6093                 (match_dup 3)))
6094    (set (match_dup 0)
6095         (ashift:DI (match_dup 0)
6096                    (const_int 32)))
6097    (set (match_dup 0)
6098         (ior:DI (match_dup 0)
6099                 (match_dup 4)))
6100    (set (match_dup 0)
6101         (ior:DI (match_dup 0)
6102                 (match_dup 5)))]
6103   "
6104 {
6105   HOST_WIDE_INT low;
6106   HOST_WIDE_INT high;
6107
6108   if (GET_CODE (operands[1]) == CONST_DOUBLE)
6109     {
6110       low = CONST_DOUBLE_LOW (operands[1]);
6111       high = CONST_DOUBLE_HIGH (operands[1]);
6112     }
6113   else
6114 #if HOST_BITS_PER_WIDE_INT == 32
6115     {
6116       low = INTVAL (operands[1]);
6117       high = (low < 0) ? ~0 : 0;
6118     }
6119 #else
6120     {
6121       low = INTVAL (operands[1]) & 0xffffffff;
6122       high = (HOST_WIDE_INT) INTVAL (operands[1]) >> 32;
6123     }
6124 #endif
6125
6126   if ((high + 0x8000) < 0x10000
6127       && ((low & 0xffff) == 0 || (low & (~ (HOST_WIDE_INT) 0xffff)) == 0))
6128     FAIL;
6129
6130   operands[2] = GEN_INT (high & (~ (HOST_WIDE_INT) 0xffff));
6131   operands[3] = GEN_INT (high & 0xffff);
6132   operands[4] = GEN_INT (low & (~ (HOST_WIDE_INT) 0xffff));
6133   operands[5] = GEN_INT (low & 0xffff);
6134 }")
6135
6136 (define_insn ""
6137   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
6138         (compare:CC (match_operand:DI 1 "gpc_reg_operand" "r")
6139                     (const_int 0)))
6140    (set (match_operand:DI 0 "gpc_reg_operand" "=r") (match_dup 1))]
6141   "TARGET_POWERPC64"
6142   "mr. %0,%1"
6143   [(set_attr "type" "compare")])
6144 \f
6145 ;; TImode is similar, except that we usually want to compute the address into
6146 ;; a register and use lsi/stsi (the exception is during reload).  MQ is also
6147 ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
6148 (define_expand "movti"
6149   [(parallel [(set (match_operand:TI 0 "general_operand" "")
6150                    (match_operand:TI 1 "general_operand" ""))
6151               (clobber (scratch:SI))])]
6152   "TARGET_STRING || TARGET_POWERPC64"
6153   "
6154 {
6155   if (GET_CODE (operands[0]) == MEM)
6156     operands[1] = force_reg (TImode, operands[1]);
6157
6158   if (GET_CODE (operands[0]) == MEM
6159       && GET_CODE (XEXP (operands[0], 0)) != REG
6160       && ! reload_in_progress)
6161     operands[0] = change_address (operands[0], TImode,
6162                                   copy_addr_to_reg (XEXP (operands[0], 0)));
6163
6164   if (GET_CODE (operands[1]) == MEM
6165       && GET_CODE (XEXP (operands[1], 0)) != REG
6166       && ! reload_in_progress)
6167     operands[1] = change_address (operands[1], TImode,
6168                                   copy_addr_to_reg (XEXP (operands[1], 0)));
6169 }")
6170
6171 ;; We say that MQ is clobbered in the last alternative because the first
6172 ;; alternative would never get used otherwise since it would need a reload
6173 ;; while the 2nd alternative would not.  We put memory cases first so they
6174 ;; are preferred.  Otherwise, we'd try to reload the output instead of
6175 ;; giving the SCRATCH mq.
6176 (define_insn ""
6177   [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,????r,????r,????r")
6178         (match_operand:TI 1 "reg_or_mem_operand" "r,r,r,Q,m"))
6179    (clobber (match_scratch:SI 2 "=q,q#X,X,X,X"))]
6180   "TARGET_STRING && TARGET_POWER && ! TARGET_POWERPC64
6181    && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
6182   "*
6183 {
6184   switch (which_alternative)
6185     {
6186     default:
6187       abort ();
6188
6189     case 0:
6190       return \"{stsi|stswi} %1,%P0,16\";
6191
6192     case 1:
6193       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
6194
6195     case 2:
6196       /* Normally copy registers with lowest numbered register copied first.
6197          But copy in the other order if the first register of the output
6198          is the second, third, or fourth register in the input.  */
6199       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
6200           && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
6201         return \"mr %Z0,%Z1\;mr %Y0,%Y1\;mr %L0,%L1\;mr %0,%1\";
6202       else
6203         return \"mr %0,%1\;mr %L0,%L1\;mr %Y0,%Y1\;mr %Z0,%Z1\";
6204     case 3:
6205       /* If the address is not used in the output, we can use lsi.  Otherwise,
6206          fall through to generating four loads.  */
6207       if (! reg_overlap_mentioned_p (operands[0], operands[1]))
6208         return \"{lsi|lswi} %0,%P1,16\";
6209       /* ... fall through ... */
6210     case 4:
6211       /* If the address register is the same as the register for the lowest-
6212          addressed word, load it last.  Similarly for the next two words.
6213          Otherwise load lowest address to highest.  */
6214       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6215                              operands[1], 0))
6216         return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
6217       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
6218                                   REGNO (operands[0]) + 2, operands[1], 0))
6219         return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
6220       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
6221                                   REGNO (operands[0]) + 3, operands[1], 0))
6222         return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
6223       else
6224         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
6225     }
6226 }"
6227   [(set_attr "type" "store,store,*,load,load")
6228    (set_attr "length" "*,16,16,*,16")])
6229
6230 (define_insn ""
6231   [(set (match_operand:TI 0 "reg_or_mem_operand" "=m,????r,????r")
6232         (match_operand:TI 1 "reg_or_mem_operand" "r,r,m"))
6233    (clobber (match_scratch:SI 2 "=X,X,X"))]
6234   "TARGET_STRING && !TARGET_POWER && ! TARGET_POWERPC64
6235    && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
6236   "*
6237 {
6238   switch (which_alternative)
6239     {
6240     default:
6241       abort ();
6242
6243     case 0:
6244       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
6245
6246     case 1:
6247       /* Normally copy registers with lowest numbered register copied first.
6248          But copy in the other order if the first register of the output
6249          is the second, third, or fourth register in the input.  */
6250       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
6251           && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
6252         return \"mr %Z0,%Z1\;mr %Y0,%Y1\;mr %L0,%L1\;mr %0,%1\";
6253       else
6254         return \"mr %0,%1\;mr %L0,%L1\;mr %Y0,%Y1\;mr %Z0,%Z1\";
6255     case 2:
6256       /* If the address register is the same as the register for the lowest-
6257          addressed word, load it last.  Similarly for the next two words.
6258          Otherwise load lowest address to highest.  */
6259       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6260                              operands[1], 0))
6261         return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
6262       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
6263                                   REGNO (operands[0]) + 2, operands[1], 0))
6264         return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
6265       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
6266                                   REGNO (operands[0]) + 3, operands[1], 0))
6267         return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
6268       else
6269         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
6270     }
6271 }"
6272   [(set_attr "type" "store,*,load")
6273    (set_attr "length" "16,16,16")])
6274
6275 (define_insn ""
6276   [(set (match_operand:TI 0 "nonimmediate_operand" "=r,r,m")
6277         (match_operand:TI 1 "input_operand" "r,m,r"))]
6278   "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
6279    || gpc_reg_operand (operands[1], TImode))"
6280   "*
6281 {
6282   switch (which_alternative)
6283     {
6284     case 0:
6285       /* We normally copy the low-numbered register first.  However, if
6286          the first register operand 0 is the same as the second register of
6287          operand 1, we must copy in the opposite order.  */
6288       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
6289         return \"mr %L0,%L1\;mr %0,%1\";
6290       else
6291         return \"mr %0,%1\;mr %L0,%L1\";
6292     case 1:
6293       /* If the low-address word is used in the address, we must load it
6294          last.  Otherwise, load it first.  Note that we cannot have
6295          auto-increment in that case since the address register is known to be
6296          dead.  */
6297       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6298                              operands [1], 0))
6299         return \"ld %L0,%L1\;ld %0,%1\";
6300       else
6301         return \"ld%U1 %0,%1\;ld %L0,%L1\";
6302     case 2:
6303       return \"std%U0 %1,%0\;std %L1,%L0\";
6304     }
6305 }"
6306   [(set_attr "type" "*,load,store")
6307    (set_attr "length" "8,8,8")])
6308 \f
6309 (define_expand "load_multiple"
6310   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
6311                           (match_operand:SI 1 "" ""))
6312                      (use (match_operand:SI 2 "" ""))])]
6313   "TARGET_STRING"
6314   "
6315 {
6316   int regno;
6317   int count;
6318   rtx from;
6319   int i;
6320
6321   /* Support only loading a constant number of fixed-point registers from
6322      memory and only bother with this if more than two; the machine
6323      doesn't support more than eight.  */
6324   if (GET_CODE (operands[2]) != CONST_INT
6325       || INTVAL (operands[2]) <= 2
6326       || INTVAL (operands[2]) > 8
6327       || GET_CODE (operands[1]) != MEM
6328       || GET_CODE (operands[0]) != REG
6329       || REGNO (operands[0]) >= 32)
6330     FAIL;
6331
6332   count = INTVAL (operands[2]);
6333   regno = REGNO (operands[0]);
6334
6335   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count));
6336   from = force_reg (SImode, XEXP (operands[1], 0));
6337
6338   for (i = 0; i < count; i++)
6339     XVECEXP (operands[3], 0, i)
6340       = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
6341                  change_address (operands[1], SImode,
6342                                  plus_constant (from, i * 4)));
6343 }")
6344
6345 (define_insn ""
6346   [(match_parallel 0 "load_multiple_operation"
6347                    [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
6348                          (mem:SI (match_operand:SI 2 "register_operand" "b")))])]
6349   "TARGET_STRING"
6350   "*
6351 {
6352   /* We have to handle the case where the pseudo used to contain the address
6353      is assigned to one of the output registers.  */
6354   int i, j;
6355   int words = XVECLEN (operands[0], 0);
6356   rtx xop[10];
6357
6358   if (XVECLEN (operands[0], 0) == 1)
6359     return \"{l|lwz} %1,0(%2)\";
6360
6361   for (i = 0; i < words; i++)
6362     if (refers_to_regno_p (REGNO (operands[1]) + i,
6363                            REGNO (operands[1]) + i + 1, operands[2], 0))
6364       {
6365         if (i == words-1)
6366           {
6367             xop[0] = operands[1];
6368             xop[1] = operands[2];
6369             xop[2] = GEN_INT (4 * (words-1));
6370             output_asm_insn (\"{lsi|lswi} %0,%1,%2\;{l|lwz} %1,%2(%1)\", xop);
6371             return \"\";
6372           }
6373         else if (i == 0)
6374           {
6375             xop[0] = operands[1];
6376             xop[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
6377             xop[2] = GEN_INT (4 * (words-1));
6378             output_asm_insn (\"{cal %0,4(%0)|addi %0,%0,4}\;{lsi|lswi} %1,%0,%2\;{l|lwz} %0,-4(%0)\", xop);
6379             return \"\";
6380           }
6381         else
6382           {
6383             for (j = 0; j < words; j++)
6384               if (j != i)
6385                 {
6386                   xop[0] = gen_rtx (REG, SImode, REGNO (operands[1]) + j);
6387                   xop[1] = operands[2];
6388                   xop[2] = GEN_INT (j * 4);
6389                   output_asm_insn (\"{l|lwz} %0,%2(%1)\", xop);
6390                 }
6391             xop[0] = operands[2];
6392             xop[1] = GEN_INT (i * 4);
6393             output_asm_insn (\"{l|lwz} %0,%1(%0)\", xop);
6394             return \"\";
6395           }
6396       }
6397
6398   return \"{lsi|lswi} %1,%2,%N0\";
6399 }"
6400   [(set_attr "type" "load")
6401    (set_attr "length" "32")])
6402
6403 \f
6404 (define_expand "store_multiple"
6405   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
6406                           (match_operand:SI 1 "" ""))
6407                      (clobber (scratch:SI))
6408                      (use (match_operand:SI 2 "" ""))])]
6409   "TARGET_STRING"
6410   "
6411 {
6412   int regno;
6413   int count;
6414   rtx to;
6415   int i;
6416
6417   /* Support only storing a constant number of fixed-point registers to
6418      memory and only bother with this if more than two; the machine
6419      doesn't support more than eight.  */
6420   if (GET_CODE (operands[2]) != CONST_INT
6421       || INTVAL (operands[2]) <= 2
6422       || INTVAL (operands[2]) > 8
6423       || GET_CODE (operands[0]) != MEM
6424       || GET_CODE (operands[1]) != REG
6425       || REGNO (operands[1]) >= 32)
6426     FAIL;
6427
6428   count = INTVAL (operands[2]);
6429   regno = REGNO (operands[1]);
6430
6431   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
6432   to = force_reg (SImode, XEXP (operands[0], 0));
6433
6434   XVECEXP (operands[3], 0, 0)
6435     = gen_rtx (SET, VOIDmode, change_address (operands[0], SImode, to),
6436                operands[1]);
6437   XVECEXP (operands[3], 0, 1) = gen_rtx (CLOBBER, VOIDmode,
6438                                                   gen_rtx (SCRATCH, SImode));
6439
6440   for (i = 1; i < count; i++)
6441     XVECEXP (operands[3], 0, i + 1)
6442       = gen_rtx (SET, VOIDmode,
6443                  change_address (operands[0], SImode,
6444                                  plus_constant (to, i * 4)),
6445                  gen_rtx (REG, SImode, regno + i));
6446 }")
6447
6448 (define_insn ""
6449   [(match_parallel 0 "store_multiple_operation"
6450                    [(set (match_operand:SI 1 "indirect_operand" "=Q")
6451                          (match_operand:SI 2 "gpc_reg_operand" "r"))
6452                     (clobber (match_scratch:SI 3 "=q"))])]
6453   "TARGET_STRING && TARGET_POWER"
6454   "{stsi|stswi} %2,%P1,%O0"
6455   [(set_attr "type" "store")])
6456
6457 (define_insn ""
6458   [(match_parallel 0 "store_multiple_operation"
6459                    [(set (mem:SI (match_operand:SI 1 "register_operand" "b"))
6460                          (match_operand:SI 2 "gpc_reg_operand" "r"))
6461                     (clobber (match_scratch:SI 3 "X"))])]
6462   "TARGET_STRING && !TARGET_POWER"
6463   "{stsi|stswi} %2,%1,%O0"
6464   [(set_attr "type" "store")])
6465
6466 \f
6467 ;; String/block move insn.
6468 ;; Argument 0 is the destination
6469 ;; Argument 1 is the source
6470 ;; Argument 2 is the length
6471 ;; Argument 3 is the alignment
6472
6473 (define_expand "movstrsi"
6474   [(parallel [(set (match_operand:BLK 0 "" "")
6475                    (match_operand:BLK 1 "" ""))
6476               (use (match_operand:SI 2 "" ""))
6477               (use (match_operand:SI 3 "" ""))])]
6478   ""
6479   "
6480 {
6481   if (expand_block_move (operands))
6482     DONE;
6483   else
6484     FAIL;
6485 }")
6486
6487 ;; Move up to 32 bytes at a time.  The fixed registers are needed because the
6488 ;; register allocator doesn't have a clue about allocating 8 word registers
6489 (define_expand "movstrsi_8reg"
6490   [(parallel [(set (match_operand 0 "" "")
6491                    (match_operand 1 "" ""))
6492               (use (match_operand 2 "" ""))
6493               (use (match_operand 3 "" ""))
6494               (clobber (reg:SI  5))
6495               (clobber (reg:SI  6))
6496               (clobber (reg:SI  7))
6497               (clobber (reg:SI  8))
6498               (clobber (reg:SI  9))
6499               (clobber (reg:SI 10))
6500               (clobber (reg:SI 11))
6501               (clobber (reg:SI 12))
6502               (clobber (match_scratch:SI 4 ""))])]
6503   "TARGET_STRING"
6504   "")
6505
6506 (define_insn ""
6507   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6508         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6509    (use (match_operand:SI 2 "immediate_operand" "i"))
6510    (use (match_operand:SI 3 "immediate_operand" "i"))
6511    (clobber (match_operand:SI 4 "register_operand" "=r"))
6512    (clobber (reg:SI  6))
6513    (clobber (reg:SI  7))
6514    (clobber (reg:SI  8))
6515    (clobber (reg:SI  9))
6516    (clobber (reg:SI 10))
6517    (clobber (reg:SI 11))
6518    (clobber (reg:SI 12))
6519    (clobber (match_scratch:SI 5 "=q"))]
6520   "TARGET_STRING && TARGET_POWER
6521    && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32) || INTVAL (operands[2]) == 0)
6522    && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
6523    && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
6524    && REGNO (operands[4]) == 5"
6525   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6526   [(set_attr "type" "load")
6527    (set_attr "length" "8")])
6528
6529 (define_insn ""
6530   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6531         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6532    (use (match_operand:SI 2 "immediate_operand" "i"))
6533    (use (match_operand:SI 3 "immediate_operand" "i"))
6534    (clobber (match_operand:SI 4 "register_operand" "=r"))
6535    (clobber (reg:SI  6))
6536    (clobber (reg:SI  7))
6537    (clobber (reg:SI  8))
6538    (clobber (reg:SI  9))
6539    (clobber (reg:SI 10))
6540    (clobber (reg:SI 11))
6541    (clobber (reg:SI 12))
6542    (clobber (match_scratch:SI 5 "X"))]
6543   "TARGET_STRING && !TARGET_POWER
6544    && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32) || INTVAL (operands[2]) == 0)
6545    && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
6546    && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
6547    && REGNO (operands[4]) == 5"
6548   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6549   [(set_attr "type" "load")
6550    (set_attr "length" "8")])
6551
6552 ;; Move up to 24 bytes at a time.  The fixed registers are needed because the
6553 ;; register allocator doesn't have a clue about allocating 6 word registers
6554 (define_expand "movstrsi_6reg"
6555   [(parallel [(set (match_operand 0 "" "")
6556                    (match_operand 1 "" ""))
6557               (use (match_operand 2 "" ""))
6558               (use (match_operand 3 "" ""))
6559               (clobber (reg:SI  7))
6560               (clobber (reg:SI  8))
6561               (clobber (reg:SI  9))
6562               (clobber (reg:SI 10))
6563               (clobber (reg:SI 11))
6564               (clobber (reg:SI 12))
6565               (clobber (match_scratch:SI 4 ""))])]
6566   "TARGET_STRING"
6567   "")
6568
6569 (define_insn ""
6570   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6571         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6572    (use (match_operand:SI 2 "immediate_operand" "i"))
6573    (use (match_operand:SI 3 "immediate_operand" "i"))
6574    (clobber (match_operand:SI 4 "register_operand" "=r"))
6575    (clobber (reg:SI  8))
6576    (clobber (reg:SI  9))
6577    (clobber (reg:SI 10))
6578    (clobber (reg:SI 11))
6579    (clobber (reg:SI 12))
6580    (clobber (match_scratch:SI 5 "=q"))]
6581   "TARGET_STRING && TARGET_POWER
6582    && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 24
6583    && (REGNO (operands[0]) < 7 || REGNO (operands[0]) > 12)
6584    && (REGNO (operands[1]) < 7 || REGNO (operands[1]) > 12)
6585    && REGNO (operands[4]) == 7"
6586   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6587   [(set_attr "type" "load")
6588    (set_attr "length" "8")])
6589
6590 (define_insn ""
6591   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6592         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6593    (use (match_operand:SI 2 "immediate_operand" "i"))
6594    (use (match_operand:SI 3 "immediate_operand" "i"))
6595    (clobber (match_operand:SI 4 "register_operand" "=r"))
6596    (clobber (reg:SI  8))
6597    (clobber (reg:SI  9))
6598    (clobber (reg:SI 10))
6599    (clobber (reg:SI 11))
6600    (clobber (reg:SI 12))
6601    (clobber (match_scratch:SI 5 "X"))]
6602   "TARGET_STRING && !TARGET_POWER
6603    && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 32
6604    && (REGNO (operands[0]) < 7 || REGNO (operands[0]) > 12)
6605    && (REGNO (operands[1]) < 7 || REGNO (operands[1]) > 12)
6606    && REGNO (operands[4]) == 7"
6607   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6608   [(set_attr "type" "load")
6609    (set_attr "length" "8")])
6610
6611 ;; Move up to 16 bytes at a time, using 4 fixed registers to avoid spill problems
6612 ;; with TImode
6613 (define_expand "movstrsi_4reg"
6614   [(parallel [(set (match_operand 0 "" "")
6615                    (match_operand 1 "" ""))
6616               (use (match_operand 2 "" ""))
6617               (use (match_operand 3 "" ""))
6618               (clobber (reg:SI  9))
6619               (clobber (reg:SI 10))
6620               (clobber (reg:SI 11))
6621               (clobber (reg:SI 12))
6622               (clobber (match_scratch:SI 4 ""))])]
6623   "TARGET_STRING"
6624   "")
6625
6626 (define_insn ""
6627   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6628         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6629    (use (match_operand:SI 2 "immediate_operand" "i"))
6630    (use (match_operand:SI 3 "immediate_operand" "i"))
6631    (clobber (match_operand:SI 4 "register_operand" "=r"))
6632    (clobber (reg:SI 10))
6633    (clobber (reg:SI 11))
6634    (clobber (reg:SI 12))
6635    (clobber (match_scratch:SI 5 "=q"))]
6636   "TARGET_STRING && TARGET_POWER
6637    && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
6638    && (REGNO (operands[0]) < 9 || REGNO (operands[0]) > 12)
6639    && (REGNO (operands[1]) < 9 || REGNO (operands[1]) > 12)
6640    && REGNO (operands[4]) == 9"
6641   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6642   [(set_attr "type" "load")
6643    (set_attr "length" "8")])
6644
6645 (define_insn ""
6646   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6647         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6648    (use (match_operand:SI 2 "immediate_operand" "i"))
6649    (use (match_operand:SI 3 "immediate_operand" "i"))
6650    (clobber (match_operand:SI 4 "register_operand" "=r"))
6651    (clobber (reg:SI 10))
6652    (clobber (reg:SI 11))
6653    (clobber (reg:SI 12))
6654    (clobber (match_scratch:SI 5 "X"))]
6655   "TARGET_STRING && !TARGET_POWER
6656    && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
6657    && (REGNO (operands[0]) < 9 || REGNO (operands[0]) > 12)
6658    && (REGNO (operands[1]) < 9 || REGNO (operands[1]) > 12)
6659    && REGNO (operands[4]) == 9"
6660   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6661   [(set_attr "type" "load")
6662    (set_attr "length" "8")])
6663
6664 ;; Move up to 8 bytes at a time.
6665 (define_expand "movstrsi_2reg"
6666   [(parallel [(set (match_operand 0 "" "")
6667                    (match_operand 1 "" ""))
6668               (use (match_operand 2 "" ""))
6669               (use (match_operand 3 "" ""))
6670               (clobber (match_scratch:DI 4 ""))
6671               (clobber (match_scratch:SI 5 ""))])]
6672   "TARGET_STRING && !TARGET_64BIT"
6673   "")
6674
6675 (define_insn ""
6676   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6677         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6678    (use (match_operand:SI 2 "immediate_operand" "i"))
6679    (use (match_operand:SI 3 "immediate_operand" "i"))
6680    (clobber (match_scratch:DI 4 "=&r"))
6681    (clobber (match_scratch:SI 5 "=q"))]
6682   "TARGET_STRING && TARGET_POWER && !TARGET_64BIT
6683    && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
6684   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6685   [(set_attr "type" "load")
6686    (set_attr "length" "8")])
6687
6688 (define_insn ""
6689   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6690         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6691    (use (match_operand:SI 2 "immediate_operand" "i"))
6692    (use (match_operand:SI 3 "immediate_operand" "i"))
6693    (clobber (match_scratch:DI 4 "=&r"))
6694    (clobber (match_scratch:SI 5 "X"))]
6695   "TARGET_STRING && !TARGET_POWER && !TARGET_64BIT
6696    && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
6697   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6698   [(set_attr "type" "load")
6699    (set_attr "length" "8")])
6700
6701 ;; Move up to 4 bytes at a time.
6702 (define_expand "movstrsi_1reg"
6703   [(parallel [(set (match_operand 0 "" "")
6704                    (match_operand 1 "" ""))
6705               (use (match_operand 2 "" ""))
6706               (use (match_operand 3 "" ""))
6707               (clobber (match_scratch:SI 4 ""))
6708               (clobber (match_scratch:SI 5 ""))])]
6709   "TARGET_STRING"
6710   "")
6711
6712 (define_insn ""
6713   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6714         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6715    (use (match_operand:SI 2 "immediate_operand" "i"))
6716    (use (match_operand:SI 3 "immediate_operand" "i"))
6717    (clobber (match_scratch:SI 4 "=&r"))
6718    (clobber (match_scratch:SI 5 "=q"))]
6719   "TARGET_STRING && TARGET_POWER
6720    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
6721   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6722   [(set_attr "type" "load")
6723    (set_attr "length" "8")])
6724
6725 (define_insn ""
6726   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6727         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6728    (use (match_operand:SI 2 "immediate_operand" "i"))
6729    (use (match_operand:SI 3 "immediate_operand" "i"))
6730    (clobber (match_scratch:SI 4 "=&r"))
6731    (clobber (match_scratch:SI 5 "X"))]
6732   "TARGET_STRING && !TARGET_POWER
6733    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
6734   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6735   [(set_attr "type" "load")
6736    (set_attr "length" "8")])
6737
6738 \f
6739 ;; Define insns that do load or store with update.  Some of these we can
6740 ;; get by using pre-decrement or pre-increment, but the hardware can also
6741 ;; do cases where the increment is not the size of the object.
6742 ;;
6743 ;; In all these cases, we use operands 0 and 1 for the register being
6744 ;; incremented because those are the operands that local-alloc will
6745 ;; tie and these are the pair most likely to be tieable (and the ones
6746 ;; that will benefit the most).
6747
6748 (define_insn ""
6749   [(set (match_operand:DI 3 "gpc_reg_operand" "=r,r")
6750         (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
6751                          (match_operand:DI 2 "reg_or_short_operand" "r,I"))))
6752    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
6753         (plus:DI (match_dup 1) (match_dup 2)))]
6754   "TARGET_POWERPC64"
6755   "@
6756    ldux %3,%0,%2
6757    ldu %3,%2(%0)"
6758   [(set_attr "type" "load")])
6759
6760 (define_insn ""
6761   [(set (match_operand:DI 3 "gpc_reg_operand" "=r")
6762         (sign_extend:DI
6763          (mem:SI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0")
6764                           (match_operand:DI 2 "gpc_reg_operand" "r")))))
6765    (set (match_operand:DI 0 "gpc_reg_operand" "=b")
6766         (plus:DI (match_dup 1) (match_dup 2)))]
6767   "TARGET_POWERPC64"
6768   "lwaux %3,%0,%2"
6769   [(set_attr "type" "load")])
6770
6771 (define_insn "movdi_update"
6772   [(set (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
6773                          (match_operand:DI 2 "reg_or_short_operand" "r,I")))
6774         (match_operand:DI 3 "gpc_reg_operand" "r,r"))
6775    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
6776         (plus:DI (match_dup 1) (match_dup 2)))]
6777   "TARGET_POWERPC64"
6778   "@
6779    stdux %3,%0,%2
6780    stdu %3,%2(%0)"
6781   [(set_attr "type" "store")])
6782
6783 (define_insn ""
6784   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6785         (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6786                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6787    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6788         (plus:SI (match_dup 1) (match_dup 2)))]
6789   ""
6790   "@
6791    {lux|lwzux} %3,%0,%2
6792    {lu|lwzu} %3,%2(%0)"
6793   [(set_attr "type" "load")])
6794
6795 (define_insn "movsi_update"
6796   [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6797                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6798         (match_operand:SI 3 "gpc_reg_operand" "r,r"))
6799    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6800         (plus:SI (match_dup 1) (match_dup 2)))]
6801   ""
6802   "@
6803    {stux|stwux} %3,%0,%2
6804    {stu|stwu} %3,%2(%0)"
6805   [(set_attr "type" "store")])
6806
6807 (define_insn ""
6808   [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
6809         (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6810                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6811    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6812         (plus:SI (match_dup 1) (match_dup 2)))]
6813   ""
6814   "@
6815    lhzux %3,%0,%2
6816    lhzu %3,%2(%0)"
6817   [(set_attr "type" "load")])
6818
6819 (define_insn ""
6820   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6821         (zero_extend:SI
6822          (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6823                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6824    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6825         (plus:SI (match_dup 1) (match_dup 2)))]
6826   ""
6827   "@
6828    lhzux %3,%0,%2
6829    lhzu %3,%2(%0)"
6830   [(set_attr "type" "load")])
6831
6832 (define_insn ""
6833   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6834         (sign_extend:SI
6835          (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6836                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6837    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6838         (plus:SI (match_dup 1) (match_dup 2)))]
6839   ""
6840   "@
6841    lhaux %3,%0,%2
6842    lhau %3,%2(%0)"
6843   [(set_attr "type" "load")])
6844
6845 (define_insn ""
6846   [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6847                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6848         (match_operand:HI 3 "gpc_reg_operand" "r,r"))
6849    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6850         (plus:SI (match_dup 1) (match_dup 2)))]
6851   ""
6852   "@
6853    sthux %3,%0,%2
6854    sthu %3,%2(%0)"
6855   [(set_attr "type" "store")])
6856
6857 (define_insn ""
6858   [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
6859         (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6860                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6861    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6862         (plus:SI (match_dup 1) (match_dup 2)))]
6863   ""
6864   "@
6865    lbzux %3,%0,%2
6866    lbzu %3,%2(%0)"
6867   [(set_attr "type" "load")])
6868
6869 (define_insn ""
6870   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6871         (zero_extend:SI
6872          (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6873                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6874    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6875         (plus:SI (match_dup 1) (match_dup 2)))]
6876   ""
6877   "@
6878    lbzux %3,%0,%2
6879    lbzu %3,%2(%0)"
6880   [(set_attr "type" "load")])
6881
6882 (define_insn ""
6883   [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6884                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6885         (match_operand:QI 3 "gpc_reg_operand" "r,r"))
6886    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6887         (plus:SI (match_dup 1) (match_dup 2)))]
6888   ""
6889   "@
6890    stbux %3,%0,%2
6891    stbu %3,%2(%0)"
6892   [(set_attr "type" "store")])
6893
6894 (define_insn ""
6895   [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
6896         (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6897                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6898    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6899         (plus:SI (match_dup 1) (match_dup 2)))]
6900   "TARGET_HARD_FLOAT"
6901   "@
6902    lfsux %3,%0,%2
6903    lfsu %3,%2(%0)"
6904   [(set_attr "type" "fpload")])
6905
6906 (define_insn ""
6907   [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6908                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6909         (match_operand:SF 3 "gpc_reg_operand" "f,f"))
6910    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6911         (plus:SI (match_dup 1) (match_dup 2)))]
6912   "TARGET_HARD_FLOAT"
6913   "@
6914    stfsux %3,%0,%2
6915    stfsu %3,%2(%0)"
6916   [(set_attr "type" "fpstore")])
6917
6918 (define_insn ""
6919   [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
6920         (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6921                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6922    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6923         (plus:SI (match_dup 1) (match_dup 2)))]
6924   "TARGET_HARD_FLOAT"
6925   "@
6926    lfdux %3,%0,%2
6927    lfdu %3,%2(%0)"
6928   [(set_attr "type" "fpload")])
6929
6930 (define_insn ""
6931   [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6932                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6933         (match_operand:DF 3 "gpc_reg_operand" "f,f"))
6934    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6935         (plus:SI (match_dup 1) (match_dup 2)))]
6936   "TARGET_HARD_FLOAT"
6937   "@
6938    stfdux %3,%0,%2
6939    stfdu %3,%2(%0)"
6940   [(set_attr "type" "fpstore")])
6941
6942 ;; Peephole to convert two consecutive FP loads or stores into lfq/stfq.
6943
6944 (define_peephole
6945   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6946         (match_operand:DF 1 "memory_operand" ""))
6947    (set (match_operand:DF 2 "gpc_reg_operand" "=f")
6948         (match_operand:DF 3 "memory_operand" ""))]
6949   "TARGET_POWER2
6950    && TARGET_HARD_FLOAT
6951    && registers_ok_for_quad_peep (operands[0], operands[2])
6952    && ! MEM_VOLATILE_P (operands[1]) && ! MEM_VOLATILE_P (operands[3])
6953    && addrs_ok_for_quad_peep (XEXP (operands[1], 0), XEXP (operands[3], 0))"
6954   "lfq%U1%X1 %0,%1")
6955
6956 (define_peephole
6957   [(set (match_operand:DF 0 "memory_operand" "")
6958         (match_operand:DF 1 "gpc_reg_operand" "f"))
6959    (set (match_operand:DF 2 "memory_operand" "")
6960         (match_operand:DF 3 "gpc_reg_operand" "f"))]
6961   "TARGET_POWER2
6962    && TARGET_HARD_FLOAT
6963    && registers_ok_for_quad_peep (operands[1], operands[3])
6964    && ! MEM_VOLATILE_P (operands[0]) && ! MEM_VOLATILE_P (operands[2])
6965    && addrs_ok_for_quad_peep (XEXP (operands[0], 0), XEXP (operands[2], 0))"
6966   "stfq%U0%X0 %1,%0")
6967 \f
6968 ;; Next come insns related to the calling sequence.
6969 ;;
6970 ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
6971 ;; We move the back-chain and decrement the stack pointer.
6972
6973 (define_expand "allocate_stack"
6974   [(set (reg:SI 1)
6975         (minus:SI (reg:SI 1) (match_operand:SI 0 "reg_or_short_operand" "")))]
6976   ""
6977   "
6978 { rtx chain = gen_reg_rtx (Pmode);
6979   rtx stack_bot = gen_rtx (MEM, Pmode, stack_pointer_rtx);
6980   rtx neg_op0;
6981
6982   emit_move_insn (chain, stack_bot);
6983
6984   /* Under Windows NT, we need to add stack probes for large/variable allocations,
6985      so do it via a call to the external function alloca, instead of doing it
6986      inline.  */
6987   if (DEFAULT_ABI == ABI_NT
6988       && (GET_CODE (operands[0]) != CONST_INT || INTVAL (operands[0]) > 4096))
6989     {
6990       rtx tmp = gen_reg_rtx (SImode);
6991       emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__allocate_stack\"),
6992                                tmp, 0, SImode, 1, operands[0], Pmode);
6993       emit_insn (gen_set_sp (tmp));
6994       DONE;
6995     }
6996
6997   if (GET_CODE (operands[0]) != CONST_INT
6998       || INTVAL (operands[0]) < -32767
6999       || INTVAL (operands[0]) > 32768)
7000     {
7001       neg_op0 = gen_reg_rtx (Pmode);
7002       if (TARGET_32BIT)
7003         emit_insn (gen_negsi2 (neg_op0, operands[0]));
7004       else
7005         emit_insn (gen_negdi2 (neg_op0, operands[0]));
7006     }
7007   else
7008     neg_op0 = GEN_INT (- INTVAL (operands[0]));
7009
7010   if (TARGET_32BIT)
7011     emit_insn (gen_movsi_update (stack_pointer_rtx, stack_pointer_rtx, neg_op0, chain));
7012   else
7013     emit_insn (gen_movdi_update (stack_pointer_rtx, stack_pointer_rtx, neg_op0, chain));
7014
7015   DONE;
7016 }")
7017
7018 ;; Marker to indicate that the stack pointer was changed under NT in
7019 ;; ways not known to the compiler
7020
7021 (define_insn "set_sp"
7022   [(set (reg:SI 1)
7023         (unspec [(match_operand:SI 0 "register_operand" "r")] 7))]
7024   ""
7025   ""
7026   [(set_attr "length" "0")])
7027
7028 ;; These patterns say how to save and restore the stack pointer.  We need not
7029 ;; save the stack pointer at function level since we are careful to
7030 ;; preserve the backchain.  At block level, we have to restore the backchain
7031 ;; when we restore the stack pointer.
7032 ;;
7033 ;; For nonlocal gotos, we must save both the stack pointer and its
7034 ;; backchain and restore both.  Note that in the nonlocal case, the
7035 ;; save area is a memory location.
7036
7037 (define_expand "save_stack_function"
7038   [(use (const_int 0))]
7039   ""
7040   "")
7041
7042 (define_expand "restore_stack_function"
7043   [(use (const_int 0))]
7044   ""
7045   "")
7046
7047 (define_expand "restore_stack_block"
7048   [(set (match_dup 2) (mem:SI (match_operand:SI 0 "register_operand" "")))
7049    (set (match_dup 0) (match_operand:SI 1 "register_operand" ""))
7050    (set (mem:SI (match_dup 0)) (match_dup 2))]
7051   ""
7052   "
7053 { operands[2] = gen_reg_rtx (SImode); }")
7054
7055 (define_expand "save_stack_nonlocal"
7056   [(match_operand:DI 0 "memory_operand" "")
7057    (match_operand:SI 1 "register_operand" "")]
7058   ""
7059   "
7060 {
7061   rtx temp = gen_reg_rtx (SImode);
7062
7063   /* Copy the backchain to the first word, sp to the second.  */
7064   emit_move_insn (temp, gen_rtx (MEM, SImode, operands[1]));
7065   emit_move_insn (operand_subword (operands[0], 0, 0, DImode), temp);
7066   emit_move_insn (operand_subword (operands[0], 1, 0, DImode), operands[1]);
7067   DONE;
7068 }")
7069
7070 (define_expand "restore_stack_nonlocal"
7071   [(match_operand:SI 0 "register_operand" "")
7072    (match_operand:DI 1 "memory_operand" "")]
7073   ""
7074   "
7075 {
7076   rtx temp = gen_reg_rtx (SImode);
7077
7078   /* Restore the backchain from the first word, sp from the second.  */
7079   emit_move_insn (temp, operand_subword (operands[1], 0, 0, DImode));
7080   emit_move_insn (operands[0], operand_subword (operands[1], 1, 0, DImode));
7081   emit_move_insn (gen_rtx (MEM, SImode, operands[0]), temp);
7082   DONE;
7083 }")
7084
7085 ;; If we have -mmiminal-toc, we need to reload r30 after a nonlocal goto.
7086
7087 (define_insn "nonlocal_goto_receiver"
7088   [(unspec_volatile [(const_int 0)] 1)]
7089   "TARGET_TOC && TARGET_MINIMAL_TOC && get_pool_size () != 0"
7090   "*
7091 {
7092   rs6000_output_load_toc_table (asm_out_file);
7093   return \"\";
7094 }"
7095   [(set_attr "type" "load")])
7096 \f
7097 ;; A function pointer under AIX is a pointer to a data area whose first word
7098 ;; contains the actual address of the function, whose second word contains a
7099 ;; pointer to its TOC, and whose third word contains a value to place in the
7100 ;; static chain register (r11).  Note that if we load the static chain, our
7101 ;; "trampoline" need not have any executable code.
7102 ;;
7103 ;; operands[0] is a register pointing to the 3 word descriptor (aka, the function address)
7104 ;; operands[1] is the stack size to clean up
7105 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument (must be 0 for AIX)
7106 ;; operands[3] is location to store the TOC
7107 ;; operands[4] is the TOC register
7108 ;; operands[5] is the static chain register
7109 ;;
7110 ;; We do not break this into separate insns, so that the scheduler will not try
7111 ;; to move the load of the new TOC before any loads from the TOC.
7112
7113 (define_insn "call_indirect_aix"
7114   [(call (mem:SI (match_operand:SI 0 "register_operand" "b"))
7115          (match_operand 1 "const_int_operand" "n"))
7116    (use (match_operand 2 "const_int_operand" "n"))
7117    (use (match_operand 3 "offsettable_addr_operand" "p"))
7118    (use (match_operand 4 "register_operand" "r"))
7119    (clobber (match_operand 5 "register_operand" "=r"))
7120    (clobber (match_scratch:SI 6 "=&r"))
7121    (clobber (match_scratch:SI 7 "=l"))]
7122   "DEFAULT_ABI == ABI_AIX
7123    && (INTVAL (operands[2]) == CALL_NORMAL || (INTVAL (operands[2]) & CALL_LONG) != 0)"
7124   "{st|stw} %4,%a3\;{l|lwz} %6,0(%0)\;{l|lwz} %4,4(%0)\;mt%7 %6\;{l|lwz} %5,8(%0)\;{brl|blrl}\;{l|lwz} %4,%a3"
7125   [(set_attr "type" "load")
7126    (set_attr "length" "28")])
7127
7128 (define_insn "call_value_indirect_aix"
7129   [(set (match_operand 0 "register_operand" "fg")
7130         (call (mem:SI (match_operand:SI 1 "register_operand" "b"))
7131               (match_operand 2 "const_int_operand" "n")))
7132    (use (match_operand 3 "const_int_operand" "n"))
7133    (use (match_operand 4 "offsettable_addr_operand" "p"))
7134    (use (match_operand 5 "register_operand" "r"))
7135    (clobber (match_operand 6 "register_operand" "=r"))
7136    (clobber (match_scratch:SI 7 "=&r"))
7137    (clobber (match_scratch:SI 8 "=l"))]
7138   "DEFAULT_ABI == ABI_AIX
7139    && (INTVAL (operands[3]) == CALL_NORMAL || (INTVAL (operands[3]) & CALL_LONG) != 0)"
7140   "{st|stw} %5,%a4\;{l|lwz} %7,0(%1)\;{l|lwz} %5,4(%1);\;mt%8 %7\;{l|lwz} %6,8(%1)\;{brl|blrl}\;{l|lwz} %5,%a4"
7141   [(set_attr "type" "load")
7142    (set_attr "length" "28")])
7143
7144 ;; A function pointer undef NT is a pointer to a data area whose first word
7145 ;; contains the actual address of the function, whose second word contains a
7146 ;; pointer to its TOC.  The static chain is not stored under NT, which means
7147 ;; that we need a trampoline.
7148 ;;
7149 ;; operands[0] is an SImode pseudo in which we place the address of the function.
7150 ;; operands[1] is the stack size to clean up
7151 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument (must be 0 for NT)
7152 ;; operands[3] is location to store the TOC
7153 ;; operands[4] is the TOC register
7154 ;;
7155 ;; We do not break this into separate insns, so that the scheduler will not try
7156 ;; to move the load of the new TOC before any loads from the TOC.
7157
7158 (define_insn "call_indirect_nt"
7159   [(call (mem:SI (match_operand:SI 0 "register_operand" "b"))
7160          (match_operand 1 "const_int_operand" "n"))
7161    (use (match_operand 2 "const_int_operand" "n"))
7162    (use (match_operand 3 "offsettable_addr_operand" "p"))
7163    (use (match_operand 4 "register_operand" "r"))
7164    (clobber (match_scratch:SI 5 "=&r"))
7165    (clobber (match_scratch:SI 6 "=l"))]
7166   "DEFAULT_ABI == ABI_NT
7167    && (INTVAL (operands[2]) == CALL_NORMAL || (INTVAL (operands[2]) & CALL_LONG) != 0)"
7168   "{st|stw} %4,%a3\;{l|lwz} %5,0(%0)\;{l|lwz} %4,4(%0)\;mt%6 %5\;{brl|blrl}\;{l|lwz} %4,%a3"
7169   [(set_attr "type" "load")
7170    (set_attr "length" "24")])
7171
7172 (define_insn "call_value_indirect_nt"
7173   [(set (match_operand 0 "register_operand" "fg")
7174         (call (mem:SI (match_operand:SI 1 "register_operand" "b"))
7175               (match_operand 2 "const_int_operand" "n")))
7176    (use (match_operand 3 "const_int_operand" "n"))
7177    (use (match_operand 4 "offsettable_addr_operand" "p"))
7178    (use (match_operand 5 "register_operand" "r"))
7179    (clobber (match_scratch:SI 6 "=&r"))
7180    (clobber (match_scratch:SI 7 "=l"))]
7181   "DEFAULT_ABI == ABI_NT
7182    && (INTVAL (operands[3]) == CALL_NORMAL || (INTVAL (operands[3]) & CALL_LONG) != 0)"
7183   "{st|stw} %5,%a4\;{l|lwz} %6,0(%1)\;{l|lwz} %5,4(%1)\;mt%7 %6\;{brl|blrl}\;{l|lwz} %5,%a4"
7184   [(set_attr "type" "load")
7185    (set_attr "length" "24")])
7186
7187 ;; A function pointer under System V is just a normal pointer
7188 ;; operands[0] is the function pointer
7189 ;; operands[1] is the stack size to clean up
7190 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument which indicates how to set cr1
7191
7192 (define_insn "call_indirect_sysv"
7193   [(call (mem:SI (match_operand:SI 0 "register_operand" "l,l"))
7194          (match_operand 1 "const_int_operand" "n,n"))
7195    (use (match_operand 2 "const_int_operand" "O,n"))
7196    (clobber (match_scratch:SI 3 "=l,l"))]
7197   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS || DEFAULT_ABI == ABI_AIX_NODESC"
7198   "*
7199 {
7200   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7201     output_asm_insn (\"crxor 6,6,6\", operands);
7202
7203   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7204     output_asm_insn (\"creqv 6,6,6\", operands);
7205
7206   return \"{brl|blrl}\";
7207 }"
7208   [(set_attr "type" "jmpreg")
7209    (set_attr "length" "4,8")])
7210
7211 (define_insn "call_value_indirect_sysv"
7212   [(set (match_operand 0 "register_operand" "=fg,fg")
7213         (call (mem:SI (match_operand:SI 1 "register_operand" "l,l"))
7214               (match_operand 2 "const_int_operand" "n,n")))
7215    (use (match_operand 3 "const_int_operand" "O,n"))
7216    (clobber (match_scratch:SI 4 "=l,l"))]
7217   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS || DEFAULT_ABI == ABI_AIX_NODESC"
7218   "*
7219 {
7220   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7221     output_asm_insn (\"crxor 6,6,6\", operands);
7222
7223   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7224     output_asm_insn (\"creqv 6,6,6\", operands);
7225
7226   return \"{brl|blrl}\";
7227 }"
7228   [(set_attr "type" "jmpreg")
7229    (set_attr "length" "4,8")])
7230
7231 ;; Now the definitions for the call and call_value insns
7232 (define_expand "call"
7233   [(parallel [(call (mem:SI (match_operand:SI 0 "address_operand" ""))
7234                     (match_operand 1 "" ""))
7235               (use (match_operand 2 "" ""))
7236               (clobber (scratch:SI))])]
7237   ""
7238   "
7239 {
7240   if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
7241     abort ();
7242
7243   operands[0] = XEXP (operands[0], 0);
7244
7245   /* Convert NT DLL imports into an indirect call.  */
7246   if (GET_CODE (operands[0]) == SYMBOL_REF
7247       && (INTVAL (operands[2]) & CALL_NT_DLLIMPORT) != 0)
7248     {
7249       operands[0] = rs6000_dll_import_ref (operands[0]);
7250       operands[2] = GEN_INT ((int)CALL_NORMAL);
7251     }
7252
7253   if (GET_CODE (operands[0]) != SYMBOL_REF
7254       || (INTVAL (operands[2]) & CALL_LONG) != 0)
7255     {
7256       if (INTVAL (operands[2]) & CALL_LONG)
7257         operands[0] = rs6000_longcall_ref (operands[0]);
7258
7259       if (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_SOLARIS)
7260         emit_call_insn (gen_call_indirect_sysv (force_reg (Pmode, operands[0]),
7261                                                 operands[1], operands[2]));
7262       else
7263         {
7264           rtx toc_reg = gen_rtx (REG, Pmode, 2);
7265           rtx toc_addr = RS6000_SAVE_TOC;
7266
7267           if (DEFAULT_ABI == ABI_AIX)
7268             {
7269               /* AIX function pointers are really pointers to a three word area */
7270               rtx static_chain = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
7271               emit_call_insn (gen_call_indirect_aix (force_reg (Pmode, operands[0]),
7272                                                      operands[1], operands[2],
7273                                                      toc_addr, toc_reg, static_chain));
7274             }
7275           else if (DEFAULT_ABI == ABI_NT)
7276             {
7277               /* NT function pointers are really pointers to a two word area */
7278               emit_call_insn (gen_call_indirect_nt (force_reg (Pmode, operands[0]),
7279                                                     operands[1], operands[2],
7280                                                     toc_addr, toc_reg));
7281             }
7282           else
7283             abort ();
7284         }
7285       DONE;
7286     }
7287 }")
7288
7289 (define_expand "call_value"
7290   [(parallel [(set (match_operand 0 "" "")
7291                    (call (mem:SI (match_operand:SI 1 "address_operand" ""))
7292                          (match_operand 2 "" "")))
7293               (use (match_operand 3 "" ""))
7294               (clobber (scratch:SI))])]
7295   ""
7296   "
7297 {
7298   if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
7299     abort ();
7300
7301   operands[1] = XEXP (operands[1], 0);
7302
7303   /* Convert NT DLL imports into an indirect call.  */
7304   if (GET_CODE (operands[1]) == SYMBOL_REF
7305       && (INTVAL (operands[3]) & CALL_NT_DLLIMPORT) != 0)
7306     {
7307       operands[1] = rs6000_dll_import_ref (operands[1]);
7308       operands[3] = GEN_INT ((int)CALL_NORMAL);
7309     }
7310
7311   if (GET_CODE (operands[1]) != SYMBOL_REF
7312       || (INTVAL (operands[3]) & CALL_LONG) != 0)
7313     {
7314       if (INTVAL (operands[2]) & CALL_LONG)
7315         operands[1] = rs6000_longcall_ref (operands[1]);
7316
7317       if (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_SOLARIS)
7318         emit_call_insn (gen_call_value_indirect_sysv (operands[0], operands[1],
7319                                                       operands[2], operands[3]));
7320       else
7321         {
7322           rtx toc_reg = gen_rtx (REG, Pmode, 2);
7323           rtx toc_addr = RS6000_SAVE_TOC;
7324
7325           if (DEFAULT_ABI == ABI_AIX)
7326             {
7327               /* AIX function pointers are really pointers to a three word area */
7328               rtx static_chain = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
7329               emit_call_insn (gen_call_value_indirect_aix (operands[0],
7330                                                            force_reg (Pmode, operands[1]),
7331                                                            operands[2], operands[3],
7332                                                            toc_addr, toc_reg, static_chain));
7333             }
7334           else if (DEFAULT_ABI == ABI_NT)
7335             {
7336               /* NT function pointers are really pointers to a two word area */
7337               emit_call_insn (gen_call_value_indirect_nt (operands[0],
7338                                                           force_reg (Pmode, operands[1]),
7339                                                           operands[2], operands[3],
7340                                                           toc_addr, toc_reg));
7341             }
7342           else
7343             abort ();
7344         }
7345       DONE;
7346     }
7347 }")
7348
7349 ;; Call to function in current module.  No TOC pointer reload needed.
7350 ;; Operand2 is non-zero if we are using the V.4 calling sequence and
7351 ;; either the function was not prototyped, or it was prototyped as a
7352 ;; variable argument function.  It is > 0 if FP registers were passed
7353 ;; and < 0 if they were not.
7354
7355 (define_insn ""
7356   [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
7357          (match_operand 1 "" "g,g"))
7358    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7359    (clobber (match_scratch:SI 3 "=l,l"))]
7360   "(INTVAL (operands[2]) & CALL_LONG) == 0"
7361   "*
7362 {
7363   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7364     output_asm_insn (\"crxor 6,6,6\", operands);
7365
7366   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7367     output_asm_insn (\"creqv 6,6,6\", operands);
7368
7369   return \"bl %z0\";
7370 }"
7371   [(set_attr "type" "branch")
7372    (set_attr "length" "4,8")])
7373
7374 ;; Call to function which may be in another module.  Restore the TOC
7375 ;; pointer (r2) after the call unless this is System V.
7376 ;; Operand2 is non-zero if we are using the V.4 calling sequence and
7377 ;; either the function was not prototyped, or it was prototyped as a
7378 ;; variable argument function.  It is > 0 if FP registers were passed
7379 ;; and < 0 if they were not.
7380
7381 (define_insn ""
7382   [(call (mem:SI (match_operand:SI 0 "call_operand" "s,s"))
7383          (match_operand 1 "" "fg,fg"))
7384    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7385    (clobber (match_scratch:SI 3 "=l,l"))]
7386   "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
7387    && (INTVAL (operands[2]) & CALL_LONG) == 0"
7388   "*
7389 {
7390   /* Indirect calls should go through call_indirect */
7391   if (GET_CODE (operands[0]) == REG)
7392     abort ();
7393
7394   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7395     output_asm_insn (\"crxor 6,6,6\", operands);
7396
7397   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7398     output_asm_insn (\"creqv 6,6,6\", operands);
7399
7400   return (TARGET_WINDOWS_NT) ? \"bl %z0\;.znop %z0\" : \"bl %z0\;%.\";
7401 }"
7402   [(set_attr "type" "branch")
7403    (set_attr "length" "8,12")])
7404
7405 (define_insn ""
7406   [(call (mem:SI (match_operand:SI 0 "call_operand" "s,s"))
7407          (match_operand 1 "" "fg,fg"))
7408    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7409    (clobber (match_scratch:SI 3 "=l,l"))]
7410   "(DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
7411    && (INTVAL (operands[2]) & CALL_LONG) == 0"
7412   "*
7413 {
7414   /* Indirect calls should go through call_indirect */
7415   if (GET_CODE (operands[0]) == REG)
7416     abort ();
7417
7418   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7419     output_asm_insn (\"crxor 6,6,6\", operands);
7420
7421   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7422     output_asm_insn (\"creqv 6,6,6\", operands);
7423
7424   return (flag_pic == 1) ? \"bl %z0@plt\" : \"bl %z0\";
7425 }"
7426   [(set_attr "type" "branch")
7427    (set_attr "length" "4,8")])
7428
7429 (define_insn ""
7430   [(set (match_operand 0 "" "=fg,fg")
7431         (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
7432               (match_operand 2 "" "g,g")))
7433    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7434    (clobber (match_scratch:SI 4 "=l,l"))]
7435   "(INTVAL (operands[3]) & CALL_LONG) == 0"
7436   "*
7437 {
7438   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7439     output_asm_insn (\"crxor 6,6,6\", operands);
7440
7441   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7442     output_asm_insn (\"creqv 6,6,6\", operands);
7443
7444   return \"bl %z1\";
7445 }"
7446   [(set_attr "type" "branch")
7447    (set_attr "length" "4,8")])
7448
7449 (define_insn ""
7450   [(set (match_operand 0 "" "=fg,fg")
7451         (call (mem:SI (match_operand:SI 1 "call_operand" "s,s"))
7452               (match_operand 2 "" "fg,fg")))
7453    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7454    (clobber (match_scratch:SI 4 "=l,l"))]
7455   "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
7456    && (INTVAL (operands[3]) & CALL_LONG) == 0"
7457   "*
7458 {
7459   /* This should be handled by call_value_indirect */
7460   if (GET_CODE (operands[1]) == REG)
7461     abort ();
7462
7463   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7464     output_asm_insn (\"crxor 6,6,6\", operands);
7465
7466   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7467     output_asm_insn (\"creqv 6,6,6\", operands);
7468
7469   return (TARGET_WINDOWS_NT) ? \"bl %z1\;.znop %z1\" : \"bl %z1\;%.\";
7470 }"
7471   [(set_attr "type" "branch")
7472    (set_attr "length" "8,12")])
7473
7474 (define_insn ""
7475   [(set (match_operand 0 "" "=fg,fg")
7476         (call (mem:SI (match_operand:SI 1 "call_operand" "s,s"))
7477               (match_operand 2 "" "fg,fg")))
7478    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7479    (clobber (match_scratch:SI 4 "=l,l"))]
7480   "(DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
7481    && (INTVAL (operands[3]) & CALL_LONG) == 0"
7482   "*
7483 {
7484   /* This should be handled by call_value_indirect */
7485   if (GET_CODE (operands[1]) == REG)
7486     abort ();
7487
7488   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7489     output_asm_insn (\"crxor 6,6,6\", operands);
7490
7491   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7492     output_asm_insn (\"creqv 6,6,6\", operands);
7493
7494   return (flag_pic == 1) ? \"bl %z1@plt\" : \"bl %z1\";
7495 }"
7496   [(set_attr "type" "branch")
7497    (set_attr "length" "4,8")])
7498
7499 ;; Call subroutine returning any type.
7500 (define_expand "untyped_call"
7501   [(parallel [(call (match_operand 0 "" "")
7502                     (const_int 0))
7503               (match_operand 1 "" "")
7504               (match_operand 2 "" "")])]
7505   ""
7506   "
7507 {
7508   int i;
7509
7510   emit_call_insn (gen_call (operands[0], const0_rtx, const0_rtx, const0_rtx));
7511
7512   for (i = 0; i < XVECLEN (operands[2], 0); i++)
7513     {
7514       rtx set = XVECEXP (operands[2], 0, i);
7515       emit_move_insn (SET_DEST (set), SET_SRC (set));
7516     }
7517
7518   /* The optimizer does not know that the call sets the function value
7519      registers we stored in the result block.  We avoid problems by
7520      claiming that all hard registers are used and clobbered at this
7521      point.  */
7522   emit_insn (gen_blockage ());
7523
7524   DONE;
7525 }")
7526
7527 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
7528 ;; all of memory.  This blocks insns from being moved across this point.
7529
7530 (define_insn "blockage"
7531   [(unspec_volatile [(const_int 0)] 0)]
7532   ""
7533   "")
7534
7535 ;; V.4 specific code to initialize the PIC register
7536
7537 (define_insn "init_v4_pic"
7538   [(set (match_operand:SI 0 "register_operand" "=l")
7539         (unspec [(const_int 0)] 7))]
7540   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS"
7541   "bl _GLOBAL_OFFSET_TABLE_@local-4"
7542   [(set_attr "type" "branch")
7543    (set_attr "length" "4")])
7544
7545 \f
7546 ;; Compare insns are next.  Note that the RS/6000 has two types of compares,
7547 ;; signed & unsigned, and one type of branch.
7548 ;;
7549 ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
7550 ;; insns, and branches.  We store the operands of compares until we see
7551 ;; how it is used.
7552 (define_expand "cmpsi"
7553   [(set (cc0)
7554         (compare (match_operand:SI 0 "gpc_reg_operand" "")
7555                  (match_operand:SI 1 "reg_or_short_operand" "")))]
7556   ""
7557   "
7558 {
7559   /* Take care of the possibility that operands[1] might be negative but
7560      this might be a logical operation.  That insn doesn't exist.  */
7561   if (GET_CODE (operands[1]) == CONST_INT
7562       && INTVAL (operands[1]) < 0)
7563     operands[1] = force_reg (SImode, operands[1]);
7564
7565   rs6000_compare_op0 = operands[0];
7566   rs6000_compare_op1 = operands[1];
7567   rs6000_compare_fp_p = 0;
7568   DONE;
7569 }")
7570
7571 (define_expand "cmpdi"
7572   [(set (cc0)
7573         (compare (match_operand:DI 0 "gpc_reg_operand" "")
7574                  (match_operand:DI 1 "reg_or_short_operand" "")))]
7575   "TARGET_POWERPC64"
7576   "
7577 {
7578   /* Take care of the possibility that operands[1] might be negative but
7579      this might be a logical operation.  That insn doesn't exist.  */
7580   if (GET_CODE (operands[1]) == CONST_INT
7581       && INTVAL (operands[1]) < 0)
7582     operands[1] = force_reg (DImode, operands[1]);
7583
7584   rs6000_compare_op0 = operands[0];
7585   rs6000_compare_op1 = operands[1];
7586   rs6000_compare_fp_p = 0;
7587   DONE;
7588 }")
7589
7590 (define_expand "cmpsf"
7591   [(set (cc0) (compare (match_operand:SF 0 "gpc_reg_operand" "")
7592                        (match_operand:SF 1 "gpc_reg_operand" "")))]
7593   "TARGET_HARD_FLOAT"
7594   "
7595 {
7596   rs6000_compare_op0 = operands[0];
7597   rs6000_compare_op1 = operands[1];
7598   rs6000_compare_fp_p = 1;
7599   DONE;
7600 }")
7601
7602 (define_expand "cmpdf"
7603   [(set (cc0) (compare (match_operand:DF 0 "gpc_reg_operand" "")
7604                        (match_operand:DF 1 "gpc_reg_operand" "")))]
7605   "TARGET_HARD_FLOAT"
7606   "
7607 {
7608   rs6000_compare_op0 = operands[0];
7609   rs6000_compare_op1 = operands[1];
7610   rs6000_compare_fp_p = 1;
7611   DONE;
7612 }")
7613
7614 (define_expand "beq"
7615   [(set (match_dup 2) (match_dup 1))
7616    (set (pc)
7617         (if_then_else (eq (match_dup 2)
7618                           (const_int 0))
7619                       (label_ref (match_operand 0 "" ""))
7620                       (pc)))]
7621   ""
7622   "
7623 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7624   operands[1] = gen_rtx (COMPARE, mode,
7625                          rs6000_compare_op0, rs6000_compare_op1);
7626   operands[2] = gen_reg_rtx (mode);
7627 }")
7628
7629 (define_expand "bne"
7630   [(set (match_dup 2) (match_dup 1))
7631    (set (pc)
7632         (if_then_else (ne (match_dup 2)
7633                           (const_int 0))
7634                       (label_ref (match_operand 0 "" ""))
7635                       (pc)))]
7636   ""
7637   "
7638 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7639   operands[1] = gen_rtx (COMPARE, mode,
7640                          rs6000_compare_op0, rs6000_compare_op1);
7641   operands[2] = gen_reg_rtx (mode);
7642 }")
7643
7644 (define_expand "blt"
7645   [(set (match_dup 2) (match_dup 1))
7646    (set (pc)
7647         (if_then_else (lt (match_dup 2)
7648                           (const_int 0))
7649                       (label_ref (match_operand 0 "" ""))
7650                       (pc)))]
7651   ""
7652   "
7653 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7654   operands[1] = gen_rtx (COMPARE, mode,
7655                          rs6000_compare_op0, rs6000_compare_op1);
7656   operands[2] = gen_reg_rtx (mode);
7657 }")
7658
7659 (define_expand "bgt"
7660   [(set (match_dup 2) (match_dup 1))
7661    (set (pc)
7662         (if_then_else (gt (match_dup 2)
7663                           (const_int 0))
7664                       (label_ref (match_operand 0 "" ""))
7665                       (pc)))]
7666   ""
7667   "
7668 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7669   operands[1] = gen_rtx (COMPARE, mode,
7670                          rs6000_compare_op0, rs6000_compare_op1);
7671   operands[2] = gen_reg_rtx (mode);
7672 }")
7673
7674 (define_expand "ble"
7675   [(set (match_dup 2) (match_dup 1))
7676    (set (pc)
7677         (if_then_else (le (match_dup 2)
7678                           (const_int 0))
7679                       (label_ref (match_operand 0 "" ""))
7680                       (pc)))]
7681   ""
7682   "
7683 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7684   operands[1] = gen_rtx (COMPARE, mode,
7685                          rs6000_compare_op0, rs6000_compare_op1);
7686   operands[2] = gen_reg_rtx (mode);
7687 }")
7688
7689 (define_expand "bge"
7690   [(set (match_dup 2) (match_dup 1))
7691    (set (pc)
7692         (if_then_else (ge (match_dup 2)
7693                           (const_int 0))
7694                       (label_ref (match_operand 0 "" ""))
7695                       (pc)))]
7696   ""
7697   "
7698 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7699   operands[1] = gen_rtx (COMPARE, mode,
7700                          rs6000_compare_op0, rs6000_compare_op1);
7701   operands[2] = gen_reg_rtx (mode);
7702 }")
7703
7704 (define_expand "bgtu"
7705   [(set (match_dup 2) (match_dup 1))
7706    (set (pc)
7707         (if_then_else (gtu (match_dup 2)
7708                            (const_int 0))
7709                       (label_ref (match_operand 0 "" ""))
7710                       (pc)))]
7711   ""
7712   "
7713 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7714                          rs6000_compare_op0, rs6000_compare_op1);
7715   operands[2] = gen_reg_rtx (CCUNSmode);
7716 }")
7717
7718 (define_expand "bltu"
7719   [(set (match_dup 2) (match_dup 1))
7720    (set (pc)
7721         (if_then_else (ltu (match_dup 2)
7722                            (const_int 0))
7723                       (label_ref (match_operand 0 "" ""))
7724                       (pc)))]
7725   ""
7726   "
7727 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7728                          rs6000_compare_op0, rs6000_compare_op1);
7729   operands[2] = gen_reg_rtx (CCUNSmode);
7730 }")
7731
7732 (define_expand "bgeu"
7733   [(set (match_dup 2) (match_dup 1))
7734    (set (pc)
7735         (if_then_else (geu (match_dup 2)
7736                            (const_int 0))
7737                       (label_ref (match_operand 0 "" ""))
7738                       (pc)))]
7739   ""
7740   "
7741 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7742                          rs6000_compare_op0, rs6000_compare_op1);
7743   operands[2] = gen_reg_rtx (CCUNSmode);
7744 }")
7745
7746 (define_expand "bleu"
7747   [(set (match_dup 2) (match_dup 1))
7748    (set (pc)
7749         (if_then_else (leu (match_dup 2)
7750                            (const_int 0))
7751                       (label_ref (match_operand 0 "" ""))
7752                       (pc)))]
7753   ""
7754   "
7755 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7756                          rs6000_compare_op0, rs6000_compare_op1);
7757   operands[2] = gen_reg_rtx (CCUNSmode);
7758 }")
7759
7760 ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
7761 ;; For SEQ, likewise, except that comparisons with zero should be done
7762 ;; with an scc insns.  However, due to the order that combine see the
7763 ;; resulting insns, we must, in fact, allow SEQ for integers.  Fail in
7764 ;; the cases we don't want to handle.
7765 (define_expand "seq"
7766   [(set (match_dup 2) (match_dup 1))
7767    (set (match_operand:SI 0 "gpc_reg_operand" "")
7768         (eq:SI (match_dup 2) (const_int 0)))]
7769   ""
7770   "
7771 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7772   operands[1] = gen_rtx (COMPARE, mode,
7773                          rs6000_compare_op0, rs6000_compare_op1);
7774   operands[2] = gen_reg_rtx (mode);
7775 }")
7776
7777 (define_expand "sne"
7778   [(set (match_dup 2) (match_dup 1))
7779    (set (match_operand:SI 0 "gpc_reg_operand" "")
7780         (ne:SI (match_dup 2) (const_int 0)))]
7781   ""
7782   "
7783 { if (! rs6000_compare_fp_p)
7784     FAIL;
7785
7786   operands[1] = gen_rtx (COMPARE, CCFPmode,
7787                          rs6000_compare_op0, rs6000_compare_op1);
7788   operands[2] = gen_reg_rtx (CCFPmode);
7789 }")
7790
7791 ;; A > 0 is best done using the portable sequence, so fail in that case.
7792 (define_expand "sgt"
7793   [(set (match_dup 2) (match_dup 1))
7794    (set (match_operand:SI 0 "gpc_reg_operand" "")
7795         (gt:SI (match_dup 2) (const_int 0)))]
7796   ""
7797   "
7798 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7799
7800   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7801     FAIL;
7802
7803   operands[1] = gen_rtx (COMPARE, mode,
7804                          rs6000_compare_op0, rs6000_compare_op1);
7805   operands[2] = gen_reg_rtx (mode);
7806 }")
7807
7808 ;; A < 0 is best done in the portable way for A an integer.
7809 (define_expand "slt"
7810   [(set (match_dup 2) (match_dup 1))
7811    (set (match_operand:SI 0 "gpc_reg_operand" "")
7812         (lt:SI (match_dup 2) (const_int 0)))]
7813   ""
7814   "
7815 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7816
7817   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7818     FAIL;
7819
7820   operands[1] = gen_rtx (COMPARE, mode,
7821                          rs6000_compare_op0, rs6000_compare_op1);
7822   operands[2] = gen_reg_rtx (mode);
7823 }")
7824
7825 (define_expand "sge"
7826   [(set (match_dup 2) (match_dup 1))
7827    (set (match_operand:SI 0 "gpc_reg_operand" "")
7828         (ge:SI (match_dup 2) (const_int 0)))]
7829   ""
7830   "
7831 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7832   operands[1] = gen_rtx (COMPARE, mode,
7833                          rs6000_compare_op0, rs6000_compare_op1);
7834   operands[2] = gen_reg_rtx (mode);
7835 }")
7836
7837 ;; A <= 0 is best done the portable way for A an integer.
7838 (define_expand "sle"
7839   [(set (match_dup 2) (match_dup 1))
7840    (set (match_operand:SI 0 "gpc_reg_operand" "")
7841         (le:SI (match_dup 2) (const_int 0)))]
7842   ""
7843   "
7844 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7845
7846   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7847     FAIL;
7848
7849   operands[1] = gen_rtx (COMPARE, mode,
7850                          rs6000_compare_op0, rs6000_compare_op1);
7851   operands[2] = gen_reg_rtx (mode);
7852 }")
7853
7854 (define_expand "sgtu"
7855   [(set (match_dup 2) (match_dup 1))
7856    (set (match_operand:SI 0 "gpc_reg_operand" "")
7857         (gtu:SI (match_dup 2) (const_int 0)))]
7858   ""
7859   "
7860 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7861                          rs6000_compare_op0, rs6000_compare_op1);
7862   operands[2] = gen_reg_rtx (CCUNSmode);
7863 }")
7864
7865 (define_expand "sltu"
7866   [(set (match_dup 2) (match_dup 1))
7867    (set (match_operand:SI 0 "gpc_reg_operand" "")
7868         (ltu:SI (match_dup 2) (const_int 0)))]
7869   ""
7870   "
7871 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7872                          rs6000_compare_op0, rs6000_compare_op1);
7873   operands[2] = gen_reg_rtx (CCUNSmode);
7874 }")
7875
7876 (define_expand "sgeu"
7877   [(set (match_dup 2) (match_dup 1))
7878    (set (match_operand:SI 0 "gpc_reg_operand" "")
7879         (geu:SI (match_dup 2) (const_int 0)))]
7880   ""
7881   "
7882 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7883                          rs6000_compare_op0, rs6000_compare_op1);
7884   operands[2] = gen_reg_rtx (CCUNSmode);
7885 }")
7886
7887 (define_expand "sleu"
7888   [(set (match_dup 2) (match_dup 1))
7889    (set (match_operand:SI 0 "gpc_reg_operand" "")
7890         (leu:SI (match_dup 2) (const_int 0)))]
7891   ""
7892   "
7893 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7894                          rs6000_compare_op0, rs6000_compare_op1);
7895   operands[2] = gen_reg_rtx (CCUNSmode);
7896 }")
7897 \f
7898 ;; Here are the actual compare insns.
7899 (define_insn ""
7900   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
7901         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
7902                     (match_operand:SI 2 "reg_or_short_operand" "rI")))]
7903   ""
7904   "{cmp%I2|cmpw%I2} %0,%1,%2"
7905   [(set_attr "type" "compare")])
7906
7907 (define_insn ""
7908   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
7909         (compare:CC (match_operand:DI 1 "gpc_reg_operand" "r")
7910                     (match_operand:DI 2 "reg_or_short_operand" "rI")))]
7911   "TARGET_POWERPC64"
7912   "cmpd%I2 %0,%1,%2"
7913   [(set_attr "type" "compare")])
7914
7915 ;; If we are comparing a register for equality with a large constant,
7916 ;; we can do this with an XOR followed by a compare.  But we need a scratch
7917 ;; register for the result of the XOR.
7918
7919 (define_split
7920   [(set (match_operand:CC 0 "cc_reg_operand" "")
7921         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
7922                     (match_operand:SI 2 "non_short_cint_operand" "")))
7923    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
7924   "find_single_use (operands[0], insn, 0)
7925    && (GET_CODE (*find_single_use (operands[0], insn, 0)) == EQ
7926        || GET_CODE (*find_single_use (operands[0], insn, 0)) == NE)"
7927   [(set (match_dup 3) (xor:SI (match_dup 1) (match_dup 4)))
7928    (set (match_dup 0) (compare:CC (match_dup 3) (match_dup 5)))]
7929   "
7930 {
7931   /* Get the constant we are comparing against, C,  and see what it looks like
7932      sign-extended to 16 bits.  Then see what constant could be XOR'ed
7933      with C to get the sign-extended value.  */
7934
7935   int c = INTVAL (operands[2]);
7936   int sextc = (c << 16) >> 16;
7937   int xorv = c ^ sextc;
7938
7939   operands[4] = gen_rtx (CONST_INT, VOIDmode, xorv);
7940   operands[5] = gen_rtx (CONST_INT, VOIDmode, sextc);
7941 }")
7942
7943 (define_insn ""
7944   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
7945         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
7946                        (match_operand:SI 2 "reg_or_u_short_operand" "rI")))]
7947   ""
7948   "{cmpl%I2|cmplw%I2} %0,%1,%W2"
7949   [(set_attr "type" "compare")])
7950
7951 (define_insn ""
7952   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
7953         (compare:CCUNS (match_operand:DI 1 "gpc_reg_operand" "r")
7954                        (match_operand:DI 2 "reg_or_u_short_operand" "rI")))]
7955   ""
7956   "cmpld%I2 %0,%1,%W2"
7957   [(set_attr "type" "compare")])
7958
7959 ;; The following two insns don't exist as single insns, but if we provide
7960 ;; them, we can swap an add and compare, which will enable us to overlap more
7961 ;; of the required delay between a compare and branch.  We generate code for
7962 ;; them by splitting.
7963
7964 (define_insn ""
7965   [(set (match_operand:CC 3 "cc_reg_operand" "=y")
7966         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
7967                     (match_operand:SI 2 "short_cint_operand" "i")))
7968    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
7969         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
7970   ""
7971   "#"
7972   [(set_attr "length" "8")])
7973
7974 (define_insn ""
7975   [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
7976         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
7977                        (match_operand:SI 2 "u_short_cint_operand" "i")))
7978    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
7979         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
7980   ""
7981   "#"
7982   [(set_attr "length" "8")])
7983
7984 (define_split
7985   [(set (match_operand:CC 3 "cc_reg_operand" "")
7986         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
7987                     (match_operand:SI 2 "short_cint_operand" "")))
7988    (set (match_operand:SI 0 "gpc_reg_operand" "")
7989         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
7990   ""
7991   [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
7992    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
7993
7994 (define_split
7995   [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
7996         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
7997                        (match_operand:SI 2 "u_short_cint_operand" "")))
7998    (set (match_operand:SI 0 "gpc_reg_operand" "")
7999         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
8000   ""
8001   [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
8002    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
8003
8004 (define_insn ""
8005   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
8006         (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
8007                       (match_operand:SF 2 "gpc_reg_operand" "f")))]
8008   "TARGET_HARD_FLOAT"
8009   "fcmpu %0,%1,%2"
8010   [(set_attr "type" "fpcompare")])
8011
8012 (define_insn ""
8013   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
8014         (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
8015                       (match_operand:DF 2 "gpc_reg_operand" "f")))]
8016   "TARGET_HARD_FLOAT"
8017   "fcmpu %0,%1,%2"
8018   [(set_attr "type" "fpcompare")])
8019 \f
8020 ;; Now we have the scc insns.  We can do some combinations because of the
8021 ;; way the machine works.
8022 ;;
8023 ;; Note that this is probably faster if we can put an insn between the
8024 ;; mfcr and rlinm, but this is tricky.  Let's leave it for now.  In most
8025 ;; cases the insns below which don't use an intermediate CR field will
8026 ;; be used instead.
8027 (define_insn ""
8028   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8029         (match_operator:SI 1 "scc_comparison_operator"
8030                            [(match_operand 2 "cc_reg_operand" "y")
8031                             (const_int 0)]))]
8032   ""
8033   "%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%J1,1"
8034   [(set_attr "length" "12")])
8035
8036 (define_insn ""
8037   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8038         (compare:CC (match_operator:SI 1 "scc_comparison_operator"
8039                                        [(match_operand 2 "cc_reg_operand" "y")
8040                                         (const_int 0)])
8041                     (const_int 0)))
8042    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
8043         (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
8044   ""
8045   "%D1mfcr %3\;{rlinm.|rlwinm.} %3,%3,%J1,1"
8046   [(set_attr "type" "delayed_compare")
8047    (set_attr "length" "12")])
8048
8049 (define_insn ""
8050   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8051         (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
8052                                       [(match_operand 2 "cc_reg_operand" "y")
8053                                        (const_int 0)])
8054                    (match_operand:SI 3 "const_int_operand" "n")))]
8055   ""
8056   "*
8057 {
8058   int is_bit = ccr_bit (operands[1], 1);
8059   int put_bit = 31 - (INTVAL (operands[3]) & 31);
8060   int count;
8061
8062   if (is_bit >= put_bit)
8063     count = is_bit - put_bit;
8064   else
8065     count = 32 - (put_bit - is_bit);
8066
8067   operands[4] = gen_rtx (CONST_INT, VOIDmode, count);
8068   operands[5] = gen_rtx (CONST_INT, VOIDmode, put_bit);
8069
8070   return \"%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
8071 }"
8072  [(set_attr "length" "12")])
8073
8074 (define_insn ""
8075   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8076         (compare:CC
8077          (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
8078                                        [(match_operand 2 "cc_reg_operand" "y")
8079                                         (const_int 0)])
8080                     (match_operand:SI 3 "const_int_operand" "n"))
8081          (const_int 0)))
8082    (set (match_operand:SI 4 "gpc_reg_operand" "=r")
8083         (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
8084                    (match_dup 3)))]
8085   ""
8086   "*
8087 {
8088   int is_bit = ccr_bit (operands[1], 1);
8089   int put_bit = 31 - (INTVAL (operands[3]) & 31);
8090   int count;
8091
8092   if (is_bit >= put_bit)
8093     count = is_bit - put_bit;
8094   else
8095     count = 32 - (put_bit - is_bit);
8096
8097   operands[5] = gen_rtx (CONST_INT, VOIDmode, count);
8098   operands[6] = gen_rtx (CONST_INT, VOIDmode, put_bit);
8099
8100   return \"%D1mfcr %4\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
8101 }"
8102   [(set_attr "type" "delayed_compare")
8103    (set_attr "length" "12")])
8104
8105 ;; If we are comparing the result of two comparisons, this can be done
8106 ;; using creqv or crxor.
8107
8108 (define_insn ""
8109   [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
8110         (compare:CCEQ (match_operator 1 "scc_comparison_operator"
8111                               [(match_operand 2 "cc_reg_operand" "y")
8112                                (const_int 0)])
8113                       (match_operator 3 "scc_comparison_operator"
8114                               [(match_operand 4 "cc_reg_operand" "y")
8115                                (const_int 0)])))]
8116   "REGNO (operands[2]) != REGNO (operands[4])"
8117   "*
8118 {
8119   enum rtx_code code1, code2;
8120
8121   code1 = GET_CODE (operands[1]);
8122   code2 = GET_CODE (operands[3]);
8123
8124   if ((code1 == EQ || code1 == LT || code1 == GT
8125        || code1 == LTU || code1 == GTU
8126        || (code1 != NE && GET_MODE (operands[2]) == CCFPmode))
8127       !=
8128       (code2 == EQ || code2 == LT || code2 == GT
8129        || code2 == LTU || code2 == GTU
8130        || (code2 != NE && GET_MODE (operands[4]) == CCFPmode)))
8131     return \"%C1%C3crxor %E0,%j1,%j3\";
8132   else
8133     return \"%C1%C3creqv %E0,%j1,%j3\";
8134 }"
8135   [(set_attr "length" "12")])
8136
8137 ;; There is a 3 cycle delay between consecutive mfcr instructions
8138 ;; so it is useful to combine 2 scc instructions to use only one mfcr.
8139
8140 (define_peephole
8141   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8142         (match_operator:SI 1 "scc_comparison_operator"
8143                            [(match_operand 2 "cc_reg_operand" "y")
8144                             (const_int 0)]))
8145    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
8146         (match_operator:SI 4 "scc_comparison_operator"
8147                            [(match_operand 5 "cc_reg_operand" "y")
8148                             (const_int 0)]))]
8149    "REGNO (operands[2]) != REGNO (operands[5])"
8150    "%D1%D4mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
8151    [(set_attr "length" "20")])
8152
8153 ;; There are some scc insns that can be done directly, without a compare.
8154 ;; These are faster because they don't involve the communications between
8155 ;; the FXU and branch units.   In fact, we will be replacing all of the
8156 ;; integer scc insns here or in the portable methods in emit_store_flag.
8157 ;;
8158 ;; Also support (neg (scc ..)) since that construct is used to replace
8159 ;; branches, (plus (scc ..) ..) since that construct is common and
8160 ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
8161 ;; cases where it is no more expensive than (neg (scc ..)).
8162
8163 ;; Have reload force a constant into a register for the simple insns that
8164 ;; otherwise won't accept constants.  We do this because it is faster than
8165 ;; the cmp/mfcr sequence we would otherwise generate.
8166
8167 (define_insn ""
8168   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8169         (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8170                (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I")))
8171    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
8172   ""
8173   "@
8174    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8175    {sfi|subfic} %3,%1,0\;{ae|adde} %0,%3,%1
8176    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8177    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8178    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0"
8179   [(set_attr "length" "12,8,12,12,12")])
8180
8181 (define_insn ""
8182   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x")
8183         (compare:CC
8184          (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8185                 (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8186          (const_int 0)))
8187    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8188         (eq:SI (match_dup 1) (match_dup 2)))
8189    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
8190   ""
8191   "@
8192    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8193    {sfi|subfic} %3,%1,0\;{ae.|adde.} %0,%3,%1
8194    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8195    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8196    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0"
8197   [(set_attr "type" "compare")
8198    (set_attr "length" "12,8,12,12,12")])
8199
8200 ;; We have insns of the form shown by the first define_insn below.  If
8201 ;; there is something inside the comparison operation, we must split it.
8202 (define_split
8203   [(set (match_operand:SI 0 "gpc_reg_operand" "")
8204         (plus:SI (match_operator 1 "comparison_operator"
8205                                  [(match_operand:SI 2 "" "")
8206                                   (match_operand:SI 3
8207                                                     "reg_or_cint_operand" "")])
8208                  (match_operand:SI 4 "gpc_reg_operand" "")))
8209    (clobber (match_operand:SI 5 "register_operand" ""))]
8210   "! gpc_reg_operand (operands[2], SImode)"
8211   [(set (match_dup 5) (match_dup 2))
8212    (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
8213                                (match_dup 4)))])
8214
8215 (define_insn ""
8216   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8217         (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8218                         (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8219                  (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))
8220    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8221   ""
8222   "@
8223    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8224    {sfi|subfic} %4,%1,0\;{aze|addze} %0,%3
8225    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8226    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8227    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
8228   [(set_attr "length" "12,8,12,12,12")])
8229
8230 (define_insn ""
8231   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x")
8232         (compare:CC
8233          (plus:SI
8234           (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8235                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8236           (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
8237          (const_int 0)))
8238    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8239   ""
8240   "@
8241    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8242    {sfi|subfic} %4,%1,0\;{aze.|addze.} %0,%3
8243    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8244    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8245    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
8246   [(set_attr "type" "compare")
8247    (set_attr "length" "12,8,12,12,12")])
8248
8249 (define_insn ""
8250   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x,x,x,x")
8251         (compare:CC
8252          (plus:SI
8253           (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8254                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8255           (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
8256          (const_int 0)))
8257    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8258         (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8259    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8260   ""
8261   "@
8262    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8263    {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
8264    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8265    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8266    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
8267   [(set_attr "type" "compare")
8268    (set_attr "length" "12,8,12,12,12")])
8269
8270 (define_insn ""
8271   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8272         (neg:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8273                        (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))))]
8274   ""
8275   "@
8276    xor %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8277    {ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0
8278    {xoril|xori} %0,%1,%b2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8279    {xoriu|xoris} %0,%1,%u2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8280    {sfi|subfic} %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
8281    [(set_attr "length" "12,8,12,12,12")])
8282
8283 ;; Simplify (ne X (const_int 0)) on the PowerPC.  No need to on the Power,
8284 ;; since it nabs/sr is just as fast.
8285 (define_insn ""
8286   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8287         (lshiftrt:SI (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8288                      (const_int 31)))
8289    (clobber (match_scratch:SI 2 "=&r"))]
8290   "!TARGET_POWER"
8291   "{ai|addic} %2,%1,-1\;{sfe|subfe} %0,%2,%1"
8292   [(set_attr "length" "8")])
8293
8294 ;; This is what (plus (ne X (const_int 0)) Y) looks like.
8295 (define_insn ""
8296   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8297         (plus:SI (lshiftrt:SI
8298                   (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8299                   (const_int 31))
8300                  (match_operand:SI 2 "gpc_reg_operand" "r")))
8301    (clobber (match_scratch:SI 3 "=&r"))]
8302   ""
8303   "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
8304   [(set_attr "length" "8")])
8305
8306 (define_insn ""
8307   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8308         (compare:CC
8309          (plus:SI (lshiftrt:SI
8310                    (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8311                    (const_int 31))
8312                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8313          (const_int 0)))
8314    (clobber (match_scratch:SI 3 "=&r"))]
8315   ""
8316   "{ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2"
8317   [(set_attr "type" "compare")
8318    (set_attr "length" "8")])
8319
8320 (define_insn ""
8321   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8322         (compare:CC
8323          (plus:SI (lshiftrt:SI
8324                    (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8325                    (const_int 31))
8326                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8327          (const_int 0)))
8328    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8329         (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
8330                  (match_dup 2)))
8331    (clobber (match_scratch:SI 3 "=&r"))]
8332   ""
8333   "{ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2"
8334   [(set_attr "type" "compare")
8335    (set_attr "length" "8")])
8336
8337 (define_insn ""
8338   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8339         (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8340                (match_operand:SI 2 "reg_or_short_operand" "r,O")))
8341    (clobber (match_scratch:SI 3 "=r,X"))]
8342   "TARGET_POWER"
8343   "@
8344    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
8345    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
8346   [(set_attr "length" "12")])
8347
8348 (define_insn ""
8349   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x")
8350         (compare:CC
8351          (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8352                 (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8353          (const_int 0)))
8354    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8355         (le:SI (match_dup 1) (match_dup 2)))
8356    (clobber (match_scratch:SI 3 "=r,X"))]
8357   "TARGET_POWER"
8358   "@
8359    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
8360    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31"
8361   [(set_attr "type" "compare,delayed_compare")
8362    (set_attr "length" "12")])
8363
8364 (define_insn ""
8365   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8366         (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8367                         (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8368                  (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8369    (clobber (match_scratch:SI 4 "=&r,&r"))]
8370   "TARGET_POWER"
8371   "@
8372    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8373    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze|addze} %0,%3"
8374   [(set_attr "length" "12")])
8375
8376 (define_insn ""
8377   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8378         (compare:CC
8379          (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8380                          (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8381                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8382          (const_int 0)))
8383    (clobber (match_scratch:SI 4 "=&r,&r"))]
8384   "TARGET_POWER"
8385   "@
8386    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8387    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3"
8388   [(set_attr "type" "compare")
8389    (set_attr "length" "12")])
8390
8391 (define_insn ""
8392   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8393         (compare:CC
8394          (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8395                          (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8396                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8397          (const_int 0)))
8398    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8399         (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8400    (clobber (match_scratch:SI 4 "=&r,&r"))]
8401   "TARGET_POWER"
8402   "@
8403    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8404    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %0,%3"
8405   [(set_attr "type" "compare")
8406    (set_attr "length" "12")])
8407
8408 (define_insn ""
8409   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8410         (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8411                        (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
8412   "TARGET_POWER"
8413   "@
8414    doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8415    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
8416   [(set_attr "length" "12")])
8417
8418 (define_insn ""
8419   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8420         (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8421                 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
8422   ""
8423   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
8424   [(set_attr "length" "12")])
8425
8426 (define_insn ""
8427   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8428         (compare:CC
8429          (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8430                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
8431          (const_int 0)))
8432    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8433         (leu:SI (match_dup 1) (match_dup 2)))]
8434    ""
8435   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
8436   [(set_attr "type" "compare")
8437    (set_attr "length" "12")])
8438
8439 (define_insn ""
8440   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8441         (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8442                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8443                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8444    (clobber (match_scratch:SI 4 "=&r"))]
8445   ""
8446   "{sf%I2|subf%I2c} %4,%1,%2\;{aze|addze} %0,%3"
8447   [(set_attr "length" "8")])
8448
8449 (define_insn ""
8450   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8451         (compare:CC
8452          (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8453                           (match_operand:SI 2 "reg_or_short_operand" "rI"))
8454                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8455          (const_int 0)))
8456    (clobber (match_scratch:SI 4 "=&r"))]
8457   ""
8458   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3"
8459   [(set_attr "type" "compare")
8460    (set_attr "length" "8")])
8461
8462 (define_insn ""
8463   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8464         (compare:CC
8465          (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8466                           (match_operand:SI 2 "reg_or_short_operand" "rI"))
8467                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8468          (const_int 0)))
8469    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8470         (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8471    (clobber (match_scratch:SI 4 "=&r"))]
8472   ""
8473   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %0,%3"
8474   [(set_attr "type" "compare")
8475    (set_attr "length" "8")])
8476
8477 (define_insn ""
8478   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8479         (neg:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8480                         (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8481   ""
8482   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
8483    [(set_attr "length" "12")])
8484
8485 (define_insn ""
8486   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8487         (and:SI (neg:SI
8488                  (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8489                          (match_operand:SI 2 "reg_or_short_operand" "rI")))
8490                 (match_operand:SI 3 "gpc_reg_operand" "r")))
8491    (clobber (match_scratch:SI 4 "=&r"))]
8492   ""
8493   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
8494   [(set_attr "length" "12")])
8495
8496 (define_insn ""
8497   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8498         (compare:CC
8499          (and:SI (neg:SI
8500                   (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8501                           (match_operand:SI 2 "reg_or_short_operand" "rI")))
8502                  (match_operand:SI 3 "gpc_reg_operand" "r"))
8503          (const_int 0)))
8504    (clobber (match_scratch:SI 4 "=&r"))]
8505   ""
8506   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
8507   [(set_attr "type" "compare")
8508    (set_attr "length" "12")])
8509
8510 (define_insn ""
8511   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8512         (compare:CC
8513          (and:SI (neg:SI
8514                   (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8515                           (match_operand:SI 2 "reg_or_short_operand" "rI")))
8516                  (match_operand:SI 3 "gpc_reg_operand" "r"))
8517          (const_int 0)))
8518    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8519         (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
8520    (clobber (match_scratch:SI 4 "=&r"))]
8521   ""
8522   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
8523   [(set_attr "type" "compare")
8524    (set_attr "length" "12")])
8525
8526 (define_insn ""
8527   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8528         (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8529                (match_operand:SI 2 "reg_or_short_operand" "rI")))]
8530   "TARGET_POWER"
8531   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
8532    [(set_attr "length" "12")])
8533
8534 (define_insn ""
8535   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8536         (compare:CC
8537          (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8538                 (match_operand:SI 2 "reg_or_short_operand" "rI"))
8539          (const_int 0)))
8540    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8541         (lt:SI (match_dup 1) (match_dup 2)))]
8542   "TARGET_POWER"
8543   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
8544   [(set_attr "type" "delayed_compare")
8545    (set_attr "length" "12")])
8546
8547 (define_insn ""
8548   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8549         (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8550                         (match_operand:SI 2 "reg_or_short_operand" "rI"))
8551                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8552    (clobber (match_scratch:SI 4 "=&r"))]
8553   "TARGET_POWER"
8554   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
8555   [(set_attr "length" "12")])
8556
8557 (define_insn ""
8558   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8559         (compare:CC
8560          (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8561                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8562                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8563          (const_int 0)))
8564    (clobber (match_scratch:SI 4 "=&r"))]
8565   "TARGET_POWER"
8566   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
8567   [(set_attr "type" "compare")
8568    (set_attr "length" "12")])
8569
8570 (define_insn ""
8571   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8572         (compare:CC
8573          (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8574                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8575                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8576          (const_int 0)))
8577    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8578         (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8579    (clobber (match_scratch:SI 4 "=&r"))]
8580   "TARGET_POWER"
8581   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
8582   [(set_attr "type" "compare")
8583    (set_attr "length" "12")])
8584
8585 (define_insn ""
8586   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8587         (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8588                        (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8589   "TARGET_POWER"
8590   "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
8591   [(set_attr "length" "12")])
8592
8593 (define_insn ""
8594   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8595         (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8596                 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
8597   ""
8598   "@
8599    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg %0,%0
8600    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
8601   [(set_attr "length" "12")])
8602
8603 (define_insn ""
8604   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
8605         (compare:CC
8606          (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8607                  (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8608          (const_int 0)))
8609    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8610         (ltu:SI (match_dup 1) (match_dup 2)))]
8611   ""
8612   "@
8613    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg. %0,%0
8614    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
8615   [(set_attr "type" "compare")
8616    (set_attr "length" "12")])
8617
8618 (define_insn ""
8619   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
8620         (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
8621                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,r,P,P"))
8622                  (match_operand:SI 3 "reg_or_short_operand" "r,I,r,I")))
8623    (clobber (match_scratch:SI 4 "=&r,r,&r,r"))]
8624   ""
8625   "@
8626   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8627   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8628   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8629   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
8630  [(set_attr "length" "12")])
8631
8632 (define_insn ""
8633   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8634         (compare:CC
8635          (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8636                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8637                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8638          (const_int 0)))
8639    (clobber (match_scratch:SI 4 "=&r,&r"))]
8640   ""
8641   "@
8642    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3
8643    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3"
8644   [(set_attr "type" "compare")
8645    (set_attr "length" "12")])
8646
8647 (define_insn ""
8648   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8649         (compare:CC
8650          (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8651                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8652                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8653          (const_int 0)))
8654    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8655         (plus:SI (ltu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8656    (clobber (match_scratch:SI 4 "=&r,&r"))]
8657   ""
8658   "@
8659    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3
8660    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
8661   [(set_attr "type" "compare")
8662    (set_attr "length" "12")])
8663
8664 (define_insn ""
8665   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8666         (neg:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8667                         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))))]
8668   ""
8669   "@
8670    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
8671    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
8672   [(set_attr "length" "8")])
8673
8674 (define_insn ""
8675   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8676         (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8677                (match_operand:SI 2 "reg_or_short_operand" "rI")))
8678    (clobber (match_scratch:SI 3 "=r"))]
8679   "TARGET_POWER"
8680   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
8681    [(set_attr "length" "12")])
8682
8683 (define_insn ""
8684   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8685         (compare:CC
8686          (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8687                 (match_operand:SI 2 "reg_or_short_operand" "rI"))
8688          (const_int 0)))
8689    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8690         (ge:SI (match_dup 1) (match_dup 2)))
8691    (clobber (match_scratch:SI 3 "=r"))]
8692   "TARGET_POWER"
8693   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3"
8694   [(set_attr "type" "compare")
8695    (set_attr "length" "12")])
8696
8697 (define_insn ""
8698   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8699         (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8700                         (match_operand:SI 2 "reg_or_short_operand" "rI"))
8701                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8702    (clobber (match_scratch:SI 4 "=&r"))]
8703   "TARGET_POWER"
8704   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
8705   [(set_attr "length" "12")])
8706
8707 (define_insn ""
8708   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8709         (compare:CC
8710          (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8711                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8712                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8713          (const_int 0)))
8714    (clobber (match_scratch:SI 4 "=&r"))]
8715   "TARGET_POWER"
8716   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
8717   [(set_attr "type" "compare")
8718    (set_attr "length" "12")])
8719
8720 (define_insn ""
8721   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8722         (compare:CC
8723          (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8724                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8725                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8726          (const_int 0)))
8727    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8728         (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8729    (clobber (match_scratch:SI 4 "=&r"))]
8730   "TARGET_POWER"
8731   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
8732   [(set_attr "type" "compare")
8733    (set_attr "length" "12")])
8734
8735 (define_insn ""
8736   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8737         (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8738                        (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8739   "TARGET_POWER"
8740   "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
8741   [(set_attr "length" "12")])
8742
8743 ;; This is (and (neg (ge X (const_int 0))) Y).
8744 (define_insn ""
8745   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8746         (and:SI (neg:SI
8747                  (lshiftrt:SI
8748                   (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8749                   (const_int 31)))
8750                 (match_operand:SI 2 "gpc_reg_operand" "r")))
8751    (clobber (match_scratch:SI 3 "=&r"))]
8752   ""
8753   "{srai|srawi} %3,%1,31\;andc %0,%2,%3"
8754   [(set_attr "length" "8")])
8755
8756 (define_insn ""
8757   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8758         (compare:CC
8759          (and:SI (neg:SI
8760                   (lshiftrt:SI
8761                    (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8762                    (const_int 31)))
8763                  (match_operand:SI 2 "gpc_reg_operand" "r"))
8764          (const_int 0)))
8765    (clobber (match_scratch:SI 3 "=&r"))]
8766   ""
8767   "{srai|srawi} %3,%1,31\;andc. %3,%2,%3"
8768   [(set_attr "type" "compare")
8769    (set_attr "length" "8")])
8770
8771 (define_insn ""
8772   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8773         (compare:CC
8774          (and:SI (neg:SI
8775                   (lshiftrt:SI
8776                    (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8777                    (const_int 31)))
8778                  (match_operand:SI 2 "gpc_reg_operand" "r"))
8779          (const_int 0)))
8780    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8781         (and:SI (neg:SI (lshiftrt:SI (not:SI (match_dup 1))
8782                                      (const_int 31)))
8783                 (match_dup 2)))
8784    (clobber (match_scratch:SI 3 "=&r"))]
8785   ""
8786   "{srai|srawi} %3,%1,31\;andc. %0,%2,%3"
8787   [(set_attr "type" "compare")
8788    (set_attr "length" "8")])
8789
8790 (define_insn ""
8791   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8792         (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8793                 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
8794   ""
8795   "@
8796    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
8797    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
8798   [(set_attr "length" "12")])
8799
8800 (define_insn ""
8801   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
8802         (compare:CC
8803          (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8804                  (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8805          (const_int 0)))
8806    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8807         (geu:SI (match_dup 1) (match_dup 2)))]
8808   ""
8809   "@
8810    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
8811    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
8812   [(set_attr "type" "compare")
8813    (set_attr "length" "12")])
8814
8815 (define_insn ""
8816   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8817         (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8818                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8819                  (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8820    (clobber (match_scratch:SI 4 "=&r,&r"))]
8821   ""
8822   "@
8823    {sf|subfc} %4,%2,%1\;{aze|addze} %0,%3
8824    {ai|addic} %4,%1,%n2\;{aze|addze} %0,%3"
8825   [(set_attr "length" "8")])
8826
8827 (define_insn ""
8828   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8829         (compare:CC
8830          (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8831                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8832                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8833          (const_int 0)))
8834    (clobber (match_scratch:SI 4 "=&r,&r"))]
8835   ""
8836   "@
8837    {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
8838    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
8839   [(set_attr "type" "compare")
8840    (set_attr "length" "8")])
8841
8842 (define_insn ""
8843   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8844         (compare:CC
8845          (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8846                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8847                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8848          (const_int 0)))
8849    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8850         (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8851    (clobber (match_scratch:SI 4 "=&r,&r"))]
8852   ""
8853   "@
8854    {sf|subfc} %4,%2,%1\;{aze.|addze.} %0,%3
8855    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
8856   [(set_attr "type" "compare")
8857    (set_attr "length" "8")])
8858
8859 (define_insn ""
8860   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8861         (neg:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8862                         (match_operand:SI 2 "reg_or_short_operand" "r,I"))))]
8863   ""
8864   "@
8865    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
8866    {sfi|subfic} %0,%1,-1\;{a%I2|add%I2c} %0,%0,%2\;{sfe|subfe} %0,%0,%0"
8867   [(set_attr "length" "12")])
8868
8869 (define_insn ""
8870   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8871         (and:SI (neg:SI
8872                  (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8873                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8874                 (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8875    (clobber (match_scratch:SI 4 "=&r,&r"))]
8876   ""
8877   "@
8878    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4
8879    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
8880   [(set_attr "length" "12")])
8881
8882 (define_insn ""
8883   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8884         (compare:CC
8885          (and:SI (neg:SI
8886                   (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8887                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8888                  (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8889          (const_int 0)))
8890    (clobber (match_scratch:SI 4 "=&r,&r"))]
8891   ""
8892   "@
8893    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
8894    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
8895   [(set_attr "type" "compare")
8896    (set_attr "length" "12")])
8897
8898 (define_insn ""
8899   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8900         (compare:CC
8901          (and:SI (neg:SI
8902                   (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8903                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8904                  (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8905          (const_int 0)))
8906    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8907         (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
8908    (clobber (match_scratch:SI 4 "=&r,&r"))]
8909   ""
8910   "@
8911    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4
8912    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
8913   [(set_attr "type" "compare")
8914    (set_attr "length" "12")])
8915
8916 (define_insn ""
8917   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8918         (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8919                (const_int 0)))]
8920   ""
8921   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri|srwi} %0,%0,31"
8922   [(set_attr "length" "12")])
8923
8924 (define_insn ""
8925   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
8926         (compare:CC
8927          (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8928                 (const_int 0))
8929          (const_int 0)))
8930    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8931         (gt:SI (match_dup 1) (const_int 0)))]
8932   ""
8933   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri.|srwi.} %0,%0,31"
8934   [(set_attr "type" "delayed_compare")
8935    (set_attr "length" "12")])
8936
8937 (define_insn ""
8938   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8939         (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8940                (match_operand:SI 2 "reg_or_short_operand" "r")))]
8941   "TARGET_POWER"
8942   "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
8943   [(set_attr "length" "12")])
8944
8945 (define_insn ""
8946   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8947         (compare:CC
8948          (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8949                 (match_operand:SI 2 "reg_or_short_operand" "r"))
8950          (const_int 0)))
8951    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8952         (gt:SI (match_dup 1) (match_dup 2)))]
8953   "TARGET_POWER"
8954   "doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
8955   [(set_attr "type" "delayed_compare")
8956    (set_attr "length" "12")])
8957
8958 (define_insn ""
8959   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8960         (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8961                         (const_int 0))
8962                  (match_operand:SI 2 "gpc_reg_operand" "r")))
8963    (clobber (match_scratch:SI 3 "=&r"))]
8964   ""
8965   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze|addze} %0,%2"
8966   [(set_attr "length" "12")])
8967
8968 (define_insn ""
8969   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8970         (compare:CC
8971          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8972                          (const_int 0))
8973                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8974          (const_int 0)))
8975    (clobber (match_scratch:SI 3 "=&r"))]
8976   ""
8977   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %0,%2"
8978   [(set_attr "type" "compare")
8979    (set_attr "length" "12")])
8980
8981 (define_insn ""
8982   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8983         (compare:CC
8984          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8985                          (const_int 0))
8986                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8987          (const_int 0)))
8988    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8989         (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
8990    (clobber (match_scratch:SI 3 "=&r"))]
8991   ""
8992   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2"
8993   [(set_attr "type" "compare")
8994    (set_attr "length" "12")])
8995
8996 (define_insn ""
8997   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8998         (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8999                         (match_operand:SI 2 "reg_or_short_operand" "r"))
9000                  (match_operand:SI 3 "gpc_reg_operand" "r")))
9001    (clobber (match_scratch:SI 4 "=&r"))]
9002   "TARGET_POWER"
9003   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
9004   [(set_attr "length" "12")])
9005
9006 (define_insn ""
9007   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
9008         (compare:CC
9009          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9010                          (match_operand:SI 2 "reg_or_short_operand" "r"))
9011                   (match_operand:SI 3 "gpc_reg_operand" "r"))
9012          (const_int 0)))
9013    (clobber (match_scratch:SI 4 "=&r"))]
9014   "TARGET_POWER"
9015   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
9016   [(set_attr "type" "compare")
9017    (set_attr "length" "12")])
9018
9019 (define_insn ""
9020   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
9021         (compare:CC
9022          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9023                          (match_operand:SI 2 "reg_or_short_operand" "r"))
9024                   (match_operand:SI 3 "gpc_reg_operand" "r"))
9025          (const_int 0)))
9026    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
9027         (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
9028    (clobber (match_scratch:SI 4 "=&r"))]
9029   "TARGET_POWER"
9030   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
9031   [(set_attr "type" "compare")
9032    (set_attr "length" "12")])
9033
9034 (define_insn ""
9035   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9036         (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9037                        (const_int 0))))]
9038   ""
9039   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{srai|srawi} %0,%0,31"
9040   [(set_attr "length" "12")])
9041
9042 (define_insn ""
9043   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9044         (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9045                        (match_operand:SI 2 "reg_or_short_operand" "r"))))]
9046   "TARGET_POWER"
9047   "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
9048   [(set_attr "length" "12")])
9049
9050 (define_insn ""
9051   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9052         (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9053                 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
9054   ""
9055   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
9056   [(set_attr "length" "12")])
9057
9058 (define_insn ""
9059   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
9060         (compare:CC
9061          (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9062                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
9063          (const_int 0)))
9064    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
9065         (gtu:SI (match_dup 1) (match_dup 2)))]
9066   ""
9067   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
9068   [(set_attr "type" "compare")
9069    (set_attr "length" "12")])
9070
9071 (define_insn ""
9072   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
9073         (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
9074                          (match_operand:SI 2 "reg_or_short_operand" "I,r,rI"))
9075                  (match_operand:SI 3 "reg_or_short_operand" "r,r,I")))
9076    (clobber (match_scratch:SI 4 "=&r,&r,&r"))]
9077   ""
9078   "@
9079    {ai|addic} %4,%1,%k2\;{aze|addze} %0,%3
9080    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
9081    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
9082   [(set_attr "length" "8,12,12")])
9083
9084 (define_insn ""
9085   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
9086         (compare:CC
9087          (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
9088                           (match_operand:SI 2 "reg_or_short_operand" "I,r"))
9089                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
9090          (const_int 0)))
9091    (clobber (match_scratch:SI 4 "=&r,&r"))]
9092   ""
9093   "@
9094    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
9095    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
9096   [(set_attr "type" "compare")
9097    (set_attr "length" "8,12")])
9098
9099 (define_insn ""
9100   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
9101         (compare:CC
9102          (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
9103                           (match_operand:SI 2 "reg_or_short_operand" "I,r"))
9104                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
9105          (const_int 0)))
9106    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
9107         (plus:SI (gtu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
9108    (clobber (match_scratch:SI 4 "=&r,&r"))]
9109   ""
9110   "@
9111    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
9112    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
9113   [(set_attr "type" "compare")
9114    (set_attr "length" "8,12")])
9115
9116 (define_insn ""
9117   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9118         (neg:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9119                         (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
9120   ""
9121   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
9122   [(set_attr "length" "8")])
9123 \f
9124 ;; Define both directions of branch and return.  If we need a reload
9125 ;; register, we'd rather use CR0 since it is much easier to copy a
9126 ;; register CC value to there.
9127
9128 (define_insn ""
9129   [(set (pc)
9130         (if_then_else (match_operator 1 "branch_comparison_operator"
9131                                       [(match_operand 2
9132                                                       "cc_reg_operand" "x,?y")
9133                                        (const_int 0)])
9134                       (label_ref (match_operand 0 "" ""))
9135                       (pc)))]
9136   ""
9137   "*
9138 {
9139   if (get_attr_length (insn) == 8)
9140     return \"%C1bc %t1,%j1,%l0\";
9141   else
9142     return \"%C1bc %T1,%j1,%$+8\;b %l0\";
9143
9144 }"
9145   [(set_attr "type" "branch")])
9146
9147 (define_insn ""
9148   [(set (pc)
9149         (if_then_else (match_operator 0 "branch_comparison_operator"
9150                                       [(match_operand 1
9151                                                       "cc_reg_operand" "x,?y")
9152                                        (const_int 0)])
9153                       (return)
9154                       (pc)))]
9155   "direct_return ()"
9156   "{%C0bcr|%C0bclr} %t0,%j0"
9157   [(set_attr "type" "branch")
9158    (set_attr "length" "8")])
9159
9160 (define_insn ""
9161   [(set (pc)
9162         (if_then_else (match_operator 1 "branch_comparison_operator"
9163                                       [(match_operand 2
9164                                                       "cc_reg_operand" "x,?y")
9165                                        (const_int 0)])
9166                       (pc)
9167                       (label_ref (match_operand 0 "" ""))))]
9168   ""
9169   "*
9170 {
9171   if (get_attr_length (insn) == 8)
9172     return \"%C1bc %T1,%j1,%l0\";
9173   else
9174     return \"%C1bc %t1,%j1,%$+8\;b %l0\";
9175 }"
9176   [(set_attr "type" "branch")])
9177
9178 (define_insn ""
9179   [(set (pc)
9180         (if_then_else (match_operator 0 "branch_comparison_operator"
9181                                       [(match_operand 1
9182                                                       "cc_reg_operand" "x,?y")
9183                                        (const_int 0)])
9184                       (pc)
9185                       (return)))]
9186   "direct_return ()"
9187   "{%C0bcr|%C0bclr} %T0,%j0"
9188   [(set_attr "type" "branch")
9189    (set_attr "length" "8")])
9190
9191 ;; Unconditional branch and return.
9192
9193 (define_insn "jump"
9194   [(set (pc)
9195         (label_ref (match_operand 0 "" "")))]
9196   ""
9197   "b %l0"
9198   [(set_attr "type" "branch")])
9199
9200 (define_insn "return"
9201   [(return)]
9202   "direct_return ()"
9203   "{br|blr}"
9204   [(set_attr "type" "jmpreg")])
9205
9206 (define_insn "indirect_jump"
9207   [(set (pc) (match_operand:SI 0 "register_operand" "c,l"))]
9208   ""
9209   "@
9210    bctr
9211    {br|blr}"
9212   [(set_attr "type" "jmpreg")])
9213
9214 (define_insn ""
9215   [(set (pc) (match_operand:DI 0 "register_operand" "c,l"))]
9216   "TARGET_POWERPC64"
9217   "@
9218    bctr
9219    {br|blr}"
9220   [(set_attr "type" "jmpreg")])
9221
9222 ;; Table jump for switch statements:
9223 (define_expand "tablejump"
9224   [(use (match_operand 0 "" ""))
9225    (use (label_ref (match_operand 1 "" "")))]
9226   ""
9227   "
9228 {
9229   if (TARGET_32BIT)
9230     emit_jump_insn (gen_tablejumpsi (operands[0], operands[1]));
9231   else
9232     emit_jump_insn (gen_tablejumpdi (operands[0], operands[1]));
9233   DONE;
9234 }")
9235
9236 (define_expand "tablejumpsi"
9237   [(set (match_dup 3)
9238         (plus:SI (match_operand:SI 0 "" "")
9239                  (match_dup 2)))
9240    (parallel [(set (pc) (match_dup 3))
9241               (use (label_ref (match_operand 1 "" "")))])]
9242   ""
9243   "
9244 { operands[0] = force_reg (SImode, operands[0]);
9245   operands[2] = force_reg (SImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
9246   operands[3] = gen_reg_rtx (SImode);
9247 }")
9248
9249 (define_expand "tablejumpdi"
9250   [(set (match_dup 3)
9251         (plus:DI (match_operand:DI 0 "" "")
9252                  (match_dup 2)))
9253    (parallel [(set (pc) (match_dup 3))
9254               (use (label_ref (match_operand 1 "" "")))])]
9255   ""
9256   "
9257 { operands[0] = force_reg (DImode, operands[0]);
9258   operands[2] = force_reg (DImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
9259   operands[3] = gen_reg_rtx (DImode);
9260 }")
9261
9262 (define_insn ""
9263   [(set (pc)
9264         (match_operand:SI 0 "register_operand" "c,l"))
9265    (use (label_ref (match_operand 1 "" "")))]
9266   ""
9267   "@
9268    bctr
9269    {br|blr}"
9270   [(set_attr "type" "jmpreg")])
9271
9272 (define_insn ""
9273   [(set (pc)
9274         (match_operand:DI 0 "register_operand" "c,l"))
9275    (use (label_ref (match_operand 1 "" "")))]
9276   "TARGET_POWERPC64"
9277   "@
9278    bctr
9279    {br|blr}"
9280   [(set_attr "type" "jmpreg")])
9281
9282 (define_insn "nop"
9283   [(const_int 0)]
9284   ""
9285   "{cror 0,0,0|nop}")
9286 \f
9287 ;; Define the subtract-one-and-jump insns, starting with the template
9288 ;; so loop.c knows what to generate.
9289
9290 (define_expand "decrement_and_branch_on_count"
9291   [(parallel [(set (pc) (if_then_else (ne (match_operand:SI 0 "register_operand" "")
9292                                           (const_int 1))
9293                                       (label_ref (match_operand 1 "" ""))
9294                                       (pc)))
9295               (set (match_dup 0)
9296                    (plus:SI (match_dup 0)
9297                             (const_int -1)))
9298               (clobber (match_scratch:CC 2 ""))
9299               (clobber (match_scratch:SI 3 ""))])]
9300   ""
9301   "")
9302
9303 ;; We need to be able to do this for any operand, including MEM, or we
9304 ;; will cause reload to blow up since we don't allow output reloads on
9305 ;; JUMP_INSNs.
9306 ;; In order that the length attribute is calculated correctly, the
9307 ;; label MUST be operand 0.
9308
9309 (define_insn ""
9310   [(set (pc)
9311         (if_then_else (ne (match_operand:SI 1 "register_operand" "c,*r,*r")
9312                           (const_int 1))
9313                       (label_ref (match_operand 0 "" ""))
9314                       (pc)))
9315    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9316         (plus:SI (match_dup 1)
9317                  (const_int -1)))
9318    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9319    (clobber (match_scratch:SI 4 "=X,X,r"))]
9320   ""
9321   "*
9322 {
9323   if (which_alternative != 0)
9324     return \"#\";
9325   else if (get_attr_length (insn) == 8)
9326     return \"{bdn|bdnz} %l0\";
9327   else
9328     return \"bdz %$+8\;b %l0\";
9329 }"
9330   [(set_attr "type" "branch")
9331    (set_attr "length" "*,12,16")])
9332
9333 (define_insn ""
9334   [(set (pc)
9335         (if_then_else (ne (match_operand:SI 1 "register_operand" "c,*r,*r")
9336                           (const_int 1))
9337                       (pc)
9338                       (label_ref (match_operand 0 "" ""))))
9339    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9340         (plus:SI (match_dup 1)
9341                  (const_int -1)))
9342    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9343    (clobber (match_scratch:SI 4 "=X,X,r"))]
9344   ""
9345   "*
9346 {
9347   if (which_alternative != 0)
9348     return \"#\";
9349   else if (get_attr_length (insn) == 8)
9350     return \"bdz %l0\";
9351   else
9352     return \"{bdn|bdnz} %$+8\;b %l0\";
9353 }"
9354   [(set_attr "type" "branch")
9355    (set_attr "length" "*,12,16")])
9356
9357 ;; Similar, but we can use GE since we have a REG_NONNEG.
9358 (define_insn ""
9359   [(set (pc)
9360         (if_then_else (ge (match_operand:SI 1 "register_operand" "c,*r,*r")
9361                           (const_int 0))
9362                       (label_ref (match_operand 0 "" ""))
9363                       (pc)))
9364    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9365         (plus:SI (match_dup 1)
9366                  (const_int -1)))
9367    (clobber (match_scratch:CC 3 "=X,&x,&X"))
9368    (clobber (match_scratch:SI 4 "=X,X,r"))]
9369   "find_reg_note (insn, REG_NONNEG, 0)"
9370   "*
9371 {
9372   if (which_alternative != 0)
9373     return \"#\";
9374   else if (get_attr_length (insn) == 8)
9375     return \"{bdn|bdnz} %l0\";
9376   else
9377     return \"bdz %$+8\;b %l0\";
9378 }"
9379   [(set_attr "type" "branch")
9380    (set_attr "length" "*,12,16")])
9381
9382 (define_insn ""
9383   [(set (pc)
9384         (if_then_else (ge (match_operand:SI 1 "register_operand" "c,*r,*r")
9385                           (const_int 0))
9386                       (pc)
9387                       (label_ref (match_operand 0 "" ""))))
9388    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9389         (plus:SI (match_dup 1)
9390                  (const_int -1)))
9391    (clobber (match_scratch:CC 3 "=X,&x,&X"))
9392    (clobber (match_scratch:SI 4 "=X,X,r"))]
9393   "find_reg_note (insn, REG_NONNEG, 0)"
9394   "*
9395 {
9396   if (which_alternative != 0)
9397     return \"#\";
9398   else if (get_attr_length (insn) == 8)
9399     return \"bdz %l0\";
9400   else
9401     return \"{bdn|bdnz} %$+8\;b %l0\";
9402 }"
9403   [(set_attr "type" "branch")
9404    (set_attr "length" "*,12,16")])
9405
9406 (define_insn ""
9407   [(set (pc)
9408         (if_then_else (eq (match_operand:SI 1 "register_operand" "c,*r,*r")
9409                           (const_int 1))
9410                       (label_ref (match_operand 0 "" ""))
9411                       (pc)))
9412    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9413         (plus:SI (match_dup 1)
9414                  (const_int -1)))
9415    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9416    (clobber (match_scratch:SI 4 "=X,X,r"))]
9417   ""
9418   "*
9419 {
9420   if (which_alternative != 0)
9421     return \"#\";
9422   else if (get_attr_length (insn) == 8)
9423     return \"bdz %l0\";
9424   else
9425     return \"{bdn|bdnz} %$+8\;b %l0\";
9426 }"
9427   [(set_attr "type" "branch")
9428    (set_attr "length" "*,12,16")])
9429
9430 (define_insn ""
9431   [(set (pc)
9432         (if_then_else (eq (match_operand:SI 1 "register_operand" "c,*r,*r")
9433                           (const_int 1))
9434                       (pc)
9435                       (label_ref (match_operand 0 "" ""))))
9436    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9437         (plus:SI (match_dup 1)
9438                  (const_int -1)))
9439    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9440    (clobber (match_scratch:SI 4 "=X,X,r"))]
9441   ""
9442   "*
9443 {
9444   if (which_alternative != 0)
9445     return \"#\";
9446   else if (get_attr_length (insn) == 8)
9447     return \"{bdn|bdnz} %l0\";
9448   else
9449     return \"bdz %$+8\;b %l0\";
9450 }"
9451   [(set_attr "type" "branch")
9452    (set_attr "length" "*,12,16")])
9453
9454 (define_split
9455   [(set (pc)
9456         (if_then_else (match_operator 2 "comparison_operator"
9457                                       [(match_operand:SI 1 "gpc_reg_operand" "")
9458                                        (const_int 1)])
9459                       (match_operand 5 "" "")
9460                       (match_operand 6 "" "")))
9461    (set (match_operand:SI 0 "gpc_reg_operand" "")
9462         (plus:SI (match_dup 1)
9463                  (const_int -1)))
9464    (clobber (match_scratch:CC 3 ""))
9465    (clobber (match_scratch:SI 4 ""))]
9466   "reload_completed"
9467   [(parallel [(set (match_dup 3)
9468                    (compare:CC (plus:SI (match_dup 1)
9469                                         (const_int -1))
9470                                (const_int 0)))
9471               (set (match_dup 0)
9472                    (plus:SI (match_dup 1)
9473                             (const_int -1)))])
9474    (set (pc) (if_then_else (match_dup 7)
9475                            (match_dup 5)
9476                            (match_dup 6)))]
9477   "
9478 { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
9479                          const0_rtx); }")
9480
9481 (define_split
9482   [(set (pc)
9483         (if_then_else (match_operator 2 "comparison_operator"
9484                                       [(match_operand:SI 1 "gpc_reg_operand" "")
9485                                        (const_int 1)])
9486                       (match_operand 5 "" "")
9487                       (match_operand 6 "" "")))
9488    (set (match_operand:SI 0 "general_operand" "")
9489         (plus:SI (match_dup 1) (const_int -1)))
9490    (clobber (match_scratch:CC 3 ""))
9491    (clobber (match_scratch:SI 4 ""))]
9492   "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
9493   [(parallel [(set (match_dup 3)
9494                    (compare:CC (plus:SI (match_dup 1)
9495                                         (const_int -1))
9496                                (const_int 0)))
9497               (set (match_dup 4)
9498                    (plus:SI (match_dup 1)
9499                             (const_int -1)))])
9500    (set (match_dup 0)
9501         (match_dup 4))
9502    (set (pc) (if_then_else (match_dup 7)
9503                            (match_dup 5)
9504                            (match_dup 6)))]
9505   "
9506 { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
9507                          const0_rtx); }")