gcc/config/rs6000/rs6000.md

   1 ;; Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
   2 ;; Copyright (C) 1990, 91, 92, 93, 94, 95, 1996 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 2) (match_dup 0)))]
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 0) (match_dup 2)))]
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) & 0xffff);
3674       output_asm_insn (\"{cau %0,%2(%1)|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)
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)
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
3745   if (rs6000_fpmem_offset > 32760)
3746     indx = operands[1];
3747   else if (frame_pointer_needed)
3748     indx = frame_pointer_rtx;
3749   else
3750     indx = stack_pointer_rtx;
3751
3752   operands[2] = gen_rtx (MEM, SImode,
3753                          gen_rtx (PLUS, Pmode,
3754                                   indx,
3755                                   GEN_INT (rs6000_fpmem_offset)));
3756
3757   return \"lfd %0,%2\";
3758 }"
3759   [(set_attr "type" "fpload")])
3760
3761 (define_expand "fix_truncdfsi2"
3762   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
3763                    (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))
3764               (clobber (match_dup 2))
3765               (clobber (match_dup 3))
3766               (clobber (match_dup 4))])]
3767   "TARGET_HARD_FLOAT"
3768   "
3769 {
3770   if (!TARGET_POWER2 && !TARGET_POWERPC)
3771     {
3772       emit_insn (gen_trunc_call (operands[0], operands[1],
3773                                  gen_rtx (SYMBOL_REF, Pmode, RS6000_ITRUNC)));
3774       DONE;
3775     }
3776
3777   operands[2] = gen_reg_rtx (DImode);
3778   operands[3] = gen_reg_rtx (Pmode);
3779   operands[4] = gen_rtx (REG, DImode, FPMEM_REGNUM);
3780 }")
3781
3782 (define_insn "*fix_truncdfsi2_internal"
3783   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3784         (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
3785    (clobber (match_operand:DI 2 "gpc_reg_operand" "=f"))
3786    (clobber (match_operand:SI 3 "gpc_reg_operand" "=b"))
3787    (clobber (reg:DI 76))]
3788   "TARGET_HARD_FLOAT"
3789   "#"
3790   [(set_attr "length" "12")])
3791
3792 (define_split
3793   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3794         (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f")))
3795    (clobber (match_operand:DI 2 "gpc_reg_operand" ""))
3796    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))
3797    (clobber (reg:DI 76))]
3798   "TARGET_HARD_FLOAT"
3799   [(set (match_dup 2)
3800         (sign_extend:DI (fix:SI (match_operand:DF 1 "gpc_reg_operand" ""))))
3801    (set (match_dup 3)
3802         (unspec [(const_int 0)] 11))
3803    (set (match_dup 4)
3804         (unspec [(match_dup 2)
3805                  (match_dup 3)] 15))
3806    (set (match_operand:SI 0 "gpc_reg_operand" "")
3807         (unspec [(match_dup 4)
3808                  (match_dup 3)] 16))]
3809   "operands[4] = gen_rtx (REG, DImode, FPMEM_REGNUM);")
3810
3811 (define_insn "*fctiwz"
3812   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
3813         (sign_extend:DI (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f"))))]
3814   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3815   "{fcirz|fctiwz} %0,%1"
3816   [(set_attr "type" "fp")])
3817
3818 (define_insn "*fix_truncdfsi2_store"
3819   [(set (reg:DI 76)
3820         (unspec [(match_operand:DI 0 "gpc_reg_operand" "f")
3821                  (match_operand:SI 1 "gpc_reg_operand" "b")] 15))]
3822   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3823   "*
3824 {
3825   rtx indx;
3826
3827   if (rs6000_fpmem_offset > 32760)
3828     indx = operands[1];
3829   else if (frame_pointer_needed)
3830     indx = frame_pointer_rtx;
3831   else
3832     indx = stack_pointer_rtx;
3833
3834   operands[2] = gen_rtx (MEM, DFmode,
3835                          gen_rtx (PLUS, Pmode,
3836                                   indx,
3837                                   GEN_INT ((rs6000_fpmem_offset & 0xffff))));
3838
3839   return \"stfd %0,%2\";
3840 }"
3841   [(set_attr "type" "fpstore")])
3842
3843 (define_insn "*fix_truncdfsi2_load"
3844   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3845         (unspec [(reg:DI 76)
3846                  (match_operand:SI 1 "gpc_reg_operand" "b")] 16))]
3847   "(TARGET_POWER2 || TARGET_POWERPC) && TARGET_HARD_FLOAT"
3848   "*
3849 {
3850   rtx indx;
3851
3852   if (rs6000_fpmem_offset > 32760)
3853     indx = operands[1];
3854   else if (frame_pointer_needed)
3855     indx = frame_pointer_rtx;
3856   else
3857     indx = stack_pointer_rtx;
3858
3859   operands[2] = gen_rtx (MEM, DFmode,
3860                          gen_rtx (PLUS, Pmode,
3861                                   indx,
3862                                   GEN_INT ((rs6000_fpmem_offset & 0xffff)
3863                                            + ((WORDS_BIG_ENDIAN) ? 4 : 0))));
3864
3865   return \"{l|lwz} %0,%2\";
3866 }"
3867   [(set_attr "type" "load")])
3868
3869 (define_expand "fixuns_truncdfsi2"
3870   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3871         (unsigned_fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
3872   "! TARGET_POWER2 && ! TARGET_POWERPC && TARGET_HARD_FLOAT"
3873   "
3874 {
3875   emit_insn (gen_trunc_call (operands[0], operands[1],
3876                              gen_rtx (SYMBOL_REF, Pmode, RS6000_UITRUNC)));
3877   DONE;
3878 }")
3879
3880 (define_expand "trunc_call"
3881   [(parallel [(set (match_operand:SI 0 "" "")
3882                    (fix:SI (match_operand:DF 1 "" "")))
3883               (use (match_operand:SI 2 "" ""))])]
3884   "TARGET_HARD_FLOAT"
3885   "
3886 {
3887   rtx insns = gen_trunc_call_rtl (operands[0], operands[1], operands[2]);
3888   rtx first = XVECEXP (insns, 0, 0);
3889   rtx last = XVECEXP (insns, 0, XVECLEN (insns, 0) - 1);
3890
3891   REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
3892                                REG_NOTES (first));
3893   REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
3894
3895   emit_insn (insns);
3896   DONE;
3897 }")
3898
3899 (define_expand "trunc_call_rtl"
3900   [(set (reg:DF 33) (match_operand:DF 1 "gpc_reg_operand" ""))
3901    (use (reg:DF 33))
3902    (parallel [(set (reg:SI 3)
3903                    (call (mem:SI (match_operand 2 "" "")) (const_int 0)))
3904               (use (const_int 0))
3905               (clobber (scratch:SI))])
3906    (set (match_operand:SI 0 "gpc_reg_operand" "")
3907         (reg:SI 3))]
3908   "TARGET_HARD_FLOAT"
3909   "
3910 {
3911   rs6000_trunc_used = 1;
3912 }")
3913
3914 (define_insn "floatdidf2"
3915   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
3916         (float:DF (match_operand:DI 1 "gpc_reg_operand" "f")))]
3917   "TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3918   "fcfid %0,%1"
3919   [(set_attr "type" "fp")])
3920
3921 (define_insn "fix_truncdfdi2"
3922   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
3923         (fix:DI (match_operand:DF 1 "gpc_reg_operand" "f")))]
3924   "TARGET_POWERPC64 && TARGET_HARD_FLOAT"
3925   "fctidz %0,%1"
3926   [(set_attr "type" "fp")])
3927 \f
3928 ;; Define the DImode operations that can be done in a small number
3929 ;; of instructions.  The & constraints are to prevent the register
3930 ;; allocator from allocating registers that overlap with the inputs
3931 ;; (for example, having an input in 7,8 and an output in 6,7).  We
3932 ;; also allow for the the output being the same as one of the inputs.
3933
3934 (define_insn "*adddi3_noppc64"
3935   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r")
3936         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,0,0")
3937                  (match_operand:DI 2 "reg_or_short_operand" "r,I,r,I")))]
3938   "! TARGET_POWERPC64"
3939   "*
3940 {
3941   if (WORDS_BIG_ENDIAN)
3942     return (GET_CODE (operands[2])) != CONST_INT
3943             ? \"{a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2\"
3944             : \"{ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1\";
3945   else
3946     return (GET_CODE (operands[2])) != CONST_INT
3947             ? \"{a|addc} %0,%1,%2\;{ae|adde} %L0,%L1,%L2\"
3948             : \"{ai|addic} %0,%1,%2\;{a%G2e|add%G2e} %L0,%L1\";
3949 }"
3950   [(set_attr "length" "8")])
3951
3952 (define_insn "*subdi3_noppc64"
3953   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,&r,r,r,r")
3954         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I,0,r,I")
3955                   (match_operand:DI 2 "gpc_reg_operand" "r,r,r,0,0")))]
3956   "! TARGET_POWERPC64"
3957   "*
3958 {
3959   if (WORDS_BIG_ENDIAN)
3960     return (GET_CODE (operands[1]) != CONST_INT)
3961             ? \"{sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1\"
3962             : \"{sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2\";
3963   else
3964     return (GET_CODE (operands[1]) != CONST_INT)
3965             ? \"{sf|subfc} %0,%2,%1\;{sfe|subfe} %L0,%L2,%L1\"
3966             : \"{sfi|subfic} %0,%2,%1\;{sf%G1e|subf%G1e} %L0,%L2\";
3967 }"
3968   [(set_attr "length" "8")])
3969
3970 (define_insn "*negdi2_noppc64"
3971   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
3972         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))]
3973   "! TARGET_POWERPC64"
3974   "*
3975 {
3976   return (WORDS_BIG_ENDIAN)
3977     ? \"{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1\"
3978     : \"{sfi|subfic} %0,%1,0\;{sfze|subfze} %L0,%L1\";
3979 }"
3980   [(set_attr "length" "8")])
3981
3982 (define_expand "mulsidi3"
3983   [(set (match_operand:DI 0 "gpc_reg_operand" "")
3984         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
3985                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
3986   ""
3987   "
3988 {
3989   if (! TARGET_POWER && ! TARGET_POWERPC)
3990     {
3991       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
3992       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
3993       emit_insn (gen_mull_call ());
3994       if (WORDS_BIG_ENDIAN)
3995         emit_move_insn (operands[0], gen_rtx (REG, DImode, 3));
3996       else
3997         {
3998           emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
3999                           gen_rtx (REG, SImode, 3));
4000           emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
4001                           gen_rtx (REG, SImode, 4));
4002         }
4003       DONE;
4004     }
4005   else if (TARGET_POWER)
4006     {
4007       emit_insn (gen_mulsidi3_mq (operands[0], operands[1], operands[2]));
4008       DONE;
4009     }
4010 }")
4011
4012 (define_insn "mulsidi3_mq"
4013   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4014         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4015                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
4016    (clobber (match_scratch:SI 3 "=q"))]
4017   "TARGET_POWER"
4018   "mul %0,%1,%2\;mfmq %L0"
4019   [(set_attr "type" "imul")
4020    (set_attr "length" "8")])
4021
4022 (define_insn "*mulsidi3_powerpc"
4023   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4024         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4025                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
4026   "TARGET_POWERPC && ! TARGET_POWERPC64"
4027   "*
4028 {
4029   return (WORDS_BIG_ENDIAN)
4030     ? \"mulhw %0,%1,%2\;mullw %L0,%1,%2\"
4031     : \"mulhw %L0,%1,%2\;mullw %0,%1,%2\";
4032 }"
4033   [(set_attr "type" "imul")
4034    (set_attr "length" "8")])
4035
4036 (define_split
4037   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4038         (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
4039                  (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
4040   "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
4041   [(set (match_dup 3)
4042         (truncate:SI
4043          (lshiftrt:DI (mult:DI (sign_extend:DI (match_dup 1))
4044                                (sign_extend:DI (match_dup 2)))
4045                       (const_int 32))))
4046    (set (match_dup 4)
4047         (mult:SI (match_dup 1)
4048                  (match_dup 2)))]
4049   "
4050 {
4051   int endian = (WORDS_BIG_ENDIAN == 0);
4052   operands[3] = operand_subword (operands[0], endian, 0, DImode);
4053   operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
4054 }")
4055
4056 (define_insn "umulsidi3"
4057   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4058         (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
4059                  (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
4060   "TARGET_POWERPC && ! TARGET_POWERPC64"
4061   "*
4062 {
4063   return (WORDS_BIG_ENDIAN)
4064     ? \"mulhwu %0,%1,%2\;mullw %L0,%1,%2\"
4065     : \"mulhwu %L0,%1,%2\;mullw %0,%1,%2\";
4066 }"
4067   [(set_attr "type" "imul")
4068    (set_attr "length" "8")])
4069
4070 (define_split
4071   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4072         (mult:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
4073                  (zero_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
4074   "TARGET_POWERPC && ! TARGET_POWERPC64 && reload_completed"
4075   [(set (match_dup 3)
4076         (truncate:SI
4077          (lshiftrt:DI (mult:DI (zero_extend:DI (match_dup 1))
4078                                (zero_extend:DI (match_dup 2)))
4079                       (const_int 32))))
4080    (set (match_dup 4)
4081         (mult:SI (match_dup 1)
4082                  (match_dup 2)))]
4083   "
4084 {
4085   int endian = (WORDS_BIG_ENDIAN == 0);
4086   operands[3] = operand_subword (operands[0], endian, 0, DImode);
4087   operands[4] = operand_subword (operands[0], 1 - endian, 0, DImode);
4088 }")
4089
4090 (define_expand "smulsi3_highpart"
4091   [(set (match_operand:SI 0 "gpc_reg_operand" "")
4092         (truncate:SI
4093          (lshiftrt:DI (mult:DI (sign_extend:DI
4094                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4095                                (sign_extend:DI
4096                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4097                       (const_int 32))))]
4098   ""
4099   "
4100 {
4101   if (! TARGET_POWER && ! TARGET_POWERPC)
4102     {
4103       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
4104       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
4105       emit_insn (gen_mulh_call ());
4106       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
4107       DONE;
4108     }
4109   else if (TARGET_POWER)
4110     {
4111       emit_insn (gen_smulsi3_highpart_mq (operands[0], operands[1], operands[2]));
4112       DONE;
4113     }
4114 }")
4115
4116 (define_insn "smulsi3_highpart_mq"
4117   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4118         (truncate:SI
4119          (lshiftrt:DI (mult:DI (sign_extend:DI
4120                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4121                                (sign_extend:DI
4122                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4123                       (const_int 32))))
4124    (clobber (match_scratch:SI 3 "=q"))]
4125   "TARGET_POWER"
4126   "mul %0,%1,%2"
4127   [(set_attr "type" "imul")])
4128
4129 (define_insn ""
4130   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4131         (truncate:SI
4132          (lshiftrt:DI (mult:DI (sign_extend:DI
4133                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4134                                (sign_extend:DI
4135                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4136                       (const_int 32))))]
4137   "TARGET_POWERPC"
4138   "mulhw %0,%1,%2"
4139   [(set_attr "type" "imul")])
4140
4141 (define_insn "umulsi3_highpart"
4142   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
4143         (truncate:SI
4144          (lshiftrt:DI (mult:DI (zero_extend:DI
4145                                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
4146                                (zero_extend:DI
4147                                 (match_operand:SI 2 "gpc_reg_operand" "r")))
4148                       (const_int 32))))]
4149   "TARGET_POWERPC"
4150   "mulhwu %0,%1,%2"
4151   [(set_attr "type" "imul")])
4152
4153 ;; If operands 0 and 2 are in the same register, we have a problem.  But
4154 ;; operands 0 and 1 (the usual case) can be in the same register.  That's
4155 ;; why we have the strange constraints below.
4156 (define_insn "ashldi3_power"
4157   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
4158         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
4159                    (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
4160    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
4161   "TARGET_POWER"
4162   "@
4163    {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
4164    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
4165    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
4166    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
4167   [(set_attr "length" "8")])
4168
4169 (define_insn "lshrdi3_power"
4170   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r,r,&r")
4171         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
4172                      (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
4173    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
4174   "TARGET_POWER"
4175   "@
4176    {cal %0,0(0)|li %0,0}\;{s%A2i|s%A2wi} %L0,%1,%h2
4177    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
4178    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
4179    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
4180   [(set_attr "length" "8")])
4181
4182 ;; Shift by a variable amount is too complex to be worth open-coding.  We
4183 ;; just handle shifts by constants.
4184 (define_insn "ashrdi3_power"
4185   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
4186         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
4187                      (match_operand:SI 2 "const_int_operand" "M,i")))
4188    (clobber (match_scratch:SI 3 "=X,q"))]
4189   "TARGET_POWER"
4190   "@
4191    {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
4192    sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
4193   [(set_attr "length" "8")])
4194 \f
4195 ;; PowerPC64 DImode operations.
4196
4197 (define_expand "adddi3"
4198   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4199         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
4200                  (match_operand:DI 2 "add_operand" "")))]
4201   ""
4202   "
4203 {
4204   if (! TARGET_POWERPC64 && non_add_cint_operand (operands[2], DImode))
4205     FAIL;
4206 }")
4207
4208 ;; Discourage ai/addic because of carry but provide it in an alternative
4209 ;; allowing register zero as source.
4210
4211 (define_insn ""
4212   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,?r,r")
4213         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,b,r,b")
4214                  (match_operand:DI 2 "add_operand" "r,I,I,J")))]
4215   "TARGET_POWERPC64"
4216   "@
4217    add %0,%1,%2
4218    addi %0,%1,%2
4219    addic %0,%1,%2
4220    addis %0,%1,%v2")
4221
4222 (define_insn ""
4223   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
4224         (compare:CC (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
4225                              (match_operand:DI 2 "reg_or_short_operand" "r,I"))
4226                     (const_int 0)))
4227    (clobber (match_scratch:DI 3 "=r,r"))]
4228   "TARGET_POWERPC64"
4229   "@
4230    add. %3,%1,%2
4231    addic. %3,%1,%2"
4232   [(set_attr "type" "compare")])
4233
4234 (define_insn ""
4235   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
4236         (compare:CC (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
4237                              (match_operand:DI 2 "reg_or_short_operand" "r,I"))
4238                     (const_int 0)))
4239    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
4240         (plus:DI (match_dup 1) (match_dup 2)))]
4241   "TARGET_POWERPC64"
4242   "@
4243    add. %0,%1,%2
4244    addic. %0,%1,%2"
4245   [(set_attr "type" "compare")])
4246
4247 ;; Split an add that we can't do in one insn into two insns, each of which
4248 ;; does one 16-bit part.  This is used by combine.  Note that the low-order
4249 ;; add should be last in case the result gets used in an address.
4250
4251 (define_split
4252   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4253         (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
4254                  (match_operand:DI 2 "non_add_cint_operand" "")))]
4255   "TARGET_POWERPC64"
4256   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 3)))
4257    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
4258 "
4259 {
4260   HOST_WIDE_INT low = INTVAL (operands[2]) & 0xffff;
4261   HOST_WIDE_INT high = INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff);
4262
4263   if (low & 0x8000)
4264     high+=0x10000, low |= ((HOST_WIDE_INT) -1) << 16;
4265
4266   operands[3] = GEN_INT (high);
4267   operands[4] = GEN_INT (low);
4268 }")
4269
4270 (define_insn "one_cmpldi2"
4271   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4272         (not:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4273   "TARGET_POWERPC64"
4274   "nor %0,%1,%1")
4275
4276 (define_insn ""
4277   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4278         (compare:CC (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4279                     (const_int 0)))
4280    (clobber (match_scratch:DI 2 "=r"))]
4281   "TARGET_POWERPC64"
4282   "nor. %2,%1,%1"
4283   [(set_attr "type" "compare")])
4284
4285 (define_insn ""
4286   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
4287         (compare:CC (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4288                     (const_int 0)))
4289    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4290         (not:DI (match_dup 1)))]
4291   "TARGET_POWERPC64"
4292   "nor. %0,%1,%1"
4293   [(set_attr "type" "compare")])
4294
4295 (define_insn ""
4296   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
4297         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
4298                   (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
4299   "TARGET_POWERPC64"
4300   "@
4301    subf %0,%2,%1
4302    subfic %0,%2,%1")
4303
4304 (define_insn ""
4305   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4306         (compare:CC (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4307                               (match_operand:DI 2 "gpc_reg_operand" "r"))
4308                     (const_int 0)))
4309    (clobber (match_scratch:DI 3 "=r"))]
4310   "TARGET_POWERPC64"
4311   "subf. %3,%2,%1"
4312   [(set_attr "type" "compare")])
4313
4314 (define_insn ""
4315   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4316         (compare:CC (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4317                               (match_operand:DI 2 "gpc_reg_operand" "r"))
4318                     (const_int 0)))
4319    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4320         (minus:DI (match_dup 1) (match_dup 2)))]
4321   "TARGET_POWERPC64"
4322   "subf. %0,%2,%1"
4323   [(set_attr "type" "compare")])
4324
4325 (define_expand "subdi3"
4326   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4327         (minus:DI (match_operand:DI 1 "reg_or_short_operand" "")
4328                   (match_operand:DI 2 "reg_or_cint_operand" "")))]
4329   ""
4330   "
4331 {
4332   if (GET_CODE (operands[2]) == CONST_INT)
4333     {
4334       emit_insn (gen_adddi3 (operands[0], operands[1],
4335                              negate_rtx (DImode, operands[2])));
4336       DONE;
4337     }
4338 }")
4339
4340 (define_insn "absdi2"
4341   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4342         (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
4343    (clobber (match_scratch:DI 2 "=&r,&r"))]
4344   "TARGET_POWERPC64"
4345   "sradi %2,%1,31\;xor %0,%2,%1\;subf %0,%2,%0"
4346   [(set_attr "length" "12")])
4347
4348 (define_split
4349   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4350         (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0")))
4351    (clobber (match_scratch:DI 2 "=&r,&r"))]
4352   "TARGET_POWERPC64 && reload_completed"
4353   [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 31)))
4354    (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
4355    (set (match_dup 0) (minus:DI (match_dup 2) (match_dup 0)))]
4356   "")
4357
4358 (define_insn ""
4359   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4360         (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
4361    (clobber (match_scratch:DI 2 "=&r,&r"))]
4362   "TARGET_POWERPC64"
4363   "sradi %2,%1,31\;xor %0,%2,%1\;subf %0,%0,%2"
4364   [(set_attr "length" "12")])
4365
4366 (define_split
4367   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r")
4368         (neg:DI (abs:DI (match_operand:DI 1 "gpc_reg_operand" "r,0"))))
4369    (clobber (match_scratch:DI 2 "=&r,&r"))]
4370   "TARGET_POWERPC64 && reload_completed"
4371   [(set (match_dup 2) (ashiftrt:DI (match_dup 1) (const_int 31)))
4372    (set (match_dup 0) (xor:DI (match_dup 2) (match_dup 1)))
4373    (set (match_dup 0) (minus:DI (match_dup 0) (match_dup 2)))]
4374   "")
4375
4376 (define_expand "negdi2"
4377   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4378         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "")))]
4379   ""
4380   "")
4381
4382 (define_insn ""
4383   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4384         (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4385   "TARGET_POWERPC64"
4386   "neg %0,%1")
4387
4388 (define_insn ""
4389   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4390         (compare:CC (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4391                     (const_int 0)))
4392    (clobber (match_scratch:DI 2 "=r"))]
4393   "TARGET_POWERPC64"
4394   "neg. %2,%1"
4395   [(set_attr "type" "compare")])
4396
4397 (define_insn ""
4398   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
4399         (compare:CC (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4400                     (const_int 0)))
4401    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4402         (neg:DI (match_dup 1)))]
4403   "TARGET_POWERPC64"
4404   "neg. %0,%1"
4405   [(set_attr "type" "compare")])
4406
4407 (define_insn "ffsdi2"
4408   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
4409         (ffs:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
4410   "TARGET_POWERPC64"
4411   "neg %0,%1\;and %0,%0,%1\;cntlzd %0,%0\;subfic %0,%0,64"
4412   [(set_attr "length" "16")])
4413
4414 (define_insn "muldi3"
4415   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4416         (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4417                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4418   "TARGET_POWERPC64"
4419   "mulld %0,%1,%2"
4420    [(set_attr "type" "imul")])
4421
4422 (define_insn "smuldi3_highpart"
4423   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4424         (truncate:DI
4425          (lshiftrt:TI (mult:TI (sign_extend:TI
4426                                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
4427                                (sign_extend:TI
4428                                 (match_operand:DI 2 "gpc_reg_operand" "r")))
4429                       (const_int 64))))]
4430   "TARGET_POWERPC64"
4431   "mulhd %0,%1,%2"
4432   [(set_attr "type" "imul")])
4433
4434 (define_insn "umuldi3_highpart"
4435   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4436         (truncate:DI
4437          (lshiftrt:TI (mult:TI (zero_extend:TI
4438                                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
4439                                (zero_extend:TI
4440                                 (match_operand:DI 2 "gpc_reg_operand" "r")))
4441                       (const_int 64))))]
4442   "TARGET_POWERPC64"
4443   "mulhdu %0,%1,%2"
4444   [(set_attr "type" "imul")])
4445
4446 (define_expand "divdi3"
4447   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4448         (div:DI (match_operand:DI 1 "gpc_reg_operand" "")
4449                 (match_operand:DI 2 "reg_or_cint_operand" "")))]
4450   "TARGET_POWERPC64"
4451   "
4452 {
4453   if (GET_CODE (operands[2]) == CONST_INT
4454       && exact_log2 (INTVAL (operands[2])) >= 0)
4455     ;
4456   else
4457     operands[2] = force_reg (DImode, operands[2]);
4458 }")
4459
4460 (define_expand "moddi3"
4461   [(use (match_operand:DI 0 "gpc_reg_operand" ""))
4462    (use (match_operand:DI 1 "gpc_reg_operand" ""))
4463    (use (match_operand:DI 2 "reg_or_cint_operand" ""))]
4464   "TARGET_POWERPC64"
4465   "
4466 {
4467   int i = exact_log2 (INTVAL (operands[2]));
4468   rtx temp1;
4469   rtx temp2;
4470
4471   if (GET_CODE (operands[2]) != CONST_INT || i < 0)
4472     FAIL;
4473
4474   temp1 = gen_reg_rtx (DImode);
4475   temp2 = gen_reg_rtx (DImode);
4476
4477   emit_insn (gen_divdi3 (temp1, operands[1], operands[2]));
4478   emit_insn (gen_ashldi3 (temp2, temp1, GEN_INT (i)));
4479   emit_insn (gen_subdi3 (operands[0], operands[1], temp2));
4480   DONE;
4481 }")
4482
4483 (define_insn ""
4484   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4485         (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4486                 (match_operand:DI 2 "const_int_operand" "N")))]
4487   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4488   "sradi %0,%1,%p2\;addze %0,%0"
4489   [(set_attr "length" "8")])
4490
4491 (define_insn ""
4492   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4493         (compare:CC (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4494                             (match_operand:DI 2 "const_int_operand" "N"))
4495                     (const_int 0)))
4496    (clobber (match_scratch:DI 3 "=r"))]
4497   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4498   "sradi %3,%1,%p2\;addze. %3,%3"
4499   [(set_attr "type" "compare")
4500    (set_attr "length" "8")])
4501
4502 (define_insn ""
4503   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4504         (compare:CC (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4505                             (match_operand:DI 2 "const_int_operand" "N"))
4506                     (const_int 0)))
4507    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4508         (div:DI (match_dup 1) (match_dup 2)))]
4509   "TARGET_POWERPC64 && exact_log2 (INTVAL (operands[2])) >= 0"
4510   "sradi %0,%1,%p2\;addze. %0,%0"
4511   [(set_attr "type" "compare")
4512    (set_attr "length" "8")])
4513
4514 (define_insn ""
4515   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4516         (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4517                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4518   "TARGET_POWERPC64"
4519   "divd %0,%1,%2"
4520   [(set_attr "type" "idiv")])
4521
4522 (define_insn "udivdi3"
4523   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4524         (udiv:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4525                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
4526   "TARGET_POWERPC64"
4527   "divdu %0,%1,%2"
4528   [(set_attr "type" "idiv")])
4529
4530 (define_insn "rotldi3"
4531   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4532         (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4533                    (match_operand:DI 2 "reg_or_cint_operand" "ri")))]
4534   "TARGET_POWERPC64"
4535   "rld%I2cl %0,%1,%H2,0")
4536
4537 (define_insn ""
4538   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4539         (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4540                                (match_operand:DI 2 "reg_or_cint_operand" "ri"))
4541                     (const_int 0)))
4542    (clobber (match_scratch:DI 3 "=r"))]
4543   "TARGET_POWERPC64"
4544   "rld%I2cl. %3,%1,%H2,0"
4545   [(set_attr "type" "delayed_compare")])
4546
4547 (define_insn ""
4548   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4549         (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4550                                (match_operand:DI 2 "reg_or_cint_operand" "ri"))
4551                     (const_int 0)))
4552    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4553         (rotate:DI (match_dup 1) (match_dup 2)))]
4554   "TARGET_POWERPC64"
4555   "rld%I2cl. %0,%1,%H2,0"
4556   [(set_attr "type" "delayed_compare")])
4557
4558 (define_expand "ashldi3"
4559   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4560         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "")
4561                    (match_operand:SI 2 "reg_or_cint_operand" "")))]
4562   "TARGET_POWERPC64 || TARGET_POWER"
4563   "
4564 {
4565   if (TARGET_POWERPC64)
4566     ;
4567   else if (TARGET_POWER)
4568     {
4569       emit_insn (gen_ashldi3_power (operands[0], operands[1], operands[2]));
4570       DONE;
4571     }
4572   else
4573     FAIL;
4574 }")
4575
4576 (define_insn ""
4577   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4578         (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4579                    (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4580   "TARGET_POWERPC64"
4581   "sld%I2 %0,%1,%H2"
4582   [(set_attr "length" "8")])
4583
4584 (define_insn ""
4585   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4586         (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4587                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4588                     (const_int 0)))
4589    (clobber (match_scratch:DI 3 "=r"))]
4590   "TARGET_POWERPC64"
4591   "sld%I2. %3,%1,%H2"
4592   [(set_attr "type" "delayed_compare")])
4593
4594 (define_insn ""
4595   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4596         (compare:CC (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4597                                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4598                     (const_int 0)))
4599    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4600         (ashift:DI (match_dup 1) (match_dup 2)))]
4601   "TARGET_POWERPC64"
4602   "sld%I2. %0,%1,%H2"
4603   [(set_attr "type" "delayed_compare")])
4604
4605 (define_expand "lshrdi3"
4606   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4607         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
4608                      (match_operand:SI 2 "reg_or_cint_operand" "")))]
4609   "TARGET_POWERPC64 || TARGET_POWER"
4610   "
4611 {
4612   if (TARGET_POWERPC64)
4613     ;
4614   else if (TARGET_POWER)
4615     {
4616       emit_insn (gen_lshrdi3_power (operands[0], operands[1], operands[2]));
4617       DONE;
4618     }
4619   else
4620     FAIL;
4621 }")
4622
4623 (define_insn ""
4624   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4625         (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4626                      (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4627   "TARGET_POWERPC64"
4628   "srd%I2 %0,%1,%H2")
4629
4630 (define_insn ""
4631   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4632         (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4633                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4634                     (const_int 0)))
4635    (clobber (match_scratch:DI 3 "=r"))]
4636   "TARGET_POWERPC64"
4637   "srd%I2. %3,%1,%H2"
4638   [(set_attr "type" "delayed_compare")])
4639
4640 (define_insn ""
4641   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4642         (compare:CC (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4643                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4644                     (const_int 0)))
4645    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4646         (lshiftrt:DI (match_dup 1) (match_dup 2)))]
4647   "TARGET_POWERPC64"
4648   "srd%I2. %0,%1,%H2"
4649   [(set_attr "type" "delayed_compare")])
4650
4651 (define_expand "ashrdi3"
4652   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4653         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
4654                      (match_operand:SI 2 "reg_or_cint_operand" "")))]
4655   "TARGET_POWERPC64 || TARGET_POWER"
4656   "
4657 {
4658   if (TARGET_POWERPC64)
4659     ;
4660   else if (TARGET_POWER && GET_CODE (operands[2]) == CONST_INT)
4661     {
4662       emit_insn (gen_ashrdi3_power (operands[0], operands[1], operands[2]));
4663       DONE;
4664     }
4665   else
4666     FAIL;
4667 }")
4668
4669 (define_insn ""
4670   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4671         (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4672                      (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
4673   "TARGET_POWERPC64"
4674   "srad%I2 %0,%1,%H2")
4675
4676 (define_insn ""
4677   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4678         (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4679                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4680                     (const_int 0)))
4681    (clobber (match_scratch:DI 3 "=r"))]
4682   "TARGET_POWERPC64"
4683   "srad%I2. %3,%1,%H2"
4684   [(set_attr "type" "delayed_compare")])
4685
4686 (define_insn ""
4687   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4688         (compare:CC (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r")
4689                                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
4690                     (const_int 0)))
4691    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4692         (ashiftrt:DI (match_dup 1) (match_dup 2)))]
4693   "TARGET_POWERPC64"
4694   "srad%I2. %0,%1,%H2"
4695   [(set_attr "type" "delayed_compare")])
4696
4697 (define_insn "anddi3"
4698   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4699         (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4700                 (match_operand:DI 2 "and_operand" "?r,K,J")))
4701    (clobber (match_scratch:CC 3 "=X,x,x"))]
4702   "TARGET_POWERPC64"
4703   "@
4704    and %0,%1,%2
4705    andi. %0,%1,%b2
4706    andis. %0,%1,%u2")
4707
4708 (define_insn ""
4709   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x")
4710         (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4711                             (match_operand:DI 2 "and_operand" "r,K,J"))
4712                     (const_int 0)))
4713    (clobber (match_scratch:DI 3 "=r,r,r"))]
4714   "TARGET_POWERPC64"
4715   "@
4716    and. %3,%1,%2
4717    andi. %3,%1,%b2
4718    andis. %3,%1,%u2"
4719   [(set_attr "type" "compare,compare,compare")])
4720
4721 (define_insn ""
4722   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x")
4723         (compare:CC (and:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4724                             (match_operand:DI 2 "and_operand" "r,K,J"))
4725                     (const_int 0)))
4726    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4727         (and:DI (match_dup 1) (match_dup 2)))]
4728   "TARGET_POWERPC64"
4729   "@
4730    and. %0,%1,%2
4731    andi. %0,%1,%b2
4732    andis. %0,%1,%u2"
4733   [(set_attr "type" "compare,compare,compare")])
4734
4735 ;; Take a AND with a constant that cannot be done in a single insn and try to
4736 ;; split it into two insns.  This does not verify that the insns are valid
4737 ;; since this need not be done as combine will do it.
4738
4739 (define_split
4740   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4741         (and:DI (match_operand:DI 1 "gpc_reg_operand" "")
4742                 (match_operand:DI 2 "non_and_cint_operand" "")))]
4743   "TARGET_POWERPC64"
4744   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
4745    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
4746   "
4747 {
4748   int maskval = INTVAL (operands[2]);
4749   int i, transitions, last_bit_value;
4750   int orig = maskval, first_c = maskval, second_c;
4751
4752   /* We know that MASKVAL must have more than 2 bit-transitions.  Start at
4753      the low-order bit and count for the third transition.  When we get there,
4754      make a first mask that has everything to the left of that position
4755      a one.  Then make the second mask to turn off whatever else is needed.  */
4756
4757   for (i = 1, transitions = 0, last_bit_value = maskval & 1; i < 32; i++)
4758     {
4759       if (((maskval >>= 1) & 1) != last_bit_value)
4760         last_bit_value ^= 1, transitions++;
4761
4762       if (transitions > 2)
4763         {
4764           first_c |= (~0) << i;
4765           break;
4766         }
4767     }
4768
4769   second_c = orig | ~ first_c;
4770
4771   operands[3] = gen_rtx (CONST_INT, VOIDmode, first_c);
4772   operands[4] = gen_rtx (CONST_INT, VOIDmode, second_c);
4773 }")
4774
4775 (define_insn "iordi3"
4776   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4777         (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4778                 (match_operand:DI 2 "logical_operand" "r,K,J")))]
4779   "TARGET_POWERPC64"
4780   "@
4781    or %0,%1,%2
4782    ori %0,%1,%b2
4783    oris %0,%1,%u2")
4784
4785 (define_insn ""
4786   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4787         (compare:CC (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4788                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4789                     (const_int 0)))
4790    (clobber (match_scratch:DI 3 "=r"))]
4791   "TARGET_POWERPC64"
4792   "or. %3,%1,%2"
4793   [(set_attr "type" "compare")])
4794
4795 (define_insn ""
4796   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4797         (compare:CC (ior:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4798                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4799                     (const_int 0)))
4800    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4801         (ior:DI (match_dup 1) (match_dup 2)))]
4802   "TARGET_POWERPC64"
4803   "or. %0,%1,%2"
4804   [(set_attr "type" "compare")])
4805
4806 ;; Split an IOR that we can't do in one insn into two insns, each of which
4807 ;; does one 16-bit part.  This is used by combine.
4808
4809 (define_split
4810   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4811         (ior:DI (match_operand:DI 1 "gpc_reg_operand" "")
4812                 (match_operand:DI 2 "non_logical_cint_operand" "")))]
4813   "TARGET_POWERPC64"
4814   [(set (match_dup 0) (ior:DI (match_dup 1) (match_dup 3)))
4815    (set (match_dup 0) (ior:DI (match_dup 0) (match_dup 4)))]
4816 "
4817 {
4818   operands[3] = gen_rtx (CONST_INT, VOIDmode,
4819                          INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
4820   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
4821 }")
4822
4823 (define_insn "xordi3"
4824   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r")
4825         (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r,r")
4826                 (match_operand:DI 2 "logical_operand" "r,K,J")))]
4827   "TARGET_POWERPC64"
4828   "@
4829    xor %0,%1,%2
4830    xori %0,%1,%b2
4831    xoris %0,%1,%u2")
4832
4833 (define_insn ""
4834   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4835         (compare:CC (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4836                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4837                     (const_int 0)))
4838    (clobber (match_scratch:DI 3 "=r"))]
4839   "TARGET_POWERPC64"
4840   "xor. %3,%1,%2"
4841   [(set_attr "type" "compare")])
4842
4843 (define_insn ""
4844   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4845         (compare:CC (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4846                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4847                     (const_int 0)))
4848    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4849         (xor:DI (match_dup 1) (match_dup 2)))]
4850   "TARGET_POWERPC64"
4851   "xor. %0,%1,%2"
4852   [(set_attr "type" "compare")])
4853
4854 ;; Split an XOR that we can't do in one insn into two insns, each of which
4855 ;; does one 16-bit part.  This is used by combine.
4856
4857 (define_split
4858   [(set (match_operand:DI 0 "gpc_reg_operand" "")
4859         (xor:DI (match_operand:DI 1 "gpc_reg_operand" "")
4860                 (match_operand:DI 2 "non_logical_cint_operand" "")))]
4861   "TARGET_POWERPC64"
4862   [(set (match_dup 0) (xor:DI (match_dup 1) (match_dup 3)))
4863    (set (match_dup 0) (xor:DI (match_dup 0) (match_dup 4)))]
4864 "
4865 {
4866   operands[3] = gen_rtx (CONST_INT, VOIDmode,
4867                          INTVAL (operands[2]) & 0xffff0000);
4868   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
4869 }")
4870
4871 (define_insn ""
4872   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4873         (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4874                         (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4875    "TARGET_POWERPC64"
4876    "eqv %0,%1,%2")
4877
4878 (define_insn ""
4879   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4880         (compare:CC (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4881                                     (match_operand:DI 2 "gpc_reg_operand" "r")))
4882                     (const_int 0)))
4883    (clobber (match_scratch:DI 3 "=r"))]
4884    "TARGET_POWERPC64"
4885    "eqv. %3,%1,%2"
4886    [(set_attr "type" "compare")])
4887
4888 (define_insn ""
4889   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4890         (compare:CC (not:DI (xor:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
4891                                     (match_operand:DI 2 "gpc_reg_operand" "r")))
4892                     (const_int 0)))
4893    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4894         (not:DI (xor:DI (match_dup 1) (match_dup 2))))]
4895    "TARGET_POWERPC64"
4896    "eqv. %0,%1,%2"
4897    [(set_attr "type" "compare")])
4898
4899 (define_insn ""
4900   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4901         (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4902                 (match_operand:DI 2 "gpc_reg_operand" "r")))]
4903   "TARGET_POWERPC64"
4904   "andc %0,%2,%1")
4905
4906 (define_insn ""
4907   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4908         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4909                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4910                     (const_int 0)))
4911    (clobber (match_scratch:DI 3 "=r"))]
4912   "TARGET_POWERPC64"
4913   "andc. %3,%2,%1"
4914   [(set_attr "type" "compare")])
4915
4916 (define_insn ""
4917   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4918         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4919                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4920                     (const_int 0)))
4921    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4922         (and:DI (not:DI (match_dup 1)) (match_dup 2)))]
4923   "TARGET_POWERPC64"
4924   "andc. %0,%2,%1"
4925   [(set_attr "type" "compare")])
4926
4927 (define_insn ""
4928   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4929         (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4930                 (match_operand:DI 2 "gpc_reg_operand" "r")))]
4931   "TARGET_POWERPC64"
4932   "orc %0,%2,%1")
4933
4934 (define_insn ""
4935   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4936         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4937                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4938                     (const_int 0)))
4939    (clobber (match_scratch:DI 3 "=r"))]
4940   "TARGET_POWERPC64"
4941   "orc. %3,%2,%1"
4942   [(set_attr "type" "compare")])
4943
4944 (define_insn ""
4945   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4946         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "r"))
4947                             (match_operand:DI 2 "gpc_reg_operand" "r"))
4948                     (const_int 0)))
4949    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4950         (ior:DI (not:DI (match_dup 1)) (match_dup 2)))]
4951   "TARGET_POWERPC64"
4952   "orc. %0,%2,%1"
4953   [(set_attr "type" "compare")])
4954
4955 (define_insn ""
4956   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4957         (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4958                 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4959   "TARGET_POWERPC64"
4960   "nand %0,%1,%2")
4961
4962 (define_insn ""
4963   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4964         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4965                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4966                     (const_int 0)))
4967    (clobber (match_scratch:DI 3 "=r"))]
4968   "TARGET_POWERPC64"
4969   "nand. %3,%1,%2"
4970   [(set_attr "type" "compare")])
4971
4972 (define_insn ""
4973   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
4974         (compare:CC (ior:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4975                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4976                     (const_int 0)))
4977    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
4978         (ior:DI (not:DI (match_dup 1)) (not:DI (match_dup 2))))]
4979   "TARGET_POWERPC64"
4980   "nand. %0,%1,%2"
4981   [(set_attr "type" "compare")])
4982
4983 (define_insn ""
4984   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
4985         (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4986                 (not:DI (match_operand:DI 2 "gpc_reg_operand" "r"))))]
4987   "TARGET_POWERPC64"
4988   "nor %0,%1,%2")
4989
4990 (define_insn ""
4991   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
4992         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
4993                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
4994                     (const_int 0)))
4995    (clobber (match_scratch:DI 3 "=r"))]
4996   "TARGET_POWERPC64"
4997   "nor. %3,%1,%2"
4998   [(set_attr "type" "compare")])
4999
5000 (define_insn ""
5001   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
5002         (compare:CC (and:DI (not:DI (match_operand:DI 1 "gpc_reg_operand" "%r"))
5003                             (not:DI (match_operand:DI 2 "gpc_reg_operand" "r")))
5004                     (const_int 0)))
5005    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
5006         (and:DI (not:DI (match_dup 1)) (not:DI (match_dup 2))))]
5007   "TARGET_POWERPC64"
5008   "nor. %0,%1,%2"
5009   [(set_attr "type" "compare")])
5010 \f
5011 ;; Now define ways of moving data around.
5012
5013 ;; Elf specific ways of loading addresses for non-PIC code.
5014 ;; The output of this could be r0, but we limit it to base
5015 ;; registers, since almost all uses of this will need it
5016 ;; in a base register shortly.
5017 (define_insn "elf_high"
5018   [(set (match_operand:SI 0 "register_operand" "=b")
5019         (high:SI (match_operand 1 "" "")))]
5020   "TARGET_ELF && !TARGET_64BIT"
5021   "{cau|addis} %0,0,%1@ha")
5022
5023 (define_insn "elf_low"
5024   [(set (match_operand:SI 0 "register_operand" "=r")
5025         (lo_sum:SI (match_operand:SI 1 "register_operand" "b")
5026                    (match_operand 2 "" "")))]
5027    "TARGET_ELF && !TARGET_64BIT"
5028    "{cal %0,%a2@l(%1)|addi %0,%1,%2@l}")
5029
5030 ;; Set up a register with a value from the GOT table
5031
5032 (define_expand "movsi_got"
5033   [(set (match_operand:SI 0 "register_operand" "")
5034         (unspec [(match_operand:SI 1 "got_operand" "")
5035                  (match_dup 2)] 8))]
5036   "(DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS) && flag_pic"
5037   "
5038 {
5039   operands[2] = rs6000_got_register (operands[1]);
5040 }")
5041
5042 (define_insn "*movsi_got_internal"
5043   [(set (match_operand:SI 0 "register_operand" "=r")
5044         (unspec [(match_operand:SI 1 "got_operand" "")
5045                  (match_operand:SI 2 "register_operand" "b")] 8))]
5046   "(DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS) && flag_pic == 1"
5047   "{l|lwz} %0,%a1@got(%2)"
5048   [(set_attr "type" "load")])
5049
5050 ;; For SI, we special-case integers that can't be loaded in one insn.  We
5051 ;; do the load 16-bits at a time.  We could do this by loading from memory,
5052 ;; and this is even supposed to be faster, but it is simpler not to get
5053 ;; integers in the TOC.
5054 (define_expand "movsi"
5055   [(set (match_operand:SI 0 "general_operand" "")
5056         (match_operand:SI 1 "any_operand" ""))]
5057   ""
5058   "
5059 {
5060   if (GET_CODE (operands[0]) != REG)
5061     operands[1] = force_reg (SImode, operands[1]);
5062
5063   /* Convert a move of a CONST_DOUBLE into a CONST_INT */
5064   if (GET_CODE (operands[1]) == CONST_DOUBLE)
5065     operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
5066
5067   /* Use default pattern for address of ELF small data */
5068   if (TARGET_ELF
5069       && (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
5070       && (GET_CODE (operands[1]) == SYMBOL_REF || GET_CODE (operands[1]) == CONST)
5071       && small_data_operand (operands[1], SImode))
5072     {
5073       emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1]));
5074       DONE;
5075     }
5076
5077   if ((DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
5078       && flag_pic == 1 && got_operand (operands[1], SImode))
5079     {
5080       emit_insn (gen_movsi_got (operands[0], operands[1]));
5081       DONE;
5082     }
5083
5084   if (TARGET_ELF && TARGET_NO_TOC && !TARGET_64BIT
5085       && CONSTANT_P (operands[1])
5086       && GET_CODE (operands[1]) != HIGH
5087       && GET_CODE (operands[1]) != CONST_INT)
5088     {
5089       rtx target = (reload_completed || reload_in_progress)
5090                         ? operands[0] : gen_reg_rtx (SImode);
5091
5092       /* If this is a function address on -mcall-aixdesc or -mcall-nt,
5093          convert it to the address of the descriptor.  */
5094       if ((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
5095           && GET_CODE (operands[1]) == SYMBOL_REF
5096           && XSTR (operands[1], 0)[0] == '.')
5097         {
5098           char *name = XSTR (operands[1], 0);
5099           rtx new_ref;
5100           while (*name == '.')
5101             name++;
5102           new_ref = gen_rtx (SYMBOL_REF, Pmode, name);
5103           CONSTANT_POOL_ADDRESS_P (new_ref) = CONSTANT_POOL_ADDRESS_P (operands[1]);
5104           SYMBOL_REF_FLAG (new_ref) = SYMBOL_REF_FLAG (operands[1]);
5105           SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
5106           operands[1] = new_ref;
5107         }
5108
5109       emit_insn (gen_elf_high (target, operands[1]));
5110       emit_insn (gen_elf_low (operands[0], target, operands[1]));
5111       DONE;
5112     }
5113
5114   if (GET_CODE (operands[1]) == CONST
5115       && DEFAULT_ABI == ABI_NT
5116       && !side_effects_p (operands[0]))
5117     {
5118       rtx const_term = const0_rtx;
5119       rtx sym = eliminate_constant_term (XEXP (operands[1], 0), &const_term);
5120       if (sym && GET_CODE (const_term) == CONST_INT
5121           && (GET_CODE (sym) == SYMBOL_REF || GET_CODE (sym) == LABEL_REF))
5122         {
5123           unsigned HOST_WIDE_INT value = INTVAL (const_term);
5124           int new_reg_p = (flag_expensive_optimizations
5125                            && !reload_completed
5126                            && !reload_in_progress);
5127           rtx tmp1 = (new_reg_p && value != 0) ? gen_reg_rtx (SImode) : operands[0];
5128
5129           emit_insn (gen_movsi (tmp1, sym));
5130           if (INTVAL (const_term) != 0)
5131             {
5132               if (value + 0x8000 < 0x10000)
5133                 emit_insn (gen_addsi3 (operands[0], tmp1, GEN_INT (value)));
5134
5135               else
5136                 {
5137                   HOST_WIDE_INT high_int = value & (~ (HOST_WIDE_INT) 0xffff);
5138                   HOST_WIDE_INT low_int = value & 0xffff;
5139                   rtx tmp2 = (!new_reg_p || !low_int) ? operands[0] : gen_reg_rtx (Pmode);
5140
5141                   if (low_int & 0x8000)
5142                     high_int += 0x10000, low_int |= ((HOST_WIDE_INT) -1) << 16;
5143
5144                   emit_insn (gen_addsi3 (tmp2, tmp1, GEN_INT (high_int)));
5145                   if (low_int)
5146                     emit_insn (gen_addsi3 (operands[0], tmp2, GEN_INT (low_int)));
5147                 }
5148             }
5149           DONE;
5150         }
5151       else
5152         fatal_insn (\"bad address\", operands[1]);
5153     }
5154
5155   if ((!TARGET_WINDOWS_NT || DEFAULT_ABI != ABI_NT)
5156       && CONSTANT_P (operands[1])
5157       && GET_CODE (operands[1]) != CONST_INT
5158       && GET_CODE (operands[1]) != HIGH
5159       && ! LEGITIMATE_CONSTANT_POOL_ADDRESS_P (operands[1]))
5160     {
5161       /* If we are to limit the number of things we put in the TOC and
5162          this is a symbol plus a constant we can add in one insn,
5163          just put the symbol in the TOC and add the constant.  Don't do
5164          this if reload is in progress.  */
5165       if (GET_CODE (operands[1]) == CONST
5166           && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
5167           && GET_CODE (XEXP (operands[1], 0)) == PLUS
5168           && add_operand (XEXP (XEXP (operands[1], 0), 1), SImode)
5169           && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
5170               || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
5171           && ! side_effects_p (operands[0]))
5172         {
5173           rtx sym = force_const_mem (SImode, XEXP (XEXP (operands[1], 0), 0));
5174           rtx other = XEXP (XEXP (operands[1], 0), 1);
5175
5176           emit_insn (gen_addsi3 (operands[0], force_reg (SImode, sym), other));
5177           DONE;
5178         }
5179
5180       operands[1] = force_const_mem (SImode, operands[1]);
5181       if (! memory_address_p (SImode, XEXP (operands[1], 0))
5182           && ! reload_in_progress)
5183         operands[1] = change_address (operands[1], SImode,
5184                                       XEXP (operands[1], 0));
5185     }
5186 }")
5187
5188 (define_insn ""
5189   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,m,r,r,r,r,r,*q,*c*l,*h")
5190         (match_operand:SI 1 "input_operand" "r,S,T,U,m,r,I,J,n,R,*h,r,r,0"))]
5191   "gpc_reg_operand (operands[0], SImode)
5192    || gpc_reg_operand (operands[1], SImode)"
5193   "@
5194    mr %0,%1
5195    {l|lwz} %0,[toc]%1(2)
5196    {l|lwz} %0,[toc]%l1(2)
5197    {cal|la} %0,%a1
5198    {l%U1%X1|lwz%U1%X1} %0,%1
5199    {st%U0%X0|stw%U0%X0} %1,%0
5200    {lil|li} %0,%1
5201    {liu|lis} %0,%v1
5202    #
5203    {cal|la} %0,%1(%*)
5204    mf%1 %0
5205    mt%0 %1
5206    mt%0 %1
5207    cror 0,0,0"
5208   [(set_attr "type" "*,load,load,*,load,store,*,*,*,*,*,*,mtjmpr,*")
5209    (set_attr "length" "4,4,4,4,4,4,4,4,8,4,4,4,4,4")])
5210
5211 ;; Split a load of a large constant into the appropriate two-insn
5212 ;; sequence.
5213
5214 (define_split
5215   [(set (match_operand:SI 0 "gpc_reg_operand" "")
5216         (match_operand:SI 1 "const_int_operand" ""))]
5217   "(unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
5218    && (INTVAL (operands[1]) & 0xffff) != 0"
5219   [(set (match_dup 0)
5220         (match_dup 2))
5221    (set (match_dup 0)
5222         (ior:SI (match_dup 0)
5223                 (match_dup 3)))]
5224   "
5225 {
5226   operands[2] = gen_rtx (CONST_INT, VOIDmode,
5227                          INTVAL (operands[1]) & 0xffff0000);
5228   operands[3] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[1]) & 0xffff);
5229 }")
5230
5231 (define_insn ""
5232   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
5233         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
5234                     (const_int 0)))
5235    (set (match_operand:SI 0 "gpc_reg_operand" "=r") (match_dup 1))]
5236   ""
5237   "mr. %0,%1"
5238   [(set_attr "type" "compare")])
5239 \f
5240 (define_expand "movhi"
5241   [(set (match_operand:HI 0 "general_operand" "")
5242         (match_operand:HI 1 "any_operand" ""))]
5243   ""
5244   "
5245 {
5246   if (GET_CODE (operands[0]) != REG)
5247     operands[1] = force_reg (HImode, operands[1]);
5248
5249   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
5250     {
5251       operands[1] = force_const_mem (HImode, operands[1]);
5252       if (! memory_address_p (HImode, XEXP (operands[1], 0))
5253           && ! reload_in_progress)
5254         operands[1] = change_address (operands[1], HImode,
5255                                       XEXP (operands[1], 0));
5256     }
5257 }")
5258
5259 (define_insn ""
5260   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
5261         (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
5262   "gpc_reg_operand (operands[0], HImode)
5263    || gpc_reg_operand (operands[1], HImode)"
5264   "@
5265    mr %0,%1
5266    lhz%U1%X1 %0,%1
5267    sth%U0%X0 %1,%0
5268    {lil|li} %0,%w1
5269    mf%1 %0
5270    mt%0 %1
5271    mt%0 %1
5272    cror 0,0,0"
5273   [(set_attr "type" "*,load,store,*,*,*,mtjmpr,*")])
5274
5275 (define_expand "movqi"
5276   [(set (match_operand:QI 0 "general_operand" "")
5277         (match_operand:QI 1 "any_operand" ""))]
5278   ""
5279   "
5280 {
5281   if (GET_CODE (operands[0]) != REG)
5282     operands[1] = force_reg (QImode, operands[1]);
5283
5284   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
5285     {
5286       operands[1] = force_const_mem (QImode, operands[1]);
5287       if (! memory_address_p (QImode, XEXP (operands[1], 0))
5288           && ! reload_in_progress)
5289         operands[1] = change_address (operands[1], QImode,
5290                                       XEXP (operands[1], 0));
5291     }
5292 }")
5293
5294 (define_insn ""
5295   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
5296         (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
5297   "gpc_reg_operand (operands[0], QImode)
5298    || gpc_reg_operand (operands[1], QImode)"
5299   "@
5300    mr %0,%1
5301    lbz%U1%X1 %0,%1
5302    stb%U0%X0 %1,%0
5303    {lil|li} %0,%1
5304    mf%1 %0
5305    mt%0 %1
5306    mt%0 %1
5307    cror 0,0,0"
5308   [(set_attr "type" "*,load,store,*,*,*,mtjmpr,*")])
5309 \f
5310 ;; Here is how to move condition codes around.  When we store CC data in
5311 ;; an integer register or memory, we store just the high-order 4 bits.
5312 ;; This lets us not shift in the most common case of CR0.
5313 (define_expand "movcc"
5314   [(set (match_operand:CC 0 "nonimmediate_operand" "")
5315         (match_operand:CC 1 "nonimmediate_operand" ""))]
5316   ""
5317   "")
5318
5319 (define_insn ""
5320   [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,y,r,r,r,r,m")
5321         (match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,m,r"))]
5322   "register_operand (operands[0], CCmode)
5323    || register_operand (operands[1], CCmode)"
5324   "@
5325    mcrf %0,%1
5326    mtcrf 128,%1
5327    {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
5328    mfcr %0
5329    mfcr %0\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
5330    mr %0,%1
5331    {l%U1%X1|lwz%U1%X1} %0,%1
5332    {st%U0%U1|stw%U0%U1} %1,%0"
5333   [(set_attr "type" "*,*,*,compare,*,*,load,store")
5334    (set_attr "length" "*,*,12,*,8,*,*,*")])
5335 \f
5336 ;; For floating-point, we normally deal with the floating-point registers
5337 ;; unless -msoft-float is used.  The sole exception is that parameter passing
5338 ;; can produce floating-point values in fixed-point registers.  Unless the
5339 ;; value is a simple constant or already in memory, we deal with this by
5340 ;; allocating memory and copying the value explicitly via that memory location.
5341 (define_expand "movsf"
5342   [(set (match_operand:SF 0 "nonimmediate_operand" "")
5343         (match_operand:SF 1 "any_operand" ""))]
5344   ""
5345   "
5346 {
5347   /* If we are called from reload, we might be getting a SUBREG of a hard
5348      reg.  So expand it.  */
5349   if (GET_CODE (operands[0]) == SUBREG
5350       && GET_CODE (SUBREG_REG (operands[0])) == REG
5351       && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER)
5352     operands[0] = alter_subreg (operands[0]);
5353   if (GET_CODE (operands[1]) == SUBREG
5354       && GET_CODE (SUBREG_REG (operands[1])) == REG
5355       && REGNO (SUBREG_REG (operands[1])) < FIRST_PSEUDO_REGISTER)
5356     operands[1] = alter_subreg (operands[1]);
5357
5358   if (TARGET_SOFT_FLOAT && GET_CODE (operands[0]) == MEM)
5359     operands[1] = force_reg (SFmode, operands[1]);
5360
5361   else if (TARGET_HARD_FLOAT)
5362     {
5363       if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 32)
5364         {
5365           /* If this is a store to memory or another integer register do the
5366              move directly.  Otherwise store to a temporary stack slot and
5367              load from there into a floating point register.  */
5368
5369           if (GET_CODE (operands[0]) == MEM
5370               || (GET_CODE (operands[0]) == REG
5371                   && (REGNO (operands[0]) < 32
5372                       || (reload_in_progress
5373                           && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))))
5374             {
5375               emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
5376                               operand_subword (operands[1], 0, 0, SFmode));
5377               DONE;
5378             }
5379           else
5380             {
5381               rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
5382
5383               emit_move_insn (stack_slot, operands[1]);
5384               emit_move_insn (operands[0], stack_slot);
5385               DONE;
5386             }
5387         }
5388
5389       if (GET_CODE (operands[0]) == MEM)
5390         {
5391           /* If operands[1] is a register, it may have double-precision data
5392              in it, so truncate it to single precision.  We need not do
5393              this for POWERPC.  */
5394           if (! TARGET_POWERPC && TARGET_HARD_FLOAT
5395               && GET_CODE (operands[1]) == REG)
5396             {
5397               rtx newreg
5398                 = reload_in_progress ? operands[1] : gen_reg_rtx (SFmode);
5399               emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
5400               operands[1] = newreg;
5401             }
5402
5403           operands[1] = force_reg (SFmode, operands[1]);
5404         }
5405
5406       if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) < 32)
5407         {
5408           if (GET_CODE (operands[1]) == MEM
5409 #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && ! defined(REAL_IS_NOT_DOUBLE)
5410               || GET_CODE (operands[1]) == CONST_DOUBLE
5411 #endif
5412               || (GET_CODE (operands[1]) == REG
5413                   && (REGNO (operands[1]) < 32
5414                       || (reload_in_progress
5415                           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER))))
5416             {
5417               emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
5418                               operand_subword (operands[1], 0, 0, SFmode));
5419               DONE;
5420             }
5421           else
5422             {
5423               rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
5424
5425               emit_move_insn (stack_slot, operands[1]);
5426               emit_move_insn (operands[0], stack_slot);
5427               DONE;
5428             }
5429         }
5430     }
5431
5432   if (CONSTANT_P (operands[1]) && TARGET_HARD_FLOAT)
5433     {
5434       operands[1] = force_const_mem (SFmode, operands[1]);
5435       if (! memory_address_p (SFmode, XEXP (operands[1], 0))
5436           && ! reload_in_progress)
5437         operands[1] = change_address (operands[1], SFmode,
5438                                       XEXP (operands[1], 0));
5439     }
5440 }")
5441
5442 (define_split
5443   [(set (match_operand:SF 0 "gpc_reg_operand" "")
5444         (match_operand:SF 1 "const_double_operand" ""))]
5445   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], SFmode) <= 1 && REGNO (operands[0]) <= 31"
5446   [(set (match_dup 2) (match_dup 3))]
5447   "
5448 {
5449   long l;
5450   REAL_VALUE_TYPE rv;
5451
5452   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
5453   REAL_VALUE_TO_TARGET_SINGLE (rv, l);
5454
5455   operands[2] = gen_rtx (SUBREG, SImode, operands[0], 0);
5456   operands[3] = GEN_INT(l);
5457 }")
5458
5459 (define_split
5460   [(set (match_operand:SF 0 "gpc_reg_operand" "")
5461         (match_operand:SF 1 "const_double_operand" ""))]
5462   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], SFmode) == 2 && REGNO (operands[0]) <= 31"
5463   [(set (match_dup 2) (match_dup 3))
5464    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 4)))]
5465   "
5466 {
5467   long l;
5468   REAL_VALUE_TYPE rv;
5469
5470   REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
5471   REAL_VALUE_TO_TARGET_SINGLE (rv, l);
5472
5473   operands[2] = gen_rtx (SUBREG, SImode, operands[0], 0);
5474   operands[3] = GEN_INT(l & 0xffff0000);
5475   operands[4] = GEN_INT(l & 0x0000ffff);
5476 }")
5477
5478 (define_insn "*movsf_hardfloat"
5479   [(set (match_operand:SF 0 "fp_reg_or_mem_operand" "=f,f,m,!r,!r")
5480         (match_operand:SF 1 "input_operand" "f,m,f,G,Fn"))]
5481   "(gpc_reg_operand (operands[0], SFmode)
5482    || gpc_reg_operand (operands[1], SFmode)) && TARGET_HARD_FLOAT"
5483   "@
5484    fmr %0,%1
5485    lfs%U1%X1 %0,%1
5486    stfs%U0%X0 %1,%0
5487    #
5488    #"
5489   [(set_attr "type" "fp,fpload,fpstore,*,*")
5490    (set_attr "length" "4,4,4,4,8")])
5491
5492 (define_insn "*movsf_softfloat"
5493   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,r")
5494         (match_operand:SF 1 "input_operand" "r,m,r,I,J,R,G,Fn"))]
5495   "(gpc_reg_operand (operands[0], SFmode)
5496    || gpc_reg_operand (operands[1], SFmode)) && TARGET_SOFT_FLOAT"
5497   "@
5498    mr %0,%1
5499    {l%U1%X1|lwz%U1%X1} %0,%1
5500    {st%U0%X0|stw%U0%X0} %1,%0
5501    {lil|li} %0,%1
5502    {liu|lis} %0,%v1
5503    {cal|la} %0,%1(%*)
5504    #
5505    #"
5506   [(set_attr "type" "*,load,store,*,*,*,*,*")
5507    (set_attr "length" "4,4,4,4,4,4,4,8")])
5508
5509 \f
5510 (define_expand "movdf"
5511   [(set (match_operand:DF 0 "nonimmediate_operand" "")
5512         (match_operand:DF 1 "any_operand" ""))]
5513   ""
5514   "
5515 {
5516   if (GET_CODE (operands[0]) != REG)
5517     operands[1] = force_reg (DFmode, operands[1]);
5518
5519       /* Stores between FPR and any non-FPR registers must go through a
5520          temporary stack slot.  */
5521
5522   if (TARGET_POWERPC64
5523       && GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
5524       && ((FP_REGNO_P (REGNO (operands[0]))
5525            && ! FP_REGNO_P (REGNO (operands[1])))
5526           || (FP_REGNO_P (REGNO (operands[1]))
5527               && ! FP_REGNO_P (REGNO (operands[0])))))
5528     {
5529       rtx stack_slot = assign_stack_temp (DFmode, 8, 0);
5530
5531       emit_move_insn (stack_slot, operands[1]);
5532       emit_move_insn (operands[0], stack_slot);
5533       DONE;
5534     }
5535
5536   if (CONSTANT_P (operands[1]) && ! easy_fp_constant (operands[1], DFmode))
5537     {
5538       operands[1] = force_const_mem (DFmode, operands[1]);
5539       if (! memory_address_p (DFmode, XEXP (operands[1], 0))
5540           && ! reload_in_progress)
5541         operands[1] = change_address (operands[1], DFmode,
5542                                       XEXP (operands[1], 0));
5543     }
5544 }")
5545
5546 (define_split
5547   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5548         (match_operand:DF 1 "const_int_operand" ""))]
5549   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) <= 1 && REGNO (operands[0]) <= 31"
5550   [(set (match_dup 2) (match_dup 4))
5551    (set (match_dup 3) (match_dup 1))]
5552   "
5553 {
5554   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5555   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5556   operands[4] = (INTVAL (operands[1]) & 0x80000000) ? constm1_rtx : const0_rtx;
5557 }")
5558
5559 (define_split
5560   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5561         (match_operand:DF 1 "const_int_operand" ""))]
5562   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) >= 2 && REGNO (operands[0]) <= 31"
5563   [(set (match_dup 3) (match_dup 5))
5564    (set (match_dup 2) (match_dup 4))
5565    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 6)))]
5566   "
5567 {
5568   HOST_WIDE_INT value = INTVAL (operands[1]);
5569   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5570   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5571   operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
5572   operands[5] = GEN_INT (value & 0xffff0000);
5573   operands[6] = GEN_INT (value & 0x0000ffff);
5574 }")
5575
5576 (define_split
5577   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5578         (match_operand:DF 1 "const_double_operand" ""))]
5579   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) <= 2 && REGNO (operands[0]) <= 31"
5580   [(set (match_dup 2) (match_dup 4))
5581    (set (match_dup 3) (match_dup 5))]
5582   "
5583 {
5584   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5585   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5586   split_double (operands[1], &operands[4], &operands[5]);
5587 }")
5588
5589 (define_split
5590   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5591         (match_operand:DF 1 "const_double_operand" ""))]
5592   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) == 3 && REGNO (operands[0]) <= 31"
5593   [(set (match_dup 2) (match_dup 4))
5594    (set (match_dup 3) (match_dup 5))
5595    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))]
5596   "
5597 {
5598   rtx high_rtx, low_rtx;
5599   HOST_WIDE_INT high;
5600   HOST_WIDE_INT low;
5601   rtx high_reg = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5602   rtx low_reg  = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5603
5604   split_double (operands[1], &high_rtx, &low_rtx);
5605   high = INTVAL (high_rtx);
5606   low  = INTVAL (low_rtx);
5607
5608   if (((unsigned HOST_WIDE_INT) (low + 0x8000) < 0x10000)
5609       || (low & 0xffff) == 0)
5610     {
5611       operands[2] = high_reg;
5612       operands[3] = low_reg;
5613       operands[4] = GEN_INT (high & 0xffff0000);
5614       operands[5] = GEN_INT (low);
5615       operands[6] = GEN_INT (high & 0x0000ffff);
5616     }
5617   else
5618     {
5619       operands[2] = low_reg;
5620       operands[3] = high_reg;
5621       operands[4] = GEN_INT (low & 0xffff0000);
5622       operands[5] = GEN_INT (high);
5623       operands[6] = GEN_INT (low & 0x0000ffff);
5624     }
5625 }")
5626
5627 (define_split
5628   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5629         (match_operand:DF 1 "const_double_operand" ""))]
5630   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DFmode) >= 4 && REGNO (operands[0]) <= 31"
5631   [(set (match_dup 2) (match_dup 4))
5632    (set (match_dup 3) (match_dup 5))
5633    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))
5634    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 7)))]
5635   "
5636 {
5637   rtx high_rtx, low_rtx;
5638   HOST_WIDE_INT high;
5639   HOST_WIDE_INT low;
5640
5641   split_double (operands[1], &high_rtx, &low_rtx);
5642   high = INTVAL (high_rtx);
5643   low  = INTVAL (low_rtx);
5644
5645   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5646   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5647   operands[4] = GEN_INT (high & 0xffff0000);
5648   operands[5] = GEN_INT (low  & 0xffff0000);
5649   operands[6] = GEN_INT (high & 0x0000ffff);
5650   operands[7] = GEN_INT (low  & 0x0000ffff);
5651 }")
5652
5653 (define_split
5654   [(set (match_operand:DF 0 "gpc_reg_operand" "")
5655         (match_operand:DF 1 "easy_fp_constant" ""))]
5656   "TARGET_64BIT && reload_completed && REGNO (operands[0]) <= 31"
5657   [(set (subreg:DI (match_dup 0) 0) (subreg:DI (match_dup 1) 0))]
5658   "")
5659
5660 ;; Don't have reload use general registers to load a constant.  First,
5661 ;; it might not work if the output operand has is the equivalent of
5662 ;; a non-offsettable memref, but also it is less efficient than loading
5663 ;; the constant into an FP register, since it will probably be used there.
5664 ;; The "??" is a kludge until we can figure out a more reasonable way
5665 ;; of handling these non-offsettable values.
5666 (define_insn "*movdf_hardfloat32"
5667   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,!r,!r,f,f,m")
5668         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F,f,m,f"))]
5669   "! TARGET_POWERPC64 && TARGET_HARD_FLOAT
5670    && (register_operand (operands[0], DFmode)
5671        || register_operand (operands[1], DFmode))"
5672   "*
5673 {
5674   switch (which_alternative)
5675     {
5676     case 0:
5677       /* We normally copy the low-numbered register first.  However, if
5678          the first register operand 0 is the same as the second register of
5679          operand 1, we must copy in the opposite order.  */
5680       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5681         return \"mr %L0,%L1\;mr %0,%1\";
5682       else
5683         return \"mr %0,%1\;mr %L0,%L1\";
5684     case 1:
5685       /* If the low-address word is used in the address, we must load it
5686          last.  Otherwise, load it first.  Note that we cannot have
5687          auto-increment in that case since the address register is known to be
5688          dead.  */
5689       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5690                              operands [1], 0))
5691         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5692       else
5693         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5694     case 2:
5695       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5696     case 3:
5697     case 4:
5698     case 5:
5699       return \"#\";
5700     case 6:
5701       return \"fmr %0,%1\";
5702     case 7:
5703       return \"lfd%U1%X1 %0,%1\";
5704     case 8:
5705       return \"stfd%U0%X0 %1,%0\";
5706     }
5707 }"
5708   [(set_attr "type" "*,load,store,*,*,*,fp,fpload,fpstore")
5709    (set_attr "length" "8,8,8,8,12,16,*,*,*")])
5710
5711 (define_insn "*movdf_softfloat32"
5712   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,o,r,r,r")
5713         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F"))]
5714   "! TARGET_POWERPC64 && TARGET_SOFT_FLOAT
5715    && (register_operand (operands[0], DFmode)
5716        || register_operand (operands[1], DFmode))"
5717   "*
5718 {
5719   switch (which_alternative)
5720     {
5721     case 0:
5722       /* We normally copy the low-numbered register first.  However, if
5723          the first register operand 0 is the same as the second register of
5724          operand 1, we must copy in the opposite order.  */
5725       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5726         return \"mr %L0,%L1\;mr %0,%1\";
5727       else
5728         return \"mr %0,%1\;mr %L0,%L1\";
5729     case 1:
5730       /* If the low-address word is used in the address, we must load it
5731          last.  Otherwise, load it first.  Note that we cannot have
5732          auto-increment in that case since the address register is known to be
5733          dead.  */
5734       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5735                              operands [1], 0))
5736         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5737       else
5738         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5739     case 2:
5740       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5741     case 3:
5742     case 4:
5743     case 5:
5744       return \"#\";
5745     }
5746 }"
5747   [(set_attr "type" "*,load,store,*,*,*")
5748    (set_attr "length" "8,8,8,8,12,16")])
5749
5750 (define_insn "*movdf_hardfloat64"
5751   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,!r,!r,f,f,m")
5752         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F,f,m,f"))]
5753   "TARGET_POWERPC64 && TARGET_HARD_FLOAT
5754    && (register_operand (operands[0], DFmode)
5755        || register_operand (operands[1], DFmode))"
5756   "@
5757    mr %0,%1
5758    ld%U1%X1 %0,%1
5759    std%U0%X0 %1,%0
5760    #
5761    #
5762    #
5763    fmr %0,%1
5764    lfd%U1%X1 %0,%1
5765    stfd%U0%X0 %1,%0"
5766   [(set_attr "type" "*,load,store,*,*,*,fp,fpload,fpstore")
5767    (set_attr "length" "4,4,4,8,12,16,4,4,4")])
5768
5769 (define_insn "*movdf_softfloat64"
5770   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,o,r,r,r")
5771         (match_operand:DF 1 "input_operand" "r,o,r,G,H,F"))]
5772   "TARGET_POWERPC64 && TARGET_SOFT_FLOAT
5773    && (register_operand (operands[0], DFmode)
5774        || register_operand (operands[1], DFmode))"
5775   "@
5776    mr %0,%1
5777    ld%U1%X1 %0,%1
5778    std%U0%X0 %1,%0
5779    #
5780    #
5781    #"
5782   [(set_attr "type" "*,load,store,*,*,*")
5783    (set_attr "length" "*,*,*,8,12,16")])
5784 \f
5785 ;; Next come the multi-word integer load and store and the load and store
5786 ;; multiple insns.
5787 (define_expand "movdi"
5788   [(set (match_operand:DI 0 "general_operand" "")
5789         (match_operand:DI 1 "any_operand" ""))]
5790   ""
5791   "
5792 {
5793   if (GET_CODE (operands[0]) != REG)
5794     operands[1] = force_reg (DImode, operands[1]);
5795
5796   if (TARGET_64BIT
5797       && (GET_CODE (operands[1]) == CONST_DOUBLE
5798           || GET_CODE (operands[1]) == CONST_INT))
5799     {
5800       HOST_WIDE_INT low;
5801       HOST_WIDE_INT high;
5802
5803       if (GET_CODE (operands[1]) == CONST_DOUBLE)
5804         {
5805           rtx high_rtx, low_rtx;
5806           split_double (operands[1], &high_rtx, &low_rtx);
5807           high = INTVAL (high_rtx);
5808           low  = INTVAL (low_rtx);
5809         }
5810       else
5811 #if HOST_BITS_PER_WIDE_INT == 32
5812         {
5813           low = INTVAL (operands[1]);
5814           high = (low < 0) ? ~0 : 0;
5815         }
5816 #else
5817         {
5818           low = INTVAL (operands[1]) & 0xffffffff;
5819           high = (HOST_WIDE_INT) INTVAL (operands[1]) >> 32;
5820         }
5821 #endif
5822
5823         if (high)
5824           {
5825             emit_move_insn (operands[0], GEN_INT (high));
5826             emit_insn (gen_ashldi3 (operands[0], operands[0], GEN_INT(32)));
5827             if (low)
5828               {
5829                 HOST_WIDE_INT low_low = low & 0xffff;
5830                 HOST_WIDE_INT low_high = low & (~ (HOST_WIDE_INT) 0xffff);
5831                 if (low_high)
5832                   emit_insn (gen_iordi3 (operands[0], operands[0],
5833                                          GEN_INT (low_high)));
5834                 if (low_low)
5835                   emit_insn (gen_iordi3 (operands[0], operands[0],
5836                                          GEN_INT (low_low)));
5837               }
5838               DONE;
5839           }
5840     }
5841
5842       /* Stores between FPR and any non-FPR registers must go through a
5843          temporary stack slot.  */
5844
5845   if (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
5846       && ((FP_REGNO_P (REGNO (operands[0]))
5847            && ! FP_REGNO_P (REGNO (operands[1])))
5848           || (FP_REGNO_P (REGNO (operands[1]))
5849               && ! FP_REGNO_P (REGNO (operands[0])))))
5850     {
5851       rtx stack_slot = assign_stack_temp (DImode, 8, 0);
5852
5853       emit_move_insn (stack_slot, operands[1]);
5854       emit_move_insn (operands[0], stack_slot);
5855       DONE;
5856     }
5857 }")
5858
5859 (define_insn "*movdi_32"
5860   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,f,f,m,r,r,r,r,r")
5861         (match_operand:DI 1 "input_operand" "r,m,r,f,m,f,IJK,n,G,H,F"))]
5862   "TARGET_32BIT
5863    && (gpc_reg_operand (operands[0], DImode)
5864        || gpc_reg_operand (operands[1], DImode))"
5865   "*
5866 {
5867   switch (which_alternative)
5868     {
5869     case 0:
5870       /* We normally copy the low-numbered register first.  However, if
5871          the first register operand 0 is the same as the second register of
5872          operand 1, we must copy in the opposite order.  */
5873       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
5874         return \"mr %L0,%L1\;mr %0,%1\";
5875       else
5876         return \"mr %0,%1\;mr %L0,%L1\";
5877     case 1:
5878       /* If the low-address word is used in the address, we must load it
5879          last.  Otherwise, load it first.  Note that we cannot have
5880          auto-increment in that case since the address register is known to be
5881          dead.  */
5882       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
5883                              operands [1], 0))
5884         return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
5885       else
5886         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
5887     case 2:
5888       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
5889     case 3:
5890       return \"fmr %0,%1\";
5891     case 4:
5892       return \"lfd%U1%X1 %0,%1\";
5893     case 5:
5894       return \"stfd%U0%X0 %1,%0\";
5895     case 6:
5896     case 7:
5897     case 8:
5898     case 9:
5899     case 10:
5900       return \"#\";
5901     }
5902 }"
5903   [(set_attr "type" "*,load,store,fp,fpload,fpstore,*,*,*,*,*")
5904    (set_attr "length" "8,8,8,*,*,*,8,12,8,12,16")])
5905
5906 (define_split
5907   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5908         (match_operand:DI 1 "const_int_operand" ""))]
5909   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) <= 1"
5910   [(set (match_dup 2) (match_dup 4))
5911    (set (match_dup 3) (match_dup 1))]
5912   "
5913 {
5914   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5915   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5916   operands[4] = (INTVAL (operands[1]) & 0x80000000) ? constm1_rtx : const0_rtx;
5917 }")
5918
5919 (define_split
5920   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5921         (match_operand:DI 1 "const_int_operand" ""))]
5922   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) >= 2"
5923   [(set (match_dup 3) (match_dup 5))
5924    (set (match_dup 2) (match_dup 4))
5925    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 6)))]
5926   "
5927 {
5928   HOST_WIDE_INT value = INTVAL (operands[1]);
5929   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5930   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5931   operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx;
5932   operands[5] = GEN_INT (value & 0xffff0000);
5933   operands[6] = GEN_INT (value & 0x0000ffff);
5934 }")
5935
5936 (define_split
5937   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5938         (match_operand:DI 1 "const_double_operand" ""))]
5939   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) <= 2"
5940   [(set (match_dup 2) (match_dup 4))
5941    (set (match_dup 3) (match_dup 5))]
5942   "
5943 {
5944   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
5945   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
5946   split_double (operands[1], &operands[4], &operands[5]);
5947 }")
5948
5949 (define_split
5950   [(set (match_operand:DI 0 "gpc_reg_operand" "")
5951         (match_operand:DI 1 "const_double_operand" ""))]
5952   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) == 3"
5953   [(set (match_dup 2) (match_dup 4))
5954    (set (match_dup 3) (match_dup 5))
5955    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))]
5956   "
5957 {
5958   rtx high_rtx, low_rtx;
5959   HOST_WIDE_INT high;
5960   HOST_WIDE_INT low;
5961   rtx high_reg, low_reg;
5962
5963   if (WORDS_BIG_ENDIAN)
5964     {
5965       high_reg = gen_rtx (SUBREG, SImode, operands[0], 0);
5966       low_reg  = gen_rtx (SUBREG, SImode, operands[0], 1);
5967       split_double (operands[1], &high_rtx, &low_rtx);
5968     }
5969   else
5970     {
5971       high_reg = gen_rtx (SUBREG, SImode, operands[0], 1);
5972       low_reg  = gen_rtx (SUBREG, SImode, operands[0], 0);
5973       split_double (operands[1], &low_rtx, &high_rtx);
5974     }
5975
5976   high = INTVAL (high_rtx);
5977   low  = INTVAL (low_rtx);
5978
5979   if (((unsigned HOST_WIDE_INT) (low + 0x8000) < 0x10000)
5980       || (low & 0xffff) == 0)
5981     {
5982       operands[2] = high_reg;
5983       operands[3] = low_reg;
5984       operands[4] = GEN_INT (high & 0xffff0000);
5985       operands[5] = GEN_INT (low);
5986       operands[6] = GEN_INT (high & 0x0000ffff);
5987     }
5988   else
5989     {
5990       operands[2] = low_reg;
5991       operands[3] = high_reg;
5992       operands[4] = GEN_INT (low & 0xffff0000);
5993       operands[5] = GEN_INT (high);
5994       operands[6] = GEN_INT (low & 0x0000ffff);
5995     }
5996 }")
5997
5998 (define_split
5999   [(set (match_operand:DI 0 "gpc_reg_operand" "")
6000         (match_operand:DI 1 "const_double_operand" ""))]
6001   "TARGET_32BIT && reload_completed && num_insns_constant (operands[1], DImode) >= 4"
6002   [(set (match_dup 2) (match_dup 4))
6003    (set (match_dup 3) (match_dup 5))
6004    (set (match_dup 2) (ior:SI (match_dup 2) (match_dup 6)))
6005    (set (match_dup 3) (ior:SI (match_dup 3) (match_dup 7)))]
6006   "
6007 {
6008   rtx high_rtx, low_rtx;
6009   HOST_WIDE_INT high;
6010   HOST_WIDE_INT low;
6011   rtx high_reg, low_reg;
6012
6013   if (WORDS_BIG_ENDIAN)
6014     {
6015       high_reg = gen_rtx (SUBREG, SImode, operands[0], 0);
6016       low_reg  = gen_rtx (SUBREG, SImode, operands[0], 1);
6017       split_double (operands[1], &high_rtx, &low_rtx);
6018     }
6019   else
6020     {
6021       high_reg = gen_rtx (SUBREG, SImode, operands[0], 1);
6022       low_reg  = gen_rtx (SUBREG, SImode, operands[0], 0);
6023       split_double (operands[1], &low_rtx, &high_rtx);
6024     }
6025
6026   operands[2] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN == 0);
6027   operands[3] = gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN != 0);
6028   operands[4] = GEN_INT (high & 0xffff0000);
6029   operands[5] = GEN_INT (low  & 0xffff0000);
6030   operands[6] = GEN_INT (high & 0x0000ffff);
6031   operands[7] = GEN_INT (low  & 0x0000ffff);
6032 }")
6033
6034 (define_insn "*movdi_64"
6035   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,r,r,f,f,m,r,*h,*h")
6036         (match_operand:DI 1 "input_operand" "r,m,r,I,J,nF,R,f,m,f,*h,r,0"))]
6037   "TARGET_64BIT
6038    && (gpc_reg_operand (operands[0], DImode)
6039        || gpc_reg_operand (operands[1], DImode))"
6040   "@
6041    mr %0,%1
6042    ld%U1%X1 %0,%1
6043    std%U0%X0 %1,%0
6044    li %0,%1
6045    lis %0,%v1
6046    #
6047    {cal|la} %0,%1(%*)
6048    fmr %0,%1
6049    lfd%U1%X1 %0,%1
6050    stfd%U0%X0 %1,%0
6051    mf%1 %0
6052    mt%0 %1
6053    cror 0,0,0"
6054   [(set_attr "type" "*,load,store,*,*,*,*,fp,fpload,fpstore,*,mtjmpr,*")
6055    (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4")])
6056
6057 ;; Split a load of a large constant into the appropriate five-instruction
6058 ;; sequence.  The expansion in movdi tries to perform the minimum number of
6059 ;; steps, but here we have to handle anything in a constant number of insns.
6060
6061 (define_split
6062   [(set (match_operand:DI 0 "gpc_reg_operand" "")
6063         (match_operand:DI 1 "const_double_operand" ""))]
6064   "TARGET_64BIT && num_insns_constant (operands[1], DImode) > 1"
6065   [(set (match_dup 0)
6066         (match_dup 2))
6067    (set (match_dup 0)
6068         (ior:DI (match_dup 0)
6069                 (match_dup 3)))
6070    (set (match_dup 0)
6071         (ashift:DI (match_dup 0)
6072                    (const_int 32)))
6073    (set (match_dup 0)
6074         (ior:DI (match_dup 0)
6075                 (match_dup 4)))
6076    (set (match_dup 0)
6077         (ior:DI (match_dup 0)
6078                 (match_dup 5)))]
6079   "
6080 {
6081   HOST_WIDE_INT low;
6082   HOST_WIDE_INT high;
6083
6084   if (GET_CODE (operands[1]) == CONST_DOUBLE)
6085     {
6086       rtx high_rtx, low_rtx;
6087       split_double (operands[1], &high_rtx, &low_rtx);
6088       high = INTVAL (high_rtx);
6089       low  = INTVAL (low_rtx);
6090     }
6091   else
6092 #if HOST_BITS_PER_WIDE_INT == 32
6093     {
6094       low = INTVAL (operands[1]);
6095       high = (low < 0) ? ~0 : 0;
6096     }
6097 #else
6098     {
6099       low = INTVAL (operands[1]) & 0xffffffff;
6100       high = (HOST_WIDE_INT) INTVAL (operands[1]) >> 32;
6101     }
6102 #endif
6103
6104   if ((high + 0x8000) < 0x10000
6105       && ((low & 0xffff) == 0 || (low & (~ (HOST_WIDE_INT) 0xffff)) == 0))
6106     FAIL;
6107
6108   operands[2] = GEN_INT (high & (~ (HOST_WIDE_INT) 0xffff));
6109   operands[3] = GEN_INT (high & 0xffff);
6110   operands[4] = GEN_INT (low & (~ (HOST_WIDE_INT) 0xffff));
6111   operands[5] = GEN_INT (low & 0xffff);
6112 }")
6113
6114 (define_insn ""
6115   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
6116         (compare:CC (match_operand:DI 1 "gpc_reg_operand" "r")
6117                     (const_int 0)))
6118    (set (match_operand:DI 0 "gpc_reg_operand" "=r") (match_dup 1))]
6119   "TARGET_POWERPC64"
6120   "mr. %0,%1"
6121   [(set_attr "type" "compare")])
6122 \f
6123 ;; TImode is similar, except that we usually want to compute the address into
6124 ;; a register and use lsi/stsi (the exception is during reload).  MQ is also
6125 ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
6126 (define_expand "movti"
6127   [(parallel [(set (match_operand:TI 0 "general_operand" "")
6128                    (match_operand:TI 1 "general_operand" ""))
6129               (clobber (scratch:SI))])]
6130   "TARGET_STRING || TARGET_POWERPC64"
6131   "
6132 {
6133   if (GET_CODE (operands[0]) == MEM)
6134     operands[1] = force_reg (TImode, operands[1]);
6135
6136   if (GET_CODE (operands[0]) == MEM
6137       && GET_CODE (XEXP (operands[0], 0)) != REG
6138       && ! reload_in_progress)
6139     operands[0] = change_address (operands[0], TImode,
6140                                   copy_addr_to_reg (XEXP (operands[0], 0)));
6141
6142   if (GET_CODE (operands[1]) == MEM
6143       && GET_CODE (XEXP (operands[1], 0)) != REG
6144       && ! reload_in_progress)
6145     operands[1] = change_address (operands[1], TImode,
6146                                   copy_addr_to_reg (XEXP (operands[1], 0)));
6147 }")
6148
6149 ;; We say that MQ is clobbered in the last alternative because the first
6150 ;; alternative would never get used otherwise since it would need a reload
6151 ;; while the 2nd alternative would not.  We put memory cases first so they
6152 ;; are preferred.  Otherwise, we'd try to reload the output instead of
6153 ;; giving the SCRATCH mq.
6154 (define_insn ""
6155   [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,????r,????r,????r")
6156         (match_operand:TI 1 "reg_or_mem_operand" "r,r,r,Q,m"))
6157    (clobber (match_scratch:SI 2 "=q,q#X,X,X,X"))]
6158   "TARGET_STRING && TARGET_POWER && ! TARGET_POWERPC64
6159    && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
6160   "*
6161 {
6162   switch (which_alternative)
6163     {
6164     default:
6165       abort ();
6166
6167     case 0:
6168       return \"{stsi|stswi} %1,%P0,16\";
6169
6170     case 1:
6171       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
6172
6173     case 2:
6174       /* Normally copy registers with lowest numbered register copied first.
6175          But copy in the other order if the first register of the output
6176          is the second, third, or fourth register in the input.  */
6177       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
6178           && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
6179         return \"mr %Z0,%Z1\;mr %Y0,%Y1\;mr %L0,%L1\;mr %0,%1\";
6180       else
6181         return \"mr %0,%1\;mr %L0,%L1\;mr %Y0,%Y1\;mr %Z0,%Z1\";
6182     case 3:
6183       /* If the address is not used in the output, we can use lsi.  Otherwise,
6184          fall through to generating four loads.  */
6185       if (! reg_overlap_mentioned_p (operands[0], operands[1]))
6186         return \"{lsi|lswi} %0,%P1,16\";
6187       /* ... fall through ... */
6188     case 4:
6189       /* If the address register is the same as the register for the lowest-
6190          addressed word, load it last.  Similarly for the next two words.
6191          Otherwise load lowest address to highest.  */
6192       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6193                              operands[1], 0))
6194         return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
6195       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
6196                                   REGNO (operands[0]) + 2, operands[1], 0))
6197         return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
6198       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
6199                                   REGNO (operands[0]) + 3, operands[1], 0))
6200         return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
6201       else
6202         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
6203     }
6204 }"
6205   [(set_attr "type" "store,store,*,load,load")
6206    (set_attr "length" "*,16,16,*,16")])
6207
6208 (define_insn ""
6209   [(set (match_operand:TI 0 "reg_or_mem_operand" "=m,????r,????r")
6210         (match_operand:TI 1 "reg_or_mem_operand" "r,r,m"))
6211    (clobber (match_scratch:SI 2 "=X,X,X"))]
6212   "TARGET_STRING && !TARGET_POWER && ! TARGET_POWERPC64
6213    && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))"
6214   "*
6215 {
6216   switch (which_alternative)
6217     {
6218     default:
6219       abort ();
6220
6221     case 0:
6222       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
6223
6224     case 1:
6225       /* Normally copy registers with lowest numbered register copied first.
6226          But copy in the other order if the first register of the output
6227          is the second, third, or fourth register in the input.  */
6228       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
6229           && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
6230         return \"mr %Z0,%Z1\;mr %Y0,%Y1\;mr %L0,%L1\;mr %0,%1\";
6231       else
6232         return \"mr %0,%1\;mr %L0,%L1\;mr %Y0,%Y1\;mr %Z0,%Z1\";
6233     case 2:
6234       /* If the address register is the same as the register for the lowest-
6235          addressed word, load it last.  Similarly for the next two words.
6236          Otherwise load lowest address to highest.  */
6237       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6238                              operands[1], 0))
6239         return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
6240       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
6241                                   REGNO (operands[0]) + 2, operands[1], 0))
6242         return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
6243       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
6244                                   REGNO (operands[0]) + 3, operands[1], 0))
6245         return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
6246       else
6247         return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
6248     }
6249 }"
6250   [(set_attr "type" "store,*,load")
6251    (set_attr "length" "16,16,16")])
6252
6253 (define_insn ""
6254   [(set (match_operand:TI 0 "nonimmediate_operand" "=r,r,m")
6255         (match_operand:TI 1 "input_operand" "r,m,r"))]
6256   "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
6257    || gpc_reg_operand (operands[1], TImode))"
6258   "*
6259 {
6260   switch (which_alternative)
6261     {
6262     case 0:
6263       /* We normally copy the low-numbered register first.  However, if
6264          the first register operand 0 is the same as the second register of
6265          operand 1, we must copy in the opposite order.  */
6266       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
6267         return \"mr %L0,%L1\;mr %0,%1\";
6268       else
6269         return \"mr %0,%1\;mr %L0,%L1\";
6270     case 1:
6271       /* If the low-address word is used in the address, we must load it
6272          last.  Otherwise, load it first.  Note that we cannot have
6273          auto-increment in that case since the address register is known to be
6274          dead.  */
6275       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
6276                              operands [1], 0))
6277         return \"ld %L0,%L1\;ld %0,%1\";
6278       else
6279         return \"ld%U1 %0,%1\;ld %L0,%L1\";
6280     case 2:
6281       return \"std%U0 %1,%0\;std %L1,%L0\";
6282     }
6283 }"
6284   [(set_attr "type" "*,load,store")
6285    (set_attr "length" "8,8,8")])
6286 \f
6287 (define_expand "load_multiple"
6288   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
6289                           (match_operand:SI 1 "" ""))
6290                      (use (match_operand:SI 2 "" ""))])]
6291   "TARGET_STRING"
6292   "
6293 {
6294   int regno;
6295   int count;
6296   rtx from;
6297   int i;
6298
6299   /* Support only loading a constant number of fixed-point registers from
6300      memory and only bother with this if more than two; the machine
6301      doesn't support more than eight.  */
6302   if (GET_CODE (operands[2]) != CONST_INT
6303       || INTVAL (operands[2]) <= 2
6304       || INTVAL (operands[2]) > 8
6305       || GET_CODE (operands[1]) != MEM
6306       || GET_CODE (operands[0]) != REG
6307       || REGNO (operands[0]) >= 32)
6308     FAIL;
6309
6310   count = INTVAL (operands[2]);
6311   regno = REGNO (operands[0]);
6312
6313   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count));
6314   from = force_reg (SImode, XEXP (operands[1], 0));
6315
6316   for (i = 0; i < count; i++)
6317     XVECEXP (operands[3], 0, i)
6318       = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
6319                  gen_rtx (MEM, SImode, plus_constant (from, i * 4)));
6320 }")
6321
6322 (define_insn ""
6323   [(match_parallel 0 "load_multiple_operation"
6324                    [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
6325                          (mem:SI (match_operand:SI 2 "register_operand" "b")))])]
6326   "TARGET_STRING"
6327   "*
6328 {
6329   /* We have to handle the case where the pseudo used to contain the address
6330      is assigned to one of the output registers.  */
6331   int i, j;
6332   int words = XVECLEN (operands[0], 0);
6333   rtx xop[10];
6334
6335   if (XVECLEN (operands[0], 0) == 1)
6336     return \"{l|lwz} %1,0(%2)\";
6337
6338   for (i = 0; i < words; i++)
6339     if (refers_to_regno_p (REGNO (operands[1]) + i,
6340                            REGNO (operands[1]) + i + 1, operands[2], 0))
6341       {
6342         if (i == words-1)
6343           {
6344             xop[0] = operands[1];
6345             xop[1] = operands[2];
6346             xop[2] = GEN_INT (4 * (words-1));
6347             output_asm_insn (\"{lsi|lswi} %0,%1,%2\;{l|lwz} %1,%2(%1)\", xop);
6348             return \"\";
6349           }
6350         else if (i == 0)
6351           {
6352             xop[0] = operands[1];
6353             xop[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
6354             xop[2] = GEN_INT (4 * (words-1));
6355             output_asm_insn (\"{cal %0,4(%0)|addi %0,%0,4}\;{lsi|lswi} %1,%0,%2\;{l|lwz} %0,-4(%0)\", xop);
6356             return \"\";
6357           }
6358         else
6359           {
6360             for (j = 0; j < words; j++)
6361               if (j != i)
6362                 {
6363                   xop[0] = gen_rtx (REG, SImode, REGNO (operands[1]) + j);
6364                   xop[1] = operands[2];
6365                   xop[2] = GEN_INT (j * 4);
6366                   output_asm_insn (\"{l|lwz} %0,%2(%1)\", xop);
6367                 }
6368             xop[0] = operands[2];
6369             xop[1] = GEN_INT (i * 4);
6370             output_asm_insn (\"{l|lwz} %0,%1(%0)\", xop);
6371             return \"\";
6372           }
6373       }
6374
6375   return \"{lsi|lswi} %1,%2,%N0\";
6376 }"
6377   [(set_attr "type" "load")
6378    (set_attr "length" "32")])
6379
6380 \f
6381 (define_expand "store_multiple"
6382   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
6383                           (match_operand:SI 1 "" ""))
6384                      (clobber (scratch:SI))
6385                      (use (match_operand:SI 2 "" ""))])]
6386   "TARGET_STRING"
6387   "
6388 {
6389   int regno;
6390   int count;
6391   rtx to;
6392   int i;
6393
6394   /* Support only storing a constant number of fixed-point registers to
6395      memory and only bother with this if more than two; the machine
6396      doesn't support more than eight.  */
6397   if (GET_CODE (operands[2]) != CONST_INT
6398       || INTVAL (operands[2]) <= 2
6399       || INTVAL (operands[2]) > 8
6400       || GET_CODE (operands[0]) != MEM
6401       || GET_CODE (operands[1]) != REG
6402       || REGNO (operands[1]) >= 32)
6403     FAIL;
6404
6405   count = INTVAL (operands[2]);
6406   regno = REGNO (operands[1]);
6407
6408   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
6409   to = force_reg (SImode, XEXP (operands[0], 0));
6410
6411   XVECEXP (operands[3], 0, 0)
6412     = gen_rtx (SET, VOIDmode, gen_rtx (MEM, SImode, to), operands[1]);
6413   XVECEXP (operands[3], 0, 1) = gen_rtx (CLOBBER, VOIDmode,
6414                                                   gen_rtx (SCRATCH, SImode));
6415
6416   for (i = 1; i < count; i++)
6417     XVECEXP (operands[3], 0, i + 1)
6418       = gen_rtx (SET, VOIDmode,
6419                  gen_rtx (MEM, SImode, plus_constant (to, i * 4)),
6420                  gen_rtx (REG, SImode, regno + i));
6421 }")
6422
6423 (define_insn ""
6424   [(match_parallel 0 "store_multiple_operation"
6425                    [(set (match_operand:SI 1 "indirect_operand" "=Q")
6426                          (match_operand:SI 2 "gpc_reg_operand" "r"))
6427                     (clobber (match_scratch:SI 3 "=q"))])]
6428   "TARGET_STRING && TARGET_POWER"
6429   "{stsi|stswi} %2,%P1,%O0"
6430   [(set_attr "type" "store")])
6431
6432 (define_insn ""
6433   [(match_parallel 0 "store_multiple_operation"
6434                    [(set (mem:SI (match_operand:SI 1 "register_operand" "b"))
6435                          (match_operand:SI 2 "gpc_reg_operand" "r"))
6436                     (clobber (match_scratch:SI 3 "X"))])]
6437   "TARGET_STRING && !TARGET_POWER"
6438   "{stsi|stswi} %2,%1,%O0"
6439   [(set_attr "type" "store")])
6440
6441 \f
6442 ;; String/block move insn.
6443 ;; Argument 0 is the destination
6444 ;; Argument 1 is the source
6445 ;; Argument 2 is the length
6446 ;; Argument 3 is the alignment
6447
6448 (define_expand "movstrsi"
6449   [(parallel [(set (match_operand:BLK 0 "" "")
6450                    (match_operand:BLK 1 "" ""))
6451               (use (match_operand:SI 2 "" ""))
6452               (use (match_operand:SI 3 "" ""))])]
6453   ""
6454   "
6455 {
6456   if (expand_block_move (operands))
6457     DONE;
6458   else
6459     FAIL;
6460 }")
6461
6462 ;; Move up to 32 bytes at a time.  The fixed registers are needed because the
6463 ;; register allocator doesn't have a clue about allocating 8 word registers
6464 (define_expand "movstrsi_8reg"
6465   [(parallel [(set (match_operand 0 "" "")
6466                    (match_operand 1 "" ""))
6467               (use (match_operand 2 "" ""))
6468               (use (match_operand 3 "" ""))
6469               (clobber (reg:SI  5))
6470               (clobber (reg:SI  6))
6471               (clobber (reg:SI  7))
6472               (clobber (reg:SI  8))
6473               (clobber (reg:SI  9))
6474               (clobber (reg:SI 10))
6475               (clobber (reg:SI 11))
6476               (clobber (reg:SI 12))
6477               (clobber (match_scratch:SI 4 ""))])]
6478   "TARGET_STRING"
6479   "")
6480
6481 (define_insn ""
6482   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6483         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6484    (use (match_operand:SI 2 "immediate_operand" "i"))
6485    (use (match_operand:SI 3 "immediate_operand" "i"))
6486    (clobber (match_operand:SI 4 "register_operand" "=r"))
6487    (clobber (reg:SI  6))
6488    (clobber (reg:SI  7))
6489    (clobber (reg:SI  8))
6490    (clobber (reg:SI  9))
6491    (clobber (reg:SI 10))
6492    (clobber (reg:SI 11))
6493    (clobber (reg:SI 12))
6494    (clobber (match_scratch:SI 5 "=q"))]
6495   "TARGET_STRING && TARGET_POWER
6496    && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32) || INTVAL (operands[2]) == 0)
6497    && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
6498    && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
6499    && REGNO (operands[4]) == 5"
6500   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6501   [(set_attr "type" "load")
6502    (set_attr "length" "8")])
6503
6504 (define_insn ""
6505   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6506         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6507    (use (match_operand:SI 2 "immediate_operand" "i"))
6508    (use (match_operand:SI 3 "immediate_operand" "i"))
6509    (clobber (match_operand:SI 4 "register_operand" "=r"))
6510    (clobber (reg:SI  6))
6511    (clobber (reg:SI  7))
6512    (clobber (reg:SI  8))
6513    (clobber (reg:SI  9))
6514    (clobber (reg:SI 10))
6515    (clobber (reg:SI 11))
6516    (clobber (reg:SI 12))
6517    (clobber (match_scratch:SI 5 "X"))]
6518   "TARGET_STRING && !TARGET_POWER
6519    && ((INTVAL (operands[2]) > 24 && INTVAL (operands[2]) < 32) || INTVAL (operands[2]) == 0)
6520    && (REGNO (operands[0]) < 5 || REGNO (operands[0]) > 12)
6521    && (REGNO (operands[1]) < 5 || REGNO (operands[1]) > 12)
6522    && REGNO (operands[4]) == 5"
6523   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6524   [(set_attr "type" "load")
6525    (set_attr "length" "8")])
6526
6527 ;; Move up to 24 bytes at a time.  The fixed registers are needed because the
6528 ;; register allocator doesn't have a clue about allocating 6 word registers
6529 (define_expand "movstrsi_6reg"
6530   [(parallel [(set (match_operand 0 "" "")
6531                    (match_operand 1 "" ""))
6532               (use (match_operand 2 "" ""))
6533               (use (match_operand 3 "" ""))
6534               (clobber (reg:SI  7))
6535               (clobber (reg:SI  8))
6536               (clobber (reg:SI  9))
6537               (clobber (reg:SI 10))
6538               (clobber (reg:SI 11))
6539               (clobber (reg:SI 12))
6540               (clobber (match_scratch:SI 4 ""))])]
6541   "TARGET_STRING"
6542   "")
6543
6544 (define_insn ""
6545   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6546         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6547    (use (match_operand:SI 2 "immediate_operand" "i"))
6548    (use (match_operand:SI 3 "immediate_operand" "i"))
6549    (clobber (match_operand:SI 4 "register_operand" "=r"))
6550    (clobber (reg:SI  8))
6551    (clobber (reg:SI  9))
6552    (clobber (reg:SI 10))
6553    (clobber (reg:SI 11))
6554    (clobber (reg:SI 12))
6555    (clobber (match_scratch:SI 5 "=q"))]
6556   "TARGET_STRING && TARGET_POWER
6557    && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 24
6558    && (REGNO (operands[0]) < 7 || REGNO (operands[0]) > 12)
6559    && (REGNO (operands[1]) < 7 || REGNO (operands[1]) > 12)
6560    && REGNO (operands[4]) == 7"
6561   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6562   [(set_attr "type" "load")
6563    (set_attr "length" "8")])
6564
6565 (define_insn ""
6566   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6567         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6568    (use (match_operand:SI 2 "immediate_operand" "i"))
6569    (use (match_operand:SI 3 "immediate_operand" "i"))
6570    (clobber (match_operand:SI 4 "register_operand" "=r"))
6571    (clobber (reg:SI  8))
6572    (clobber (reg:SI  9))
6573    (clobber (reg:SI 10))
6574    (clobber (reg:SI 11))
6575    (clobber (reg:SI 12))
6576    (clobber (match_scratch:SI 5 "X"))]
6577   "TARGET_STRING && !TARGET_POWER
6578    && INTVAL (operands[2]) > 16 && INTVAL (operands[2]) <= 32
6579    && (REGNO (operands[0]) < 7 || REGNO (operands[0]) > 12)
6580    && (REGNO (operands[1]) < 7 || REGNO (operands[1]) > 12)
6581    && REGNO (operands[4]) == 7"
6582   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6583   [(set_attr "type" "load")
6584    (set_attr "length" "8")])
6585
6586 ;; Move up to 16 bytes at a time, using 4 fixed registers to avoid spill problems
6587 ;; with TImode
6588 (define_expand "movstrsi_4reg"
6589   [(parallel [(set (match_operand 0 "" "")
6590                    (match_operand 1 "" ""))
6591               (use (match_operand 2 "" ""))
6592               (use (match_operand 3 "" ""))
6593               (clobber (reg:SI  9))
6594               (clobber (reg:SI 10))
6595               (clobber (reg:SI 11))
6596               (clobber (reg:SI 12))
6597               (clobber (match_scratch:SI 4 ""))])]
6598   "TARGET_STRING"
6599   "")
6600
6601 (define_insn ""
6602   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6603         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6604    (use (match_operand:SI 2 "immediate_operand" "i"))
6605    (use (match_operand:SI 3 "immediate_operand" "i"))
6606    (clobber (match_operand:SI 4 "register_operand" "=r"))
6607    (clobber (reg:SI 10))
6608    (clobber (reg:SI 11))
6609    (clobber (reg:SI 12))
6610    (clobber (match_scratch:SI 5 "=q"))]
6611   "TARGET_STRING && TARGET_POWER
6612    && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
6613    && (REGNO (operands[0]) < 9 || REGNO (operands[0]) > 12)
6614    && (REGNO (operands[1]) < 9 || REGNO (operands[1]) > 12)
6615    && REGNO (operands[4]) == 9"
6616   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6617   [(set_attr "type" "load")
6618    (set_attr "length" "8")])
6619
6620 (define_insn ""
6621   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6622         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6623    (use (match_operand:SI 2 "immediate_operand" "i"))
6624    (use (match_operand:SI 3 "immediate_operand" "i"))
6625    (clobber (match_operand:SI 4 "register_operand" "=r"))
6626    (clobber (reg:SI 10))
6627    (clobber (reg:SI 11))
6628    (clobber (reg:SI 12))
6629    (clobber (match_scratch:SI 5 "X"))]
6630   "TARGET_STRING && !TARGET_POWER
6631    && INTVAL (operands[2]) > 8 && INTVAL (operands[2]) <= 16
6632    && (REGNO (operands[0]) < 9 || REGNO (operands[0]) > 12)
6633    && (REGNO (operands[1]) < 9 || REGNO (operands[1]) > 12)
6634    && REGNO (operands[4]) == 9"
6635   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6636   [(set_attr "type" "load")
6637    (set_attr "length" "8")])
6638
6639 ;; Move up to 8 bytes at a time.
6640 (define_expand "movstrsi_2reg"
6641   [(parallel [(set (match_operand 0 "" "")
6642                    (match_operand 1 "" ""))
6643               (use (match_operand 2 "" ""))
6644               (use (match_operand 3 "" ""))
6645               (clobber (match_scratch:DI 4 ""))
6646               (clobber (match_scratch:SI 5 ""))])]
6647   "TARGET_STRING && !TARGET_64BIT"
6648   "")
6649
6650 (define_insn ""
6651   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6652         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6653    (use (match_operand:SI 2 "immediate_operand" "i"))
6654    (use (match_operand:SI 3 "immediate_operand" "i"))
6655    (clobber (match_scratch:DI 4 "=&r"))
6656    (clobber (match_scratch:SI 5 "=q"))]
6657   "TARGET_STRING && TARGET_POWER && !TARGET_64BIT
6658    && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
6659   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6660   [(set_attr "type" "load")
6661    (set_attr "length" "8")])
6662
6663 (define_insn ""
6664   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6665         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6666    (use (match_operand:SI 2 "immediate_operand" "i"))
6667    (use (match_operand:SI 3 "immediate_operand" "i"))
6668    (clobber (match_scratch:DI 4 "=&r"))
6669    (clobber (match_scratch:SI 5 "X"))]
6670   "TARGET_STRING && !TARGET_POWER && !TARGET_64BIT
6671    && INTVAL (operands[2]) > 4 && INTVAL (operands[2]) <= 8"
6672   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6673   [(set_attr "type" "load")
6674    (set_attr "length" "8")])
6675
6676 ;; Move up to 4 bytes at a time.
6677 (define_expand "movstrsi_1reg"
6678   [(parallel [(set (match_operand 0 "" "")
6679                    (match_operand 1 "" ""))
6680               (use (match_operand 2 "" ""))
6681               (use (match_operand 3 "" ""))
6682               (clobber (match_scratch:SI 4 ""))
6683               (clobber (match_scratch:SI 5 ""))])]
6684   "TARGET_STRING"
6685   "")
6686
6687 (define_insn ""
6688   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6689         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6690    (use (match_operand:SI 2 "immediate_operand" "i"))
6691    (use (match_operand:SI 3 "immediate_operand" "i"))
6692    (clobber (match_scratch:SI 4 "=&r"))
6693    (clobber (match_scratch:SI 5 "=q"))]
6694   "TARGET_STRING && TARGET_POWER
6695    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
6696   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6697   [(set_attr "type" "load")
6698    (set_attr "length" "8")])
6699
6700 (define_insn ""
6701   [(set (mem:BLK (match_operand:SI 0 "register_operand" "b"))
6702         (mem:BLK (match_operand:SI 1 "register_operand" "b")))
6703    (use (match_operand:SI 2 "immediate_operand" "i"))
6704    (use (match_operand:SI 3 "immediate_operand" "i"))
6705    (clobber (match_scratch:SI 4 "=&r"))
6706    (clobber (match_scratch:SI 5 "X"))]
6707   "TARGET_STRING && !TARGET_POWER
6708    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) <= 4"
6709   "{lsi|lswi} %4,%1,%2\;{stsi|stswi} %4,%0,%2"
6710   [(set_attr "type" "load")
6711    (set_attr "length" "8")])
6712
6713 \f
6714 ;; Define insns that do load or store with update.  Some of these we can
6715 ;; get by using pre-decrement or pre-increment, but the hardware can also
6716 ;; do cases where the increment is not the size of the object.
6717 ;;
6718 ;; In all these cases, we use operands 0 and 1 for the register being
6719 ;; incremented because those are the operands that local-alloc will
6720 ;; tie and these are the pair most likely to be tieable (and the ones
6721 ;; that will benefit the most).
6722
6723 (define_insn ""
6724   [(set (match_operand:DI 3 "gpc_reg_operand" "=r,r")
6725         (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
6726                          (match_operand:DI 2 "reg_or_short_operand" "r,I"))))
6727    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
6728         (plus:DI (match_dup 1) (match_dup 2)))]
6729   "TARGET_POWERPC64"
6730   "@
6731    ldux %3,%0,%2
6732    ldu %3,%2(%0)"
6733   [(set_attr "type" "load")])
6734
6735 (define_insn ""
6736   [(set (match_operand:DI 3 "gpc_reg_operand" "=r")
6737         (sign_extend:DI
6738          (mem:SI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0")
6739                           (match_operand:DI 2 "gpc_reg_operand" "r")))))
6740    (set (match_operand:DI 0 "gpc_reg_operand" "=b")
6741         (plus:DI (match_dup 1) (match_dup 2)))]
6742   "TARGET_POWERPC64"
6743   "lwaux %3,%0,%2"
6744   [(set_attr "type" "load")])
6745
6746 (define_insn "movdi_update"
6747   [(set (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
6748                          (match_operand:DI 2 "reg_or_short_operand" "r,I")))
6749         (match_operand:DI 3 "gpc_reg_operand" "r,r"))
6750    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
6751         (plus:DI (match_dup 1) (match_dup 2)))]
6752   "TARGET_POWERPC64"
6753   "@
6754    stdux %3,%0,%2
6755    stdu %3,%2(%0)"
6756   [(set_attr "type" "store")])
6757
6758 (define_insn ""
6759   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6760         (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6761                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6762    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6763         (plus:SI (match_dup 1) (match_dup 2)))]
6764   ""
6765   "@
6766    {lux|lwzux} %3,%0,%2
6767    {lu|lwzu} %3,%2(%0)"
6768   [(set_attr "type" "load")])
6769
6770 (define_insn "movsi_update"
6771   [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6772                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6773         (match_operand:SI 3 "gpc_reg_operand" "r,r"))
6774    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6775         (plus:SI (match_dup 1) (match_dup 2)))]
6776   ""
6777   "@
6778    {stux|stwux} %3,%0,%2
6779    {stu|stwu} %3,%2(%0)"
6780   [(set_attr "type" "store")])
6781
6782 (define_insn ""
6783   [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
6784         (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6785                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6786    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6787         (plus:SI (match_dup 1) (match_dup 2)))]
6788   ""
6789   "@
6790    lhzux %3,%0,%2
6791    lhzu %3,%2(%0)"
6792   [(set_attr "type" "load")])
6793
6794 (define_insn ""
6795   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6796         (zero_extend:SI
6797          (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6798                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6799    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6800         (plus:SI (match_dup 1) (match_dup 2)))]
6801   ""
6802   "@
6803    lhzux %3,%0,%2
6804    lhzu %3,%2(%0)"
6805   [(set_attr "type" "load")])
6806
6807 (define_insn ""
6808   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6809         (sign_extend:SI
6810          (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6811                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6812    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6813         (plus:SI (match_dup 1) (match_dup 2)))]
6814   ""
6815   "@
6816    lhaux %3,%0,%2
6817    lhau %3,%2(%0)"
6818   [(set_attr "type" "load")])
6819
6820 (define_insn ""
6821   [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6822                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6823         (match_operand:HI 3 "gpc_reg_operand" "r,r"))
6824    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6825         (plus:SI (match_dup 1) (match_dup 2)))]
6826   ""
6827   "@
6828    sthux %3,%0,%2
6829    sthu %3,%2(%0)"
6830   [(set_attr "type" "store")])
6831
6832 (define_insn ""
6833   [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
6834         (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6835                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6836    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6837         (plus:SI (match_dup 1) (match_dup 2)))]
6838   ""
6839   "@
6840    lbzux %3,%0,%2
6841    lbzu %3,%2(%0)"
6842   [(set_attr "type" "load")])
6843
6844 (define_insn ""
6845   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
6846         (zero_extend:SI
6847          (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6848                           (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
6849    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6850         (plus:SI (match_dup 1) (match_dup 2)))]
6851   ""
6852   "@
6853    lbzux %3,%0,%2
6854    lbzu %3,%2(%0)"
6855   [(set_attr "type" "load")])
6856
6857 (define_insn ""
6858   [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6859                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6860         (match_operand:QI 3 "gpc_reg_operand" "r,r"))
6861    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6862         (plus:SI (match_dup 1) (match_dup 2)))]
6863   ""
6864   "@
6865    stbux %3,%0,%2
6866    stbu %3,%2(%0)"
6867   [(set_attr "type" "store")])
6868
6869 (define_insn ""
6870   [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
6871         (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6872                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6873    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6874         (plus:SI (match_dup 1) (match_dup 2)))]
6875   "TARGET_HARD_FLOAT"
6876   "@
6877    lfsux %3,%0,%2
6878    lfsu %3,%2(%0)"
6879   [(set_attr "type" "fpload")])
6880
6881 (define_insn ""
6882   [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6883                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6884         (match_operand:SF 3 "gpc_reg_operand" "f,f"))
6885    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6886         (plus:SI (match_dup 1) (match_dup 2)))]
6887   "TARGET_HARD_FLOAT"
6888   "@
6889    stfsux %3,%0,%2
6890    stfsu %3,%2(%0)"
6891   [(set_attr "type" "fpstore")])
6892
6893 (define_insn ""
6894   [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
6895         (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6896                          (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
6897    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6898         (plus:SI (match_dup 1) (match_dup 2)))]
6899   "TARGET_HARD_FLOAT"
6900   "@
6901    lfdux %3,%0,%2
6902    lfdu %3,%2(%0)"
6903   [(set_attr "type" "fpload")])
6904
6905 (define_insn ""
6906   [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
6907                          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
6908         (match_operand:DF 3 "gpc_reg_operand" "f,f"))
6909    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
6910         (plus:SI (match_dup 1) (match_dup 2)))]
6911   "TARGET_HARD_FLOAT"
6912   "@
6913    stfdux %3,%0,%2
6914    stfdu %3,%2(%0)"
6915   [(set_attr "type" "fpstore")])
6916
6917 ;; Peephole to convert two consecutive FP loads or stores into lfq/stfq.
6918
6919 (define_peephole
6920   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
6921         (match_operand:DF 1 "memory_operand" ""))
6922    (set (match_operand:DF 2 "gpc_reg_operand" "=f")
6923         (match_operand:DF 3 "memory_operand" ""))]
6924   "TARGET_POWER2
6925    && TARGET_HARD_FLOAT
6926    && registers_ok_for_quad_peep (operands[0], operands[2])
6927    && ! MEM_VOLATILE_P (operands[1]) && ! MEM_VOLATILE_P (operands[3])
6928    && addrs_ok_for_quad_peep (XEXP (operands[1], 0), XEXP (operands[3], 0))"
6929   "lfq%U1%X1 %0,%1")
6930
6931 (define_peephole
6932   [(set (match_operand:DF 0 "memory_operand" "")
6933         (match_operand:DF 1 "gpc_reg_operand" "f"))
6934    (set (match_operand:DF 2 "memory_operand" "")
6935         (match_operand:DF 3 "gpc_reg_operand" "f"))]
6936   "TARGET_POWER2
6937    && TARGET_HARD_FLOAT
6938    && registers_ok_for_quad_peep (operands[1], operands[3])
6939    && ! MEM_VOLATILE_P (operands[0]) && ! MEM_VOLATILE_P (operands[2])
6940    && addrs_ok_for_quad_peep (XEXP (operands[0], 0), XEXP (operands[2], 0))"
6941   "stfq%U0%X0 %1,%0")
6942 \f
6943 ;; Next come insns related to the calling sequence.
6944 ;;
6945 ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
6946 ;; We move the back-chain and decrement the stack pointer.
6947
6948 (define_expand "allocate_stack"
6949   [(set (reg:SI 1)
6950         (minus:SI (reg:SI 1) (match_operand:SI 0 "reg_or_short_operand" "")))]
6951   ""
6952   "
6953 { rtx chain = gen_reg_rtx (Pmode);
6954   rtx stack_bot = gen_rtx (MEM, Pmode, stack_pointer_rtx);
6955   rtx neg_op0;
6956
6957   emit_move_insn (chain, stack_bot);
6958
6959   /* Under Windows NT, we need to add stack probes for large/variable allocations,
6960      so do it via a call to the external function alloca, instead of doing it
6961      inline.  */
6962   if (DEFAULT_ABI == ABI_NT
6963       && (GET_CODE (operands[0]) != CONST_INT || INTVAL (operands[0]) > 4096))
6964     {
6965       rtx tmp = gen_reg_rtx (SImode);
6966       emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__allocate_stack\"),
6967                                tmp, 0, SImode, 1, operands[0], Pmode);
6968       emit_insn (gen_set_sp (tmp));
6969       DONE;
6970     }
6971
6972   if (GET_CODE (operands[0]) != CONST_INT
6973       || INTVAL (operands[0]) < -32767
6974       || INTVAL (operands[0]) > 32768)
6975     {
6976       neg_op0 = gen_reg_rtx (Pmode);
6977       if (TARGET_32BIT)
6978         emit_insn (gen_negsi2 (neg_op0, operands[0]));
6979       else
6980         emit_insn (gen_negdi2 (neg_op0, operands[0]));
6981     }
6982   else
6983     neg_op0 = GEN_INT (- INTVAL (operands[0]));
6984
6985   if (TARGET_32BIT)
6986     emit_insn (gen_movsi_update (stack_pointer_rtx, stack_pointer_rtx, neg_op0, chain));
6987   else
6988     emit_insn (gen_movdi_update (stack_pointer_rtx, stack_pointer_rtx, neg_op0, chain));
6989
6990   DONE;
6991 }")
6992
6993 ;; Marker to indicate that the stack pointer was changed under NT in
6994 ;; ways not known to the compiler
6995
6996 (define_insn "set_sp"
6997   [(set (reg:SI 1)
6998         (unspec [(match_operand:SI 0 "register_operand" "r")] 7))]
6999   ""
7000   ""
7001   [(set_attr "length" "0")])
7002
7003 ;; These patterns say how to save and restore the stack pointer.  We need not
7004 ;; save the stack pointer at function level since we are careful to
7005 ;; preserve the backchain.  At block level, we have to restore the backchain
7006 ;; when we restore the stack pointer.
7007 ;;
7008 ;; For nonlocal gotos, we must save both the stack pointer and its
7009 ;; backchain and restore both.  Note that in the nonlocal case, the
7010 ;; save area is a memory location.
7011
7012 (define_expand "save_stack_function"
7013   [(use (const_int 0))]
7014   ""
7015   "")
7016
7017 (define_expand "restore_stack_function"
7018   [(use (const_int 0))]
7019   ""
7020   "")
7021
7022 (define_expand "restore_stack_block"
7023   [(set (match_dup 2) (mem:SI (match_operand:SI 0 "register_operand" "")))
7024    (set (match_dup 0) (match_operand:SI 1 "register_operand" ""))
7025    (set (mem:SI (match_dup 0)) (match_dup 2))]
7026   ""
7027   "
7028 { operands[2] = gen_reg_rtx (SImode); }")
7029
7030 (define_expand "save_stack_nonlocal"
7031   [(match_operand:DI 0 "memory_operand" "")
7032    (match_operand:SI 1 "register_operand" "")]
7033   ""
7034   "
7035 {
7036   rtx temp = gen_reg_rtx (SImode);
7037
7038   /* Copy the backchain to the first word, sp to the second.  */
7039   emit_move_insn (temp, gen_rtx (MEM, SImode, operands[1]));
7040   emit_move_insn (operand_subword (operands[0], 0, 0, DImode), temp);
7041   emit_move_insn (operand_subword (operands[0], 1, 0, DImode), operands[1]);
7042   DONE;
7043 }")
7044
7045 (define_expand "restore_stack_nonlocal"
7046   [(match_operand:SI 0 "register_operand" "")
7047    (match_operand:DI 1 "memory_operand" "")]
7048   ""
7049   "
7050 {
7051   rtx temp = gen_reg_rtx (SImode);
7052
7053   /* Restore the backchain from the first word, sp from the second.  */
7054   emit_move_insn (temp, operand_subword (operands[1], 0, 0, DImode));
7055   emit_move_insn (operands[0], operand_subword (operands[1], 1, 0, DImode));
7056   emit_move_insn (gen_rtx (MEM, SImode, operands[0]), temp);
7057   DONE;
7058 }")
7059
7060 \f
7061 ;; A function pointer under AIX is a pointer to a data area whose first word
7062 ;; contains the actual address of the function, whose second word contains a
7063 ;; pointer to its TOC, and whose third word contains a value to place in the
7064 ;; static chain register (r11).  Note that if we load the static chain, our
7065 ;; "trampoline" need not have any executable code.
7066 ;;
7067 ;; operands[0] is a register pointing to the 3 word descriptor (aka, the function address)
7068 ;; operands[1] is the stack size to clean up
7069 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument (must be 0 for AIX)
7070 ;; operands[3] is location to store the TOC
7071 ;; operands[4] is the TOC register
7072 ;; operands[5] is the static chain register
7073 ;;
7074 ;; We do not break this into separate insns, so that the scheduler will not try
7075 ;; to move the load of the new TOC before any loads from the TOC.
7076
7077 (define_insn "call_indirect_aix"
7078   [(call (mem:SI (match_operand:SI 0 "register_operand" "b"))
7079          (match_operand 1 "const_int_operand" "n"))
7080    (use (match_operand 2 "const_int_operand" "n"))
7081    (use (match_operand 3 "offsettable_addr_operand" "p"))
7082    (use (match_operand 4 "register_operand" "r"))
7083    (clobber (match_operand 5 "register_operand" "=r"))
7084    (clobber (match_scratch:SI 6 "=&r"))
7085    (clobber (match_scratch:SI 7 "=l"))]
7086   "DEFAULT_ABI == ABI_AIX
7087    && (INTVAL (operands[2]) == CALL_NORMAL || (INTVAL (operands[2]) & CALL_LONG) != 0)"
7088   "{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"
7089   [(set_attr "type" "load")
7090    (set_attr "length" "28")])
7091
7092 (define_insn "call_value_indirect_aix"
7093   [(set (match_operand 0 "register_operand" "fg")
7094         (call (mem:SI (match_operand:SI 1 "register_operand" "b"))
7095               (match_operand 2 "const_int_operand" "n")))
7096    (use (match_operand 3 "const_int_operand" "n"))
7097    (use (match_operand 4 "offsettable_addr_operand" "p"))
7098    (use (match_operand 5 "register_operand" "r"))
7099    (clobber (match_operand 6 "register_operand" "=r"))
7100    (clobber (match_scratch:SI 7 "=&r"))
7101    (clobber (match_scratch:SI 8 "=l"))]
7102   "DEFAULT_ABI == ABI_AIX
7103    && (INTVAL (operands[3]) == CALL_NORMAL || (INTVAL (operands[3]) & CALL_LONG) != 0)"
7104   "{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"
7105   [(set_attr "type" "load")
7106    (set_attr "length" "28")])
7107
7108 ;; A function pointer undef NT is a pointer to a data area whose first word
7109 ;; contains the actual address of the function, whose second word contains a
7110 ;; pointer to its TOC.  The static chain is not stored under NT, which means
7111 ;; that we need a trampoline.
7112 ;;
7113 ;; operands[0] is an SImode pseudo in which we place the address of the function.
7114 ;; operands[1] is the stack size to clean up
7115 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument (must be 0 for NT)
7116 ;; operands[3] is location to store the TOC
7117 ;; operands[4] is the TOC register
7118 ;;
7119 ;; We do not break this into separate insns, so that the scheduler will not try
7120 ;; to move the load of the new TOC before any loads from the TOC.
7121
7122 (define_insn "call_indirect_nt"
7123   [(call (mem:SI (match_operand:SI 0 "register_operand" "b"))
7124          (match_operand 1 "const_int_operand" "n"))
7125    (use (match_operand 2 "const_int_operand" "n"))
7126    (use (match_operand 3 "offsettable_addr_operand" "p"))
7127    (use (match_operand 4 "register_operand" "r"))
7128    (clobber (match_scratch:SI 5 "=&r"))
7129    (clobber (match_scratch:SI 6 "=l"))]
7130   "DEFAULT_ABI == ABI_NT
7131    && (INTVAL (operands[2]) == CALL_NORMAL || (INTVAL (operands[2]) & CALL_LONG) != 0)"
7132   "{st|stw} %4,%a3\;{l|lwz} %5,0(%0)\;{l|lwz} %4,4(%0)\;mt%6 %5\;{brl|blrl}\;{l|lwz} %4,%a3"
7133   [(set_attr "type" "load")
7134    (set_attr "length" "24")])
7135
7136 (define_insn "call_value_indirect_nt"
7137   [(set (match_operand 0 "register_operand" "fg")
7138         (call (mem:SI (match_operand:SI 1 "register_operand" "b"))
7139               (match_operand 2 "const_int_operand" "n")))
7140    (use (match_operand 3 "const_int_operand" "n"))
7141    (use (match_operand 4 "offsettable_addr_operand" "p"))
7142    (use (match_operand 5 "register_operand" "r"))
7143    (clobber (match_scratch:SI 6 "=&r"))
7144    (clobber (match_scratch:SI 7 "=l"))]
7145   "DEFAULT_ABI == ABI_NT
7146    && (INTVAL (operands[3]) == CALL_NORMAL || (INTVAL (operands[3]) & CALL_LONG) != 0)"
7147   "{st|stw} %5,%a4\;{l|lwz} %6,0(%1)\;{l|lwz} %5,4(%1)\;mt%7 %6\;{brl|blrl}\;{l|lwz} %5,%a4"
7148   [(set_attr "type" "load")
7149    (set_attr "length" "24")])
7150
7151 ;; A function pointer under System V is just a normal pointer
7152 ;; operands[0] is the function pointer
7153 ;; operands[1] is the stack size to clean up
7154 ;; operands[2] is the value FUNCTION_ARG returns for the VOID argument which indicates how to set cr1
7155
7156 (define_insn "call_indirect_sysv"
7157   [(call (mem:SI (match_operand:SI 0 "register_operand" "l,l"))
7158          (match_operand 1 "const_int_operand" "n,n"))
7159    (use (match_operand 2 "const_int_operand" "O,n"))
7160    (clobber (match_scratch:SI 3 "=l,l"))]
7161   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS || DEFAULT_ABI == ABI_AIX_NODESC"
7162   "*
7163 {
7164   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7165     output_asm_insn (\"crxor 6,6,6\", operands);
7166
7167   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7168     output_asm_insn (\"creqv 6,6,6\", operands);
7169
7170   return \"{brl|blrl}\";
7171 }"
7172   [(set_attr "type" "jmpreg")
7173    (set_attr "length" "4,8")])
7174
7175 (define_insn "call_value_indirect_sysv"
7176   [(set (match_operand 0 "register_operand" "=fg,fg")
7177         (call (mem:SI (match_operand:SI 1 "register_operand" "l,l"))
7178               (match_operand 2 "const_int_operand" "n,n")))
7179    (use (match_operand 3 "const_int_operand" "O,n"))
7180    (clobber (match_scratch:SI 4 "=l,l"))]
7181   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS || DEFAULT_ABI == ABI_AIX_NODESC"
7182   "*
7183 {
7184   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7185     output_asm_insn (\"crxor 6,6,6\", operands);
7186
7187   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7188     output_asm_insn (\"creqv 6,6,6\", operands);
7189
7190   return \"{brl|blrl}\";
7191 }"
7192   [(set_attr "type" "jmpreg")
7193    (set_attr "length" "4,8")])
7194
7195 ;; Now the definitions for the call and call_value insns
7196 (define_expand "call"
7197   [(parallel [(call (mem:SI (match_operand:SI 0 "address_operand" ""))
7198                     (match_operand 1 "" ""))
7199               (use (match_operand 2 "" ""))
7200               (clobber (scratch:SI))])]
7201   ""
7202   "
7203 {
7204   if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
7205     abort ();
7206
7207   operands[0] = XEXP (operands[0], 0);
7208
7209   /* Convert NT DLL imports into an indirect call.  */
7210   if (GET_CODE (operands[0]) == SYMBOL_REF
7211       && (INTVAL (operands[2]) & CALL_NT_DLLIMPORT) != 0)
7212     {
7213       operands[0] = rs6000_dll_import_ref (operands[0]);
7214       operands[2] = GEN_INT ((int)CALL_NORMAL);
7215     }
7216
7217   if (GET_CODE (operands[0]) != SYMBOL_REF
7218       || (INTVAL (operands[2]) & CALL_LONG) != 0)
7219     {
7220       if (INTVAL (operands[2]) & CALL_LONG)
7221         operands[0] = rs6000_longcall_ref (operands[0]);
7222
7223       if (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_SOLARIS)
7224         emit_call_insn (gen_call_indirect_sysv (force_reg (Pmode, operands[0]),
7225                                                 operands[1], operands[2]));
7226       else
7227         {
7228           rtx toc_reg = gen_rtx (REG, Pmode, 2);
7229           rtx toc_addr = RS6000_SAVE_TOC;
7230
7231           if (DEFAULT_ABI == ABI_AIX)
7232             {
7233               /* AIX function pointers are really pointers to a three word area */
7234               rtx static_chain = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
7235               emit_call_insn (gen_call_indirect_aix (force_reg (Pmode, operands[0]),
7236                                                      operands[1], operands[2],
7237                                                      toc_addr, toc_reg, static_chain));
7238             }
7239           else if (DEFAULT_ABI == ABI_NT)
7240             {
7241               /* NT function pointers are really pointers to a two word area */
7242               rs6000_save_toc_p = 1;
7243               emit_call_insn (gen_call_indirect_nt (force_reg (Pmode, operands[0]),
7244                                                     operands[1], operands[2],
7245                                                     toc_addr, toc_reg));
7246             }
7247           else
7248             abort ();
7249         }
7250       DONE;
7251     }
7252 }")
7253
7254 (define_expand "call_value"
7255   [(parallel [(set (match_operand 0 "" "")
7256                    (call (mem:SI (match_operand:SI 1 "address_operand" ""))
7257                          (match_operand 2 "" "")))
7258               (use (match_operand 3 "" ""))
7259               (clobber (scratch:SI))])]
7260   ""
7261   "
7262 {
7263   if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
7264     abort ();
7265
7266   operands[1] = XEXP (operands[1], 0);
7267
7268   /* Convert NT DLL imports into an indirect call.  */
7269   if (GET_CODE (operands[1]) == SYMBOL_REF
7270       && (INTVAL (operands[3]) & CALL_NT_DLLIMPORT) != 0)
7271     {
7272       operands[1] = rs6000_dll_import_ref (operands[1]);
7273       operands[3] = GEN_INT ((int)CALL_NORMAL);
7274     }
7275
7276   if (GET_CODE (operands[1]) != SYMBOL_REF
7277       || (INTVAL (operands[3]) & CALL_LONG) != 0)
7278     {
7279       if (INTVAL (operands[2]) & CALL_LONG)
7280         operands[1] = rs6000_longcall_ref (operands[1]);
7281
7282       if (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_SOLARIS)
7283         emit_call_insn (gen_call_value_indirect_sysv (operands[0], operands[1],
7284                                                       operands[2], operands[3]));
7285       else
7286         {
7287           rtx toc_reg = gen_rtx (REG, Pmode, 2);
7288           rtx toc_addr = RS6000_SAVE_TOC;
7289
7290           if (DEFAULT_ABI == ABI_AIX)
7291             {
7292               /* AIX function pointers are really pointers to a three word area */
7293               rtx static_chain = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
7294               emit_call_insn (gen_call_value_indirect_aix (operands[0],
7295                                                            force_reg (Pmode, operands[1]),
7296                                                            operands[2], operands[3],
7297                                                            toc_addr, toc_reg, static_chain));
7298             }
7299           else if (DEFAULT_ABI == ABI_NT)
7300             {
7301               /* NT function pointers are really pointers to a two word area */
7302               rs6000_save_toc_p = 1;
7303               emit_call_insn (gen_call_value_indirect_nt (operands[0],
7304                                                           force_reg (Pmode, operands[1]),
7305                                                           operands[2], operands[3],
7306                                                           toc_addr, toc_reg));
7307             }
7308           else
7309             abort ();
7310         }
7311       DONE;
7312     }
7313 }")
7314
7315 ;; Call to function in current module.  No TOC pointer reload needed.
7316 ;; Operand2 is non-zero if we are using the V.4 calling sequence and
7317 ;; either the function was not prototyped, or it was prototyped as a
7318 ;; variable argument function.  It is > 0 if FP registers were passed
7319 ;; and < 0 if they were not.
7320
7321 (define_insn ""
7322   [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s,s"))
7323          (match_operand 1 "" "g,g"))
7324    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7325    (clobber (match_scratch:SI 3 "=l,l"))]
7326   "(INTVAL (operands[2]) & CALL_LONG) == 0"
7327   "*
7328 {
7329   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7330     output_asm_insn (\"crxor 6,6,6\", operands);
7331
7332   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7333     output_asm_insn (\"creqv 6,6,6\", operands);
7334
7335   return \"bl %z0\";
7336 }"
7337   [(set_attr "type" "branch")
7338    (set_attr "length" "4,8")])
7339
7340 ;; Call to function which may be in another module.  Restore the TOC
7341 ;; pointer (r2) after the call unless this is System V.
7342 ;; Operand2 is non-zero if we are using the V.4 calling sequence and
7343 ;; either the function was not prototyped, or it was prototyped as a
7344 ;; variable argument function.  It is > 0 if FP registers were passed
7345 ;; and < 0 if they were not.
7346
7347 (define_insn ""
7348   [(call (mem:SI (match_operand:SI 0 "call_operand" "s,s"))
7349          (match_operand 1 "" "fg,fg"))
7350    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7351    (clobber (match_scratch:SI 3 "=l,l"))]
7352   "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
7353    && (INTVAL (operands[2]) & CALL_LONG) == 0"
7354   "*
7355 {
7356   /* Indirect calls should go through call_indirect */
7357   if (GET_CODE (operands[0]) == REG)
7358     abort ();
7359
7360   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7361     output_asm_insn (\"crxor 6,6,6\", operands);
7362
7363   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7364     output_asm_insn (\"creqv 6,6,6\", operands);
7365
7366   return (TARGET_WINDOWS_NT) ? \"bl %z0\;.znop %z0\" : \"bl %z0\;%.\";
7367 }"
7368   [(set_attr "type" "branch")
7369    (set_attr "length" "8,12")])
7370
7371 (define_insn ""
7372   [(call (mem:SI (match_operand:SI 0 "call_operand" "s,s"))
7373          (match_operand 1 "" "fg,fg"))
7374    (use (match_operand:SI 2 "immediate_operand" "O,n"))
7375    (clobber (match_scratch:SI 3 "=l,l"))]
7376   "(DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
7377    && (INTVAL (operands[2]) & CALL_LONG) == 0"
7378   "*
7379 {
7380   /* Indirect calls should go through call_indirect */
7381   if (GET_CODE (operands[0]) == REG)
7382     abort ();
7383
7384   if (INTVAL (operands[2]) & CALL_V4_SET_FP_ARGS)
7385     output_asm_insn (\"crxor 6,6,6\", operands);
7386
7387   else if (INTVAL (operands[2]) & CALL_V4_CLEAR_FP_ARGS)
7388     output_asm_insn (\"creqv 6,6,6\", operands);
7389
7390   return \"bl %z0\";
7391 }"
7392   [(set_attr "type" "branch")
7393    (set_attr "length" "4,8")])
7394
7395 (define_insn ""
7396   [(set (match_operand 0 "" "=fg,fg")
7397         (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s,s"))
7398               (match_operand 2 "" "g,g")))
7399    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7400    (clobber (match_scratch:SI 4 "=l,l"))]
7401   "(INTVAL (operands[3]) & CALL_LONG) == 0"
7402   "*
7403 {
7404   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7405     output_asm_insn (\"crxor 6,6,6\", operands);
7406
7407   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7408     output_asm_insn (\"creqv 6,6,6\", operands);
7409
7410   return \"bl %z1\";
7411 }"
7412   [(set_attr "type" "branch")
7413    (set_attr "length" "4,8")])
7414
7415 (define_insn ""
7416   [(set (match_operand 0 "" "=fg,fg")
7417         (call (mem:SI (match_operand:SI 1 "call_operand" "s,s"))
7418               (match_operand 2 "" "fg,fg")))
7419    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7420    (clobber (match_scratch:SI 4 "=l,l"))]
7421   "(DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_NT)
7422    && (INTVAL (operands[3]) & CALL_LONG) == 0"
7423   "*
7424 {
7425   /* This should be handled by call_value_indirect */
7426   if (GET_CODE (operands[1]) == REG)
7427     abort ();
7428
7429   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7430     output_asm_insn (\"crxor 6,6,6\", operands);
7431
7432   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7433     output_asm_insn (\"creqv 6,6,6\", operands);
7434
7435   return (TARGET_WINDOWS_NT) ? \"bl %z1\;.znop %z1\" : \"bl %z1\;%.\";
7436 }"
7437   [(set_attr "type" "branch")
7438    (set_attr "length" "8,12")])
7439
7440 (define_insn ""
7441   [(set (match_operand 0 "" "=fg,fg")
7442         (call (mem:SI (match_operand:SI 1 "call_operand" "s,s"))
7443               (match_operand 2 "" "fg,fg")))
7444    (use (match_operand:SI 3 "immediate_operand" "O,n"))
7445    (clobber (match_scratch:SI 4 "=l,l"))]
7446   "(DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
7447    && (INTVAL (operands[3]) & CALL_LONG) == 0"
7448   "*
7449 {
7450   /* This should be handled by call_value_indirect */
7451   if (GET_CODE (operands[1]) == REG)
7452     abort ();
7453
7454   if (INTVAL (operands[3]) & CALL_V4_SET_FP_ARGS)
7455     output_asm_insn (\"crxor 6,6,6\", operands);
7456
7457   else if (INTVAL (operands[3]) & CALL_V4_CLEAR_FP_ARGS)
7458     output_asm_insn (\"creqv 6,6,6\", operands);
7459
7460   return \"bl %z1\";
7461 }"
7462   [(set_attr "type" "branch")
7463    (set_attr "length" "4,8")])
7464
7465 ;; Call subroutine returning any type.
7466 (define_expand "untyped_call"
7467   [(parallel [(call (match_operand 0 "" "")
7468                     (const_int 0))
7469               (match_operand 1 "" "")
7470               (match_operand 2 "" "")])]
7471   ""
7472   "
7473 {
7474   int i;
7475
7476   emit_call_insn (gen_call (operands[0], const0_rtx, const0_rtx, const0_rtx));
7477
7478   for (i = 0; i < XVECLEN (operands[2], 0); i++)
7479     {
7480       rtx set = XVECEXP (operands[2], 0, i);
7481       emit_move_insn (SET_DEST (set), SET_SRC (set));
7482     }
7483
7484   /* The optimizer does not know that the call sets the function value
7485      registers we stored in the result block.  We avoid problems by
7486      claiming that all hard registers are used and clobbered at this
7487      point.  */
7488   emit_insn (gen_blockage ());
7489
7490   DONE;
7491 }")
7492
7493 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
7494 ;; all of memory.  This blocks insns from being moved across this point.
7495
7496 (define_insn "blockage"
7497   [(unspec_volatile [(const_int 0)] 0)]
7498   ""
7499   "")
7500
7501 ;; Synchronize instructions/data caches for V.4 trampolines
7502 ;; The extra memory_operand is to prevent the optimizer from
7503 ;; deleting insns with "no" effect.
7504 (define_insn "icbi"
7505   [(unspec [(match_operand 0 "memory_operand" "=m")
7506             (match_operand 1 "register_operand" "b")
7507             (match_operand 2 "register_operand" "r")] 3)]
7508   "TARGET_POWERPC"
7509   "icbi %1,%2")
7510
7511 (define_insn "dcbst"
7512   [(unspec [(match_operand 0 "memory_operand" "=m")
7513             (match_operand 1 "register_operand" "b")
7514             (match_operand 2 "register_operand" "r")] 4)]
7515   "TARGET_POWERPC"
7516   "dcbst %1,%2")
7517
7518 (define_insn "sync"
7519   [(unspec [(match_operand 0 "memory_operand" "=m")] 5)]
7520   ""
7521   "{dcs|sync}")
7522
7523 (define_insn "isync"
7524   [(unspec [(match_operand 0 "memory_operand" "=m")] 6)]
7525   ""
7526   "{ics|isync}")
7527
7528
7529 ;; V.4 specific code to initialize the PIC register
7530
7531 (define_insn "init_v4_pic"
7532   [(set (match_operand:SI 0 "register_operand" "=l")
7533         (unspec [(const_int 0)] 7))]
7534   "DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS"
7535   "bl _GLOBAL_OFFSET_TABLE_-4"
7536   [(set_attr "type" "branch")])
7537
7538 \f
7539 ;; Compare insns are next.  Note that the RS/6000 has two types of compares,
7540 ;; signed & unsigned, and one type of branch.
7541 ;;
7542 ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
7543 ;; insns, and branches.  We store the operands of compares until we see
7544 ;; how it is used.
7545 (define_expand "cmpsi"
7546   [(set (cc0)
7547         (compare (match_operand:SI 0 "gpc_reg_operand" "")
7548                  (match_operand:SI 1 "reg_or_short_operand" "")))]
7549   ""
7550   "
7551 {
7552   /* Take care of the possibility that operands[1] might be negative but
7553      this might be a logical operation.  That insn doesn't exist.  */
7554   if (GET_CODE (operands[1]) == CONST_INT
7555       && INTVAL (operands[1]) < 0)
7556     operands[1] = force_reg (SImode, operands[1]);
7557
7558   rs6000_compare_op0 = operands[0];
7559   rs6000_compare_op1 = operands[1];
7560   rs6000_compare_fp_p = 0;
7561   DONE;
7562 }")
7563
7564 (define_expand "cmpdi"
7565   [(set (cc0)
7566         (compare (match_operand:DI 0 "gpc_reg_operand" "")
7567                  (match_operand:DI 1 "reg_or_short_operand" "")))]
7568   "TARGET_POWERPC64"
7569   "
7570 {
7571   /* Take care of the possibility that operands[1] might be negative but
7572      this might be a logical operation.  That insn doesn't exist.  */
7573   if (GET_CODE (operands[1]) == CONST_INT
7574       && INTVAL (operands[1]) < 0)
7575     operands[1] = force_reg (DImode, operands[1]);
7576
7577   rs6000_compare_op0 = operands[0];
7578   rs6000_compare_op1 = operands[1];
7579   rs6000_compare_fp_p = 0;
7580   DONE;
7581 }")
7582
7583 (define_expand "cmpsf"
7584   [(set (cc0) (compare (match_operand:SF 0 "gpc_reg_operand" "")
7585                        (match_operand:SF 1 "gpc_reg_operand" "")))]
7586   "TARGET_HARD_FLOAT"
7587   "
7588 {
7589   rs6000_compare_op0 = operands[0];
7590   rs6000_compare_op1 = operands[1];
7591   rs6000_compare_fp_p = 1;
7592   DONE;
7593 }")
7594
7595 (define_expand "cmpdf"
7596   [(set (cc0) (compare (match_operand:DF 0 "gpc_reg_operand" "")
7597                        (match_operand:DF 1 "gpc_reg_operand" "")))]
7598   "TARGET_HARD_FLOAT"
7599   "
7600 {
7601   rs6000_compare_op0 = operands[0];
7602   rs6000_compare_op1 = operands[1];
7603   rs6000_compare_fp_p = 1;
7604   DONE;
7605 }")
7606
7607 (define_expand "beq"
7608   [(set (match_dup 2) (match_dup 1))
7609    (set (pc)
7610         (if_then_else (eq (match_dup 2)
7611                           (const_int 0))
7612                       (label_ref (match_operand 0 "" ""))
7613                       (pc)))]
7614   ""
7615   "
7616 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7617   operands[1] = gen_rtx (COMPARE, mode,
7618                          rs6000_compare_op0, rs6000_compare_op1);
7619   operands[2] = gen_reg_rtx (mode);
7620 }")
7621
7622 (define_expand "bne"
7623   [(set (match_dup 2) (match_dup 1))
7624    (set (pc)
7625         (if_then_else (ne (match_dup 2)
7626                           (const_int 0))
7627                       (label_ref (match_operand 0 "" ""))
7628                       (pc)))]
7629   ""
7630   "
7631 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7632   operands[1] = gen_rtx (COMPARE, mode,
7633                          rs6000_compare_op0, rs6000_compare_op1);
7634   operands[2] = gen_reg_rtx (mode);
7635 }")
7636
7637 (define_expand "blt"
7638   [(set (match_dup 2) (match_dup 1))
7639    (set (pc)
7640         (if_then_else (lt (match_dup 2)
7641                           (const_int 0))
7642                       (label_ref (match_operand 0 "" ""))
7643                       (pc)))]
7644   ""
7645   "
7646 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7647   operands[1] = gen_rtx (COMPARE, mode,
7648                          rs6000_compare_op0, rs6000_compare_op1);
7649   operands[2] = gen_reg_rtx (mode);
7650 }")
7651
7652 (define_expand "bgt"
7653   [(set (match_dup 2) (match_dup 1))
7654    (set (pc)
7655         (if_then_else (gt (match_dup 2)
7656                           (const_int 0))
7657                       (label_ref (match_operand 0 "" ""))
7658                       (pc)))]
7659   ""
7660   "
7661 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7662   operands[1] = gen_rtx (COMPARE, mode,
7663                          rs6000_compare_op0, rs6000_compare_op1);
7664   operands[2] = gen_reg_rtx (mode);
7665 }")
7666
7667 (define_expand "ble"
7668   [(set (match_dup 2) (match_dup 1))
7669    (set (pc)
7670         (if_then_else (le (match_dup 2)
7671                           (const_int 0))
7672                       (label_ref (match_operand 0 "" ""))
7673                       (pc)))]
7674   ""
7675   "
7676 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7677   operands[1] = gen_rtx (COMPARE, mode,
7678                          rs6000_compare_op0, rs6000_compare_op1);
7679   operands[2] = gen_reg_rtx (mode);
7680 }")
7681
7682 (define_expand "bge"
7683   [(set (match_dup 2) (match_dup 1))
7684    (set (pc)
7685         (if_then_else (ge (match_dup 2)
7686                           (const_int 0))
7687                       (label_ref (match_operand 0 "" ""))
7688                       (pc)))]
7689   ""
7690   "
7691 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7692   operands[1] = gen_rtx (COMPARE, mode,
7693                          rs6000_compare_op0, rs6000_compare_op1);
7694   operands[2] = gen_reg_rtx (mode);
7695 }")
7696
7697 (define_expand "bgtu"
7698   [(set (match_dup 2) (match_dup 1))
7699    (set (pc)
7700         (if_then_else (gtu (match_dup 2)
7701                            (const_int 0))
7702                       (label_ref (match_operand 0 "" ""))
7703                       (pc)))]
7704   ""
7705   "
7706 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7707                          rs6000_compare_op0, rs6000_compare_op1);
7708   operands[2] = gen_reg_rtx (CCUNSmode);
7709 }")
7710
7711 (define_expand "bltu"
7712   [(set (match_dup 2) (match_dup 1))
7713    (set (pc)
7714         (if_then_else (ltu (match_dup 2)
7715                            (const_int 0))
7716                       (label_ref (match_operand 0 "" ""))
7717                       (pc)))]
7718   ""
7719   "
7720 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7721                          rs6000_compare_op0, rs6000_compare_op1);
7722   operands[2] = gen_reg_rtx (CCUNSmode);
7723 }")
7724
7725 (define_expand "bgeu"
7726   [(set (match_dup 2) (match_dup 1))
7727    (set (pc)
7728         (if_then_else (geu (match_dup 2)
7729                            (const_int 0))
7730                       (label_ref (match_operand 0 "" ""))
7731                       (pc)))]
7732   ""
7733   "
7734 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7735                          rs6000_compare_op0, rs6000_compare_op1);
7736   operands[2] = gen_reg_rtx (CCUNSmode);
7737 }")
7738
7739 (define_expand "bleu"
7740   [(set (match_dup 2) (match_dup 1))
7741    (set (pc)
7742         (if_then_else (leu (match_dup 2)
7743                            (const_int 0))
7744                       (label_ref (match_operand 0 "" ""))
7745                       (pc)))]
7746   ""
7747   "
7748 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7749                          rs6000_compare_op0, rs6000_compare_op1);
7750   operands[2] = gen_reg_rtx (CCUNSmode);
7751 }")
7752
7753 ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
7754 ;; For SEQ, likewise, except that comparisons with zero should be done
7755 ;; with an scc insns.  However, due to the order that combine see the
7756 ;; resulting insns, we must, in fact, allow SEQ for integers.  Fail in
7757 ;; the cases we don't want to handle.
7758 (define_expand "seq"
7759   [(set (match_dup 2) (match_dup 1))
7760    (set (match_operand:SI 0 "gpc_reg_operand" "")
7761         (eq:SI (match_dup 2) (const_int 0)))]
7762   ""
7763   "
7764 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7765   operands[1] = gen_rtx (COMPARE, mode,
7766                          rs6000_compare_op0, rs6000_compare_op1);
7767   operands[2] = gen_reg_rtx (mode);
7768 }")
7769
7770 (define_expand "sne"
7771   [(set (match_dup 2) (match_dup 1))
7772    (set (match_operand:SI 0 "gpc_reg_operand" "")
7773         (ne:SI (match_dup 2) (const_int 0)))]
7774   ""
7775   "
7776 { if (! rs6000_compare_fp_p)
7777     FAIL;
7778
7779   operands[1] = gen_rtx (COMPARE, CCFPmode,
7780                          rs6000_compare_op0, rs6000_compare_op1);
7781   operands[2] = gen_reg_rtx (CCFPmode);
7782 }")
7783
7784 ;; A > 0 is best done using the portable sequence, so fail in that case.
7785 (define_expand "sgt"
7786   [(set (match_dup 2) (match_dup 1))
7787    (set (match_operand:SI 0 "gpc_reg_operand" "")
7788         (gt:SI (match_dup 2) (const_int 0)))]
7789   ""
7790   "
7791 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7792
7793   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7794     FAIL;
7795
7796   operands[1] = gen_rtx (COMPARE, mode,
7797                          rs6000_compare_op0, rs6000_compare_op1);
7798   operands[2] = gen_reg_rtx (mode);
7799 }")
7800
7801 ;; A < 0 is best done in the portable way for A an integer.
7802 (define_expand "slt"
7803   [(set (match_dup 2) (match_dup 1))
7804    (set (match_operand:SI 0 "gpc_reg_operand" "")
7805         (lt:SI (match_dup 2) (const_int 0)))]
7806   ""
7807   "
7808 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7809
7810   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7811     FAIL;
7812
7813   operands[1] = gen_rtx (COMPARE, mode,
7814                          rs6000_compare_op0, rs6000_compare_op1);
7815   operands[2] = gen_reg_rtx (mode);
7816 }")
7817
7818 (define_expand "sge"
7819   [(set (match_dup 2) (match_dup 1))
7820    (set (match_operand:SI 0 "gpc_reg_operand" "")
7821         (ge:SI (match_dup 2) (const_int 0)))]
7822   ""
7823   "
7824 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7825   operands[1] = gen_rtx (COMPARE, mode,
7826                          rs6000_compare_op0, rs6000_compare_op1);
7827   operands[2] = gen_reg_rtx (mode);
7828 }")
7829
7830 ;; A <= 0 is best done the portable way for A an integer.
7831 (define_expand "sle"
7832   [(set (match_dup 2) (match_dup 1))
7833    (set (match_operand:SI 0 "gpc_reg_operand" "")
7834         (le:SI (match_dup 2) (const_int 0)))]
7835   ""
7836   "
7837 { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
7838
7839   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
7840     FAIL;
7841
7842   operands[1] = gen_rtx (COMPARE, mode,
7843                          rs6000_compare_op0, rs6000_compare_op1);
7844   operands[2] = gen_reg_rtx (mode);
7845 }")
7846
7847 (define_expand "sgtu"
7848   [(set (match_dup 2) (match_dup 1))
7849    (set (match_operand:SI 0 "gpc_reg_operand" "")
7850         (gtu:SI (match_dup 2) (const_int 0)))]
7851   ""
7852   "
7853 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7854                          rs6000_compare_op0, rs6000_compare_op1);
7855   operands[2] = gen_reg_rtx (CCUNSmode);
7856 }")
7857
7858 (define_expand "sltu"
7859   [(set (match_dup 2) (match_dup 1))
7860    (set (match_operand:SI 0 "gpc_reg_operand" "")
7861         (ltu:SI (match_dup 2) (const_int 0)))]
7862   ""
7863   "
7864 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7865                          rs6000_compare_op0, rs6000_compare_op1);
7866   operands[2] = gen_reg_rtx (CCUNSmode);
7867 }")
7868
7869 (define_expand "sgeu"
7870   [(set (match_dup 2) (match_dup 1))
7871    (set (match_operand:SI 0 "gpc_reg_operand" "")
7872         (geu:SI (match_dup 2) (const_int 0)))]
7873   ""
7874   "
7875 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7876                          rs6000_compare_op0, rs6000_compare_op1);
7877   operands[2] = gen_reg_rtx (CCUNSmode);
7878 }")
7879
7880 (define_expand "sleu"
7881   [(set (match_dup 2) (match_dup 1))
7882    (set (match_operand:SI 0 "gpc_reg_operand" "")
7883         (leu:SI (match_dup 2) (const_int 0)))]
7884   ""
7885   "
7886 { operands[1] = gen_rtx (COMPARE, CCUNSmode,
7887                          rs6000_compare_op0, rs6000_compare_op1);
7888   operands[2] = gen_reg_rtx (CCUNSmode);
7889 }")
7890 \f
7891 ;; Here are the actual compare insns.
7892 (define_insn ""
7893   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
7894         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
7895                     (match_operand:SI 2 "reg_or_short_operand" "rI")))]
7896   ""
7897   "{cmp%I2|cmpw%I2} %0,%1,%2"
7898   [(set_attr "type" "compare")])
7899
7900 (define_insn ""
7901   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
7902         (compare:CC (match_operand:DI 1 "gpc_reg_operand" "r")
7903                     (match_operand:DI 2 "reg_or_short_operand" "rI")))]
7904   "TARGET_POWERPC64"
7905   "cmpd%I2 %0,%1,%2"
7906   [(set_attr "type" "compare")])
7907
7908 ;; If we are comparing a register for equality with a large constant,
7909 ;; we can do this with an XOR followed by a compare.  But we need a scratch
7910 ;; register for the result of the XOR.
7911
7912 (define_split
7913   [(set (match_operand:CC 0 "cc_reg_operand" "")
7914         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
7915                     (match_operand:SI 2 "non_short_cint_operand" "")))
7916    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
7917   "find_single_use (operands[0], insn, 0)
7918    && (GET_CODE (*find_single_use (operands[0], insn, 0)) == EQ
7919        || GET_CODE (*find_single_use (operands[0], insn, 0)) == NE)"
7920   [(set (match_dup 3) (xor:SI (match_dup 1) (match_dup 4)))
7921    (set (match_dup 0) (compare:CC (match_dup 3) (match_dup 5)))]
7922   "
7923 {
7924   /* Get the constant we are comparing against, C,  and see what it looks like
7925      sign-extended to 16 bits.  Then see what constant could be XOR'ed
7926      with C to get the sign-extended value.  */
7927
7928   int c = INTVAL (operands[2]);
7929   int sextc = (c << 16) >> 16;
7930   int xorv = c ^ sextc;
7931
7932   operands[4] = gen_rtx (CONST_INT, VOIDmode, xorv);
7933   operands[5] = gen_rtx (CONST_INT, VOIDmode, sextc);
7934 }")
7935
7936 (define_insn ""
7937   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
7938         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
7939                        (match_operand:SI 2 "reg_or_u_short_operand" "rI")))]
7940   ""
7941   "{cmpl%I2|cmplw%I2} %0,%1,%W2"
7942   [(set_attr "type" "compare")])
7943
7944 (define_insn ""
7945   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
7946         (compare:CCUNS (match_operand:DI 1 "gpc_reg_operand" "r")
7947                        (match_operand:DI 2 "reg_or_u_short_operand" "rI")))]
7948   ""
7949   "cmpld%I2 %0,%1,%W2"
7950   [(set_attr "type" "compare")])
7951
7952 ;; The following two insns don't exist as single insns, but if we provide
7953 ;; them, we can swap an add and compare, which will enable us to overlap more
7954 ;; of the required delay between a compare and branch.  We generate code for
7955 ;; them by splitting.
7956
7957 (define_insn ""
7958   [(set (match_operand:CC 3 "cc_reg_operand" "=y")
7959         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
7960                     (match_operand:SI 2 "short_cint_operand" "i")))
7961    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
7962         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
7963   ""
7964   "#"
7965   [(set_attr "length" "8")])
7966
7967 (define_insn ""
7968   [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
7969         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
7970                        (match_operand:SI 2 "u_short_cint_operand" "i")))
7971    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
7972         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
7973   ""
7974   "#"
7975   [(set_attr "length" "8")])
7976
7977 (define_split
7978   [(set (match_operand:CC 3 "cc_reg_operand" "")
7979         (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
7980                     (match_operand:SI 2 "short_cint_operand" "")))
7981    (set (match_operand:SI 0 "gpc_reg_operand" "")
7982         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
7983   ""
7984   [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
7985    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
7986
7987 (define_split
7988   [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
7989         (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
7990                        (match_operand:SI 2 "u_short_cint_operand" "")))
7991    (set (match_operand:SI 0 "gpc_reg_operand" "")
7992         (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
7993   ""
7994   [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
7995    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
7996
7997 (define_insn ""
7998   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
7999         (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
8000                       (match_operand:SF 2 "gpc_reg_operand" "f")))]
8001   "TARGET_HARD_FLOAT"
8002   "fcmpu %0,%1,%2"
8003   [(set_attr "type" "fpcompare")])
8004
8005 (define_insn ""
8006   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
8007         (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
8008                       (match_operand:DF 2 "gpc_reg_operand" "f")))]
8009   "TARGET_HARD_FLOAT"
8010   "fcmpu %0,%1,%2"
8011   [(set_attr "type" "fpcompare")])
8012 \f
8013 ;; Now we have the scc insns.  We can do some combinations because of the
8014 ;; way the machine works.
8015 ;;
8016 ;; Note that this is probably faster if we can put an insn between the
8017 ;; mfcr and rlinm, but this is tricky.  Let's leave it for now.  In most
8018 ;; cases the insns below which don't use an intermediate CR field will
8019 ;; be used instead.
8020 (define_insn ""
8021   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8022         (match_operator:SI 1 "scc_comparison_operator"
8023                            [(match_operand 2 "cc_reg_operand" "y")
8024                             (const_int 0)]))]
8025   ""
8026   "%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%J1,1"
8027   [(set_attr "length" "12")])
8028
8029 (define_insn ""
8030   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8031         (compare:CC (match_operator:SI 1 "scc_comparison_operator"
8032                                        [(match_operand 2 "cc_reg_operand" "y")
8033                                         (const_int 0)])
8034                     (const_int 0)))
8035    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
8036         (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
8037   ""
8038   "%D1mfcr %3\;{rlinm.|rlwinm.} %3,%3,%J1,1"
8039   [(set_attr "type" "delayed_compare")
8040    (set_attr "length" "12")])
8041
8042 (define_insn ""
8043   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8044         (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
8045                                       [(match_operand 2 "cc_reg_operand" "y")
8046                                        (const_int 0)])
8047                    (match_operand:SI 3 "const_int_operand" "n")))]
8048   ""
8049   "*
8050 {
8051   int is_bit = ccr_bit (operands[1], 1);
8052   int put_bit = 31 - (INTVAL (operands[3]) & 31);
8053   int count;
8054
8055   if (is_bit >= put_bit)
8056     count = is_bit - put_bit;
8057   else
8058     count = 32 - (put_bit - is_bit);
8059
8060   operands[4] = gen_rtx (CONST_INT, VOIDmode, count);
8061   operands[5] = gen_rtx (CONST_INT, VOIDmode, put_bit);
8062
8063   return \"%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
8064 }"
8065  [(set_attr "length" "12")])
8066
8067 (define_insn ""
8068   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8069         (compare:CC
8070          (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
8071                                        [(match_operand 2 "cc_reg_operand" "y")
8072                                         (const_int 0)])
8073                     (match_operand:SI 3 "const_int_operand" "n"))
8074          (const_int 0)))
8075    (set (match_operand:SI 4 "gpc_reg_operand" "=r")
8076         (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
8077                    (match_dup 3)))]
8078   ""
8079   "*
8080 {
8081   int is_bit = ccr_bit (operands[1], 1);
8082   int put_bit = 31 - (INTVAL (operands[3]) & 31);
8083   int count;
8084
8085   if (is_bit >= put_bit)
8086     count = is_bit - put_bit;
8087   else
8088     count = 32 - (put_bit - is_bit);
8089
8090   operands[5] = gen_rtx (CONST_INT, VOIDmode, count);
8091   operands[6] = gen_rtx (CONST_INT, VOIDmode, put_bit);
8092
8093   return \"%D1mfcr %4\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
8094 }"
8095   [(set_attr "type" "delayed_compare")
8096    (set_attr "length" "12")])
8097
8098 ;; If we are comparing the result of two comparisons, this can be done
8099 ;; using creqv or crxor.
8100
8101 (define_insn ""
8102   [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
8103         (compare:CCEQ (match_operator 1 "scc_comparison_operator"
8104                               [(match_operand 2 "cc_reg_operand" "y")
8105                                (const_int 0)])
8106                       (match_operator 3 "scc_comparison_operator"
8107                               [(match_operand 4 "cc_reg_operand" "y")
8108                                (const_int 0)])))]
8109   "REGNO (operands[2]) != REGNO (operands[4])"
8110   "*
8111 {
8112   enum rtx_code code1, code2;
8113
8114   code1 = GET_CODE (operands[1]);
8115   code2 = GET_CODE (operands[3]);
8116
8117   if ((code1 == EQ || code1 == LT || code1 == GT
8118        || code1 == LTU || code1 == GTU
8119        || (code1 != NE && GET_MODE (operands[2]) == CCFPmode))
8120       !=
8121       (code2 == EQ || code2 == LT || code2 == GT
8122        || code2 == LTU || code2 == GTU
8123        || (code2 != NE && GET_MODE (operands[4]) == CCFPmode)))
8124     return \"%C1%C3crxor %E0,%j1,%j3\";
8125   else
8126     return \"%C1%C3creqv %E0,%j1,%j3\";
8127 }"
8128   [(set_attr "length" "12")])
8129
8130 ;; There is a 3 cycle delay between consecutive mfcr instructions
8131 ;; so it is useful to combine 2 scc instructions to use only one mfcr.
8132
8133 (define_peephole
8134   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8135         (match_operator:SI 1 "scc_comparison_operator"
8136                            [(match_operand 2 "cc_reg_operand" "y")
8137                             (const_int 0)]))
8138    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
8139         (match_operator:SI 4 "scc_comparison_operator"
8140                            [(match_operand 5 "cc_reg_operand" "y")
8141                             (const_int 0)]))]
8142    "REGNO (operands[2]) != REGNO (operands[5])"
8143    "%D1%D4mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
8144    [(set_attr "length" "20")])
8145
8146 ;; There are some scc insns that can be done directly, without a compare.
8147 ;; These are faster because they don't involve the communications between
8148 ;; the FXU and branch units.   In fact, we will be replacing all of the
8149 ;; integer scc insns here or in the portable methods in emit_store_flag.
8150 ;;
8151 ;; Also support (neg (scc ..)) since that construct is used to replace
8152 ;; branches, (plus (scc ..) ..) since that construct is common and
8153 ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
8154 ;; cases where it is no more expensive than (neg (scc ..)).
8155
8156 ;; Have reload force a constant into a register for the simple insns that
8157 ;; otherwise won't accept constants.  We do this because it is faster than
8158 ;; the cmp/mfcr sequence we would otherwise generate.
8159
8160 (define_insn ""
8161   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8162         (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8163                (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I")))
8164    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
8165   ""
8166   "@
8167    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8168    {sfi|subfic} %3,%1,0\;{ae|adde} %0,%3,%1
8169    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8170    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
8171    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0"
8172   [(set_attr "length" "12,8,12,12,12")])
8173
8174 (define_insn ""
8175   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x")
8176         (compare:CC
8177          (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8178                 (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8179          (const_int 0)))
8180    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8181         (eq:SI (match_dup 1) (match_dup 2)))
8182    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
8183   ""
8184   "@
8185    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8186    {sfi|subfic} %3,%1,0\;{ae.|adde.} %0,%3,%1
8187    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8188    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
8189    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0"
8190   [(set_attr "type" "compare")
8191    (set_attr "length" "12,8,12,12,12")])
8192
8193 ;; We have insns of the form shown by the first define_insn below.  If
8194 ;; there is something inside the comparison operation, we must split it.
8195 (define_split
8196   [(set (match_operand:SI 0 "gpc_reg_operand" "")
8197         (plus:SI (match_operator 1 "comparison_operator"
8198                                  [(match_operand:SI 2 "" "")
8199                                   (match_operand:SI 3
8200                                                     "reg_or_cint_operand" "")])
8201                  (match_operand:SI 4 "gpc_reg_operand" "")))
8202    (clobber (match_operand:SI 5 "register_operand" ""))]
8203   "! gpc_reg_operand (operands[2], SImode)"
8204   [(set (match_dup 5) (match_dup 2))
8205    (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
8206                                (match_dup 4)))])
8207
8208 (define_insn ""
8209   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8210         (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8211                         (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8212                  (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))
8213    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8214   ""
8215   "@
8216    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8217    {sfi|subfic} %4,%1,0\;{aze|addze} %0,%3
8218    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8219    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8220    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
8221   [(set_attr "length" "12,8,12,12,12")])
8222
8223 (define_insn ""
8224   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x")
8225         (compare:CC
8226          (plus:SI
8227           (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8228                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8229           (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
8230          (const_int 0)))
8231    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8232   ""
8233   "@
8234    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8235    {sfi|subfic} %4,%1,0\;{aze.|addze.} %0,%3
8236    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8237    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8238    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
8239   [(set_attr "type" "compare")
8240    (set_attr "length" "12,8,12,12,12")])
8241
8242 (define_insn ""
8243   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x,x,x,x")
8244         (compare:CC
8245          (plus:SI
8246           (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8247                  (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
8248           (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
8249          (const_int 0)))
8250    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8251         (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8252    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
8253   ""
8254   "@
8255    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8256    {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
8257    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8258    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8259    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
8260   [(set_attr "type" "compare")
8261    (set_attr "length" "12,8,12,12,12")])
8262
8263 (define_insn ""
8264   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
8265         (neg:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
8266                        (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))))]
8267   ""
8268   "@
8269    xor %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8270    {ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0
8271    {xoril|xori} %0,%1,%b2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8272    {xoriu|xoris} %0,%1,%u2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8273    {sfi|subfic} %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
8274    [(set_attr "length" "12,8,12,12,12")])
8275
8276 ;; Simplify (ne X (const_int 0)) on the PowerPC.  No need to on the Power,
8277 ;; since it nabs/sr is just as fast.
8278 (define_insn ""
8279   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8280         (lshiftrt:SI (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8281                      (const_int 31)))
8282    (clobber (match_scratch:SI 2 "=&r"))]
8283   "!TARGET_POWER"
8284   "{ai|addic} %2,%1,-1\;{sfe|subfe} %0,%2,%1"
8285   [(set_attr "length" "8")])
8286
8287 ;; This is what (plus (ne X (const_int 0)) Y) looks like.
8288 (define_insn ""
8289   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8290         (plus:SI (lshiftrt:SI
8291                   (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8292                   (const_int 31))
8293                  (match_operand:SI 2 "gpc_reg_operand" "r")))
8294    (clobber (match_scratch:SI 3 "=&r"))]
8295   ""
8296   "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
8297   [(set_attr "length" "8")])
8298
8299 (define_insn ""
8300   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8301         (compare:CC
8302          (plus:SI (lshiftrt:SI
8303                    (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8304                    (const_int 31))
8305                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8306          (const_int 0)))
8307    (clobber (match_scratch:SI 3 "=&r"))]
8308   ""
8309   "{ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2"
8310   [(set_attr "type" "compare")
8311    (set_attr "length" "8")])
8312
8313 (define_insn ""
8314   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8315         (compare:CC
8316          (plus:SI (lshiftrt:SI
8317                    (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
8318                    (const_int 31))
8319                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8320          (const_int 0)))
8321    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8322         (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
8323                  (match_dup 2)))
8324    (clobber (match_scratch:SI 3 "=&r"))]
8325   ""
8326   "{ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2"
8327   [(set_attr "type" "compare")
8328    (set_attr "length" "8")])
8329
8330 (define_insn ""
8331   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8332         (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8333                (match_operand:SI 2 "reg_or_short_operand" "r,O")))
8334    (clobber (match_scratch:SI 3 "=r,X"))]
8335   "TARGET_POWER"
8336   "@
8337    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
8338    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
8339   [(set_attr "length" "12")])
8340
8341 (define_insn ""
8342   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x")
8343         (compare:CC
8344          (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8345                 (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8346          (const_int 0)))
8347    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8348         (le:SI (match_dup 1) (match_dup 2)))
8349    (clobber (match_scratch:SI 3 "=r,X"))]
8350   "TARGET_POWER"
8351   "@
8352    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
8353    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31"
8354   [(set_attr "type" "compare,delayed_compare")
8355    (set_attr "length" "12")])
8356
8357 (define_insn ""
8358   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8359         (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8360                         (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8361                  (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8362    (clobber (match_scratch:SI 4 "=&r,&r"))]
8363   "TARGET_POWER"
8364   "@
8365    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
8366    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze|addze} %0,%3"
8367   [(set_attr "length" "12")])
8368
8369 (define_insn ""
8370   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8371         (compare:CC
8372          (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8373                          (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8374                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8375          (const_int 0)))
8376    (clobber (match_scratch:SI 4 "=&r,&r"))]
8377   "TARGET_POWER"
8378   "@
8379    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
8380    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3"
8381   [(set_attr "type" "compare")
8382    (set_attr "length" "12")])
8383
8384 (define_insn ""
8385   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8386         (compare:CC
8387          (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8388                          (match_operand:SI 2 "reg_or_short_operand" "r,O"))
8389                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8390          (const_int 0)))
8391    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8392         (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8393    (clobber (match_scratch:SI 4 "=&r,&r"))]
8394   "TARGET_POWER"
8395   "@
8396    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
8397    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %0,%3"
8398   [(set_attr "type" "compare")
8399    (set_attr "length" "12")])
8400
8401 (define_insn ""
8402   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8403         (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8404                        (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
8405   "TARGET_POWER"
8406   "@
8407    doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
8408    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
8409   [(set_attr "length" "12")])
8410
8411 (define_insn ""
8412   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8413         (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8414                 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
8415   ""
8416   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
8417   [(set_attr "length" "12")])
8418
8419 (define_insn ""
8420   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8421         (compare:CC
8422          (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8423                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
8424          (const_int 0)))
8425    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8426         (leu:SI (match_dup 1) (match_dup 2)))]
8427    ""
8428   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
8429   [(set_attr "type" "compare")
8430    (set_attr "length" "12")])
8431
8432 (define_insn ""
8433   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8434         (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8435                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8436                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8437    (clobber (match_scratch:SI 4 "=&r"))]
8438   ""
8439   "{sf%I2|subf%I2c} %4,%1,%2\;{aze|addze} %0,%3"
8440   [(set_attr "length" "8")])
8441
8442 (define_insn ""
8443   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8444         (compare:CC
8445          (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8446                           (match_operand:SI 2 "reg_or_short_operand" "rI"))
8447                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8448          (const_int 0)))
8449    (clobber (match_scratch:SI 4 "=&r"))]
8450   ""
8451   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3"
8452   [(set_attr "type" "compare")
8453    (set_attr "length" "8")])
8454
8455 (define_insn ""
8456   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8457         (compare:CC
8458          (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8459                           (match_operand:SI 2 "reg_or_short_operand" "rI"))
8460                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8461          (const_int 0)))
8462    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8463         (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8464    (clobber (match_scratch:SI 4 "=&r"))]
8465   ""
8466   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %0,%3"
8467   [(set_attr "type" "compare")
8468    (set_attr "length" "8")])
8469
8470 (define_insn ""
8471   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8472         (neg:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8473                         (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8474   ""
8475   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
8476    [(set_attr "length" "12")])
8477
8478 (define_insn ""
8479   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8480         (and:SI (neg:SI
8481                  (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8482                          (match_operand:SI 2 "reg_or_short_operand" "rI")))
8483                 (match_operand:SI 3 "gpc_reg_operand" "r")))
8484    (clobber (match_scratch:SI 4 "=&r"))]
8485   ""
8486   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
8487   [(set_attr "length" "12")])
8488
8489 (define_insn ""
8490   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8491         (compare:CC
8492          (and:SI (neg:SI
8493                   (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8494                           (match_operand:SI 2 "reg_or_short_operand" "rI")))
8495                  (match_operand:SI 3 "gpc_reg_operand" "r"))
8496          (const_int 0)))
8497    (clobber (match_scratch:SI 4 "=&r"))]
8498   ""
8499   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
8500   [(set_attr "type" "compare")
8501    (set_attr "length" "12")])
8502
8503 (define_insn ""
8504   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8505         (compare:CC
8506          (and:SI (neg:SI
8507                   (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8508                           (match_operand:SI 2 "reg_or_short_operand" "rI")))
8509                  (match_operand:SI 3 "gpc_reg_operand" "r"))
8510          (const_int 0)))
8511    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8512         (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
8513    (clobber (match_scratch:SI 4 "=&r"))]
8514   ""
8515   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
8516   [(set_attr "type" "compare")
8517    (set_attr "length" "12")])
8518
8519 (define_insn ""
8520   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8521         (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8522                (match_operand:SI 2 "reg_or_short_operand" "rI")))]
8523   "TARGET_POWER"
8524   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
8525    [(set_attr "length" "12")])
8526
8527 (define_insn ""
8528   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8529         (compare:CC
8530          (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8531                 (match_operand:SI 2 "reg_or_short_operand" "rI"))
8532          (const_int 0)))
8533    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8534         (lt:SI (match_dup 1) (match_dup 2)))]
8535   "TARGET_POWER"
8536   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
8537   [(set_attr "type" "delayed_compare")
8538    (set_attr "length" "12")])
8539
8540 (define_insn ""
8541   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8542         (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8543                         (match_operand:SI 2 "reg_or_short_operand" "rI"))
8544                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8545    (clobber (match_scratch:SI 4 "=&r"))]
8546   "TARGET_POWER"
8547   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
8548   [(set_attr "length" "12")])
8549
8550 (define_insn ""
8551   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8552         (compare:CC
8553          (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8554                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8555                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8556          (const_int 0)))
8557    (clobber (match_scratch:SI 4 "=&r"))]
8558   "TARGET_POWER"
8559   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
8560   [(set_attr "type" "compare")
8561    (set_attr "length" "12")])
8562
8563 (define_insn ""
8564   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8565         (compare:CC
8566          (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8567                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8568                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8569          (const_int 0)))
8570    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8571         (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8572    (clobber (match_scratch:SI 4 "=&r"))]
8573   "TARGET_POWER"
8574   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
8575   [(set_attr "type" "compare")
8576    (set_attr "length" "12")])
8577
8578 (define_insn ""
8579   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8580         (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8581                        (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8582   "TARGET_POWER"
8583   "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
8584   [(set_attr "length" "12")])
8585
8586 (define_insn ""
8587   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8588         (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8589                 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
8590   ""
8591   "@
8592    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg %0,%0
8593    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
8594   [(set_attr "length" "12")])
8595
8596 (define_insn ""
8597   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
8598         (compare:CC
8599          (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8600                  (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8601          (const_int 0)))
8602    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8603         (ltu:SI (match_dup 1) (match_dup 2)))]
8604   ""
8605   "@
8606    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg. %0,%0
8607    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
8608   [(set_attr "type" "compare")
8609    (set_attr "length" "12")])
8610
8611 (define_insn ""
8612   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
8613         (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
8614                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,r,P,P"))
8615                  (match_operand:SI 3 "reg_or_short_operand" "r,I,r,I")))
8616    (clobber (match_scratch:SI 4 "=&r,r,&r,r"))]
8617   ""
8618   "@
8619   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8620   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8621   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
8622   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
8623  [(set_attr "length" "12")])
8624
8625 (define_insn ""
8626   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8627         (compare:CC
8628          (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8629                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8630                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8631          (const_int 0)))
8632    (clobber (match_scratch:SI 4 "=&r,&r"))]
8633   ""
8634   "@
8635    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3
8636    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3"
8637   [(set_attr "type" "compare")
8638    (set_attr "length" "12")])
8639
8640 (define_insn ""
8641   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8642         (compare:CC
8643          (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8644                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8645                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8646          (const_int 0)))
8647    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8648         (plus:SI (ltu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8649    (clobber (match_scratch:SI 4 "=&r,&r"))]
8650   ""
8651   "@
8652    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3
8653    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
8654   [(set_attr "type" "compare")
8655    (set_attr "length" "12")])
8656
8657 (define_insn ""
8658   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8659         (neg:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8660                         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))))]
8661   ""
8662   "@
8663    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
8664    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
8665   [(set_attr "length" "8")])
8666
8667 (define_insn ""
8668   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8669         (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8670                (match_operand:SI 2 "reg_or_short_operand" "rI")))
8671    (clobber (match_scratch:SI 3 "=r"))]
8672   "TARGET_POWER"
8673   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
8674    [(set_attr "length" "12")])
8675
8676 (define_insn ""
8677   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8678         (compare:CC
8679          (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8680                 (match_operand:SI 2 "reg_or_short_operand" "rI"))
8681          (const_int 0)))
8682    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8683         (ge:SI (match_dup 1) (match_dup 2)))
8684    (clobber (match_scratch:SI 3 "=r"))]
8685   "TARGET_POWER"
8686   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3"
8687   [(set_attr "type" "compare")
8688    (set_attr "length" "12")])
8689
8690 (define_insn ""
8691   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8692         (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8693                         (match_operand:SI 2 "reg_or_short_operand" "rI"))
8694                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8695    (clobber (match_scratch:SI 4 "=&r"))]
8696   "TARGET_POWER"
8697   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
8698   [(set_attr "length" "12")])
8699
8700 (define_insn ""
8701   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8702         (compare:CC
8703          (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8704                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8705                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8706          (const_int 0)))
8707    (clobber (match_scratch:SI 4 "=&r"))]
8708   "TARGET_POWER"
8709   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
8710   [(set_attr "type" "compare")
8711    (set_attr "length" "12")])
8712
8713 (define_insn ""
8714   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
8715         (compare:CC
8716          (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8717                          (match_operand:SI 2 "reg_or_short_operand" "rI"))
8718                   (match_operand:SI 3 "gpc_reg_operand" "r"))
8719          (const_int 0)))
8720    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8721         (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8722    (clobber (match_scratch:SI 4 "=&r"))]
8723   "TARGET_POWER"
8724   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
8725   [(set_attr "type" "compare")
8726    (set_attr "length" "12")])
8727
8728 (define_insn ""
8729   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8730         (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8731                        (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
8732   "TARGET_POWER"
8733   "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
8734   [(set_attr "length" "12")])
8735
8736 ;; This is (and (neg (ge X (const_int 0))) Y).
8737 (define_insn ""
8738   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8739         (and:SI (neg:SI
8740                  (lshiftrt:SI
8741                   (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8742                   (const_int 31)))
8743                 (match_operand:SI 2 "gpc_reg_operand" "r")))
8744    (clobber (match_scratch:SI 3 "=&r"))]
8745   ""
8746   "{srai|srawi} %3,%1,31\;andc %0,%2,%3"
8747   [(set_attr "length" "8")])
8748
8749 (define_insn ""
8750   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8751         (compare:CC
8752          (and:SI (neg:SI
8753                   (lshiftrt:SI
8754                    (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8755                    (const_int 31)))
8756                  (match_operand:SI 2 "gpc_reg_operand" "r"))
8757          (const_int 0)))
8758    (clobber (match_scratch:SI 3 "=&r"))]
8759   ""
8760   "{srai|srawi} %3,%1,31\;andc. %3,%2,%3"
8761   [(set_attr "type" "compare")
8762    (set_attr "length" "8")])
8763
8764 (define_insn ""
8765   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8766         (compare:CC
8767          (and:SI (neg:SI
8768                   (lshiftrt:SI
8769                    (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
8770                    (const_int 31)))
8771                  (match_operand:SI 2 "gpc_reg_operand" "r"))
8772          (const_int 0)))
8773    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8774         (and:SI (neg:SI (lshiftrt:SI (not:SI (match_dup 1))
8775                                      (const_int 31)))
8776                 (match_dup 2)))
8777    (clobber (match_scratch:SI 3 "=&r"))]
8778   ""
8779   "{srai|srawi} %3,%1,31\;andc. %0,%2,%3"
8780   [(set_attr "type" "compare")
8781    (set_attr "length" "8")])
8782
8783 (define_insn ""
8784   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8785         (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8786                 (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
8787   ""
8788   "@
8789    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
8790    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
8791   [(set_attr "length" "12")])
8792
8793 (define_insn ""
8794   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
8795         (compare:CC
8796          (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8797                  (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8798          (const_int 0)))
8799    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8800         (geu:SI (match_dup 1) (match_dup 2)))]
8801   ""
8802   "@
8803    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
8804    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
8805   [(set_attr "type" "compare")
8806    (set_attr "length" "12")])
8807
8808 (define_insn ""
8809   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8810         (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8811                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8812                  (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8813    (clobber (match_scratch:SI 4 "=&r,&r"))]
8814   ""
8815   "@
8816    {sf|subfc} %4,%2,%1\;{aze|addze} %0,%3
8817    {ai|addic} %4,%1,%n2\;{aze|addze} %0,%3"
8818   [(set_attr "length" "8")])
8819
8820 (define_insn ""
8821   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8822         (compare:CC
8823          (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8824                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8825                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8826          (const_int 0)))
8827    (clobber (match_scratch:SI 4 "=&r,&r"))]
8828   ""
8829   "@
8830    {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
8831    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
8832   [(set_attr "type" "compare")
8833    (set_attr "length" "8")])
8834
8835 (define_insn ""
8836   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8837         (compare:CC
8838          (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8839                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
8840                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8841          (const_int 0)))
8842    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8843         (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
8844    (clobber (match_scratch:SI 4 "=&r,&r"))]
8845   ""
8846   "@
8847    {sf|subfc} %4,%2,%1\;{aze.|addze.} %0,%3
8848    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
8849   [(set_attr "type" "compare")
8850    (set_attr "length" "8")])
8851
8852 (define_insn ""
8853   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8854         (neg:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8855                         (match_operand:SI 2 "reg_or_short_operand" "r,I"))))]
8856   ""
8857   "@
8858    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
8859    {sfi|subfic} %0,%1,-1\;{a%I2|add%I2c} %0,%0,%2\;{sfe|subfe} %0,%0,%0"
8860   [(set_attr "length" "12")])
8861
8862 (define_insn ""
8863   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8864         (and:SI (neg:SI
8865                  (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8866                          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8867                 (match_operand:SI 3 "gpc_reg_operand" "r,r")))
8868    (clobber (match_scratch:SI 4 "=&r,&r"))]
8869   ""
8870   "@
8871    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4
8872    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
8873   [(set_attr "length" "12")])
8874
8875 (define_insn ""
8876   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
8877         (compare:CC
8878          (and:SI (neg:SI
8879                   (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8880                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8881                  (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8882          (const_int 0)))
8883    (clobber (match_scratch:SI 4 "=&r,&r"))]
8884   ""
8885   "@
8886    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
8887    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
8888   [(set_attr "type" "compare")
8889    (set_attr "length" "12")])
8890
8891 (define_insn ""
8892   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
8893         (compare:CC
8894          (and:SI (neg:SI
8895                   (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
8896                           (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
8897                  (match_operand:SI 3 "gpc_reg_operand" "r,r"))
8898          (const_int 0)))
8899    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
8900         (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
8901    (clobber (match_scratch:SI 4 "=&r,&r"))]
8902   ""
8903   "@
8904    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4
8905    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
8906   [(set_attr "type" "compare")
8907    (set_attr "length" "12")])
8908
8909 (define_insn ""
8910   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8911         (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8912                (const_int 0)))]
8913   ""
8914   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri|srwi} %0,%0,31"
8915   [(set_attr "length" "12")])
8916
8917 (define_insn ""
8918   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
8919         (compare:CC
8920          (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8921                 (const_int 0))
8922          (const_int 0)))
8923    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8924         (gt:SI (match_dup 1) (const_int 0)))]
8925   ""
8926   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri.|srwi.} %0,%0,31"
8927   [(set_attr "type" "delayed_compare")
8928    (set_attr "length" "12")])
8929
8930 (define_insn ""
8931   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8932         (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8933                (match_operand:SI 2 "reg_or_short_operand" "r")))]
8934   "TARGET_POWER"
8935   "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
8936   [(set_attr "length" "12")])
8937
8938 (define_insn ""
8939   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
8940         (compare:CC
8941          (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8942                 (match_operand:SI 2 "reg_or_short_operand" "r"))
8943          (const_int 0)))
8944    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8945         (gt:SI (match_dup 1) (match_dup 2)))]
8946   "TARGET_POWER"
8947   "doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
8948   [(set_attr "type" "delayed_compare")
8949    (set_attr "length" "12")])
8950
8951 (define_insn ""
8952   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8953         (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8954                         (const_int 0))
8955                  (match_operand:SI 2 "gpc_reg_operand" "r")))
8956    (clobber (match_scratch:SI 3 "=&r"))]
8957   ""
8958   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze|addze} %0,%2"
8959   [(set_attr "length" "12")])
8960
8961 (define_insn ""
8962   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
8963         (compare:CC
8964          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8965                          (const_int 0))
8966                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8967          (const_int 0)))
8968    (clobber (match_scratch:SI 3 "=&r"))]
8969   ""
8970   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %0,%2"
8971   [(set_attr "type" "compare")
8972    (set_attr "length" "12")])
8973
8974 (define_insn ""
8975   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
8976         (compare:CC
8977          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8978                          (const_int 0))
8979                   (match_operand:SI 2 "gpc_reg_operand" "r"))
8980          (const_int 0)))
8981    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
8982         (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
8983    (clobber (match_scratch:SI 3 "=&r"))]
8984   ""
8985   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2"
8986   [(set_attr "type" "compare")
8987    (set_attr "length" "12")])
8988
8989 (define_insn ""
8990   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
8991         (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
8992                         (match_operand:SI 2 "reg_or_short_operand" "r"))
8993                  (match_operand:SI 3 "gpc_reg_operand" "r")))
8994    (clobber (match_scratch:SI 4 "=&r"))]
8995   "TARGET_POWER"
8996   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
8997   [(set_attr "length" "12")])
8998
8999 (define_insn ""
9000   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
9001         (compare:CC
9002          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9003                          (match_operand:SI 2 "reg_or_short_operand" "r"))
9004                   (match_operand:SI 3 "gpc_reg_operand" "r"))
9005          (const_int 0)))
9006    (clobber (match_scratch:SI 4 "=&r"))]
9007   "TARGET_POWER"
9008   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
9009   [(set_attr "type" "compare")
9010    (set_attr "length" "12")])
9011
9012 (define_insn ""
9013   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
9014         (compare:CC
9015          (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9016                          (match_operand:SI 2 "reg_or_short_operand" "r"))
9017                   (match_operand:SI 3 "gpc_reg_operand" "r"))
9018          (const_int 0)))
9019    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
9020         (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
9021    (clobber (match_scratch:SI 4 "=&r"))]
9022   "TARGET_POWER"
9023   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
9024   [(set_attr "type" "compare")
9025    (set_attr "length" "12")])
9026
9027 (define_insn ""
9028   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9029         (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9030                        (const_int 0))))]
9031   ""
9032   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{srai|srawi} %0,%0,31"
9033   [(set_attr "length" "12")])
9034
9035 (define_insn ""
9036   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9037         (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9038                        (match_operand:SI 2 "reg_or_short_operand" "r"))))]
9039   "TARGET_POWER"
9040   "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
9041   [(set_attr "length" "12")])
9042
9043 (define_insn ""
9044   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9045         (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9046                 (match_operand:SI 2 "reg_or_short_operand" "rI")))]
9047   ""
9048   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
9049   [(set_attr "length" "12")])
9050
9051 (define_insn ""
9052   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
9053         (compare:CC
9054          (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9055                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
9056          (const_int 0)))
9057    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
9058         (gtu:SI (match_dup 1) (match_dup 2)))]
9059   ""
9060   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
9061   [(set_attr "type" "compare")
9062    (set_attr "length" "12")])
9063
9064 (define_insn ""
9065   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
9066         (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
9067                          (match_operand:SI 2 "reg_or_short_operand" "I,r,rI"))
9068                  (match_operand:SI 3 "reg_or_short_operand" "r,r,I")))
9069    (clobber (match_scratch:SI 4 "=&r,&r,&r"))]
9070   ""
9071   "@
9072    {ai|addic} %4,%1,%k2\;{aze|addze} %0,%3
9073    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
9074    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
9075   [(set_attr "length" "8,12,12")])
9076
9077 (define_insn ""
9078   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
9079         (compare:CC
9080          (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
9081                           (match_operand:SI 2 "reg_or_short_operand" "I,r"))
9082                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
9083          (const_int 0)))
9084    (clobber (match_scratch:SI 4 "=&r,&r"))]
9085   ""
9086   "@
9087    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
9088    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
9089   [(set_attr "type" "compare")
9090    (set_attr "length" "8,12")])
9091
9092 (define_insn ""
9093   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
9094         (compare:CC
9095          (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
9096                           (match_operand:SI 2 "reg_or_short_operand" "I,r"))
9097                   (match_operand:SI 3 "gpc_reg_operand" "r,r"))
9098          (const_int 0)))
9099    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
9100         (plus:SI (gtu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
9101    (clobber (match_scratch:SI 4 "=&r,&r"))]
9102   ""
9103   "@
9104    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
9105    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
9106   [(set_attr "type" "compare")
9107    (set_attr "length" "8,12")])
9108
9109 (define_insn ""
9110   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
9111         (neg:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
9112                         (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
9113   ""
9114   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
9115   [(set_attr "length" "8")])
9116 \f
9117 ;; Define both directions of branch and return.  If we need a reload
9118 ;; register, we'd rather use CR0 since it is much easier to copy a
9119 ;; register CC value to there.
9120
9121 (define_insn ""
9122   [(set (pc)
9123         (if_then_else (match_operator 1 "branch_comparison_operator"
9124                                       [(match_operand 2
9125                                                       "cc_reg_operand" "x,?y")
9126                                        (const_int 0)])
9127                       (label_ref (match_operand 0 "" ""))
9128                       (pc)))]
9129   ""
9130   "*
9131 {
9132   if (get_attr_length (insn) == 8)
9133     return \"%C1bc %t1,%j1,%l0\";
9134   else
9135     return \"%C1bc %T1,%j1,%$+8\;b %l0\";
9136
9137 }"
9138   [(set_attr "type" "branch")])
9139
9140 (define_insn ""
9141   [(set (pc)
9142         (if_then_else (match_operator 0 "branch_comparison_operator"
9143                                       [(match_operand 1
9144                                                       "cc_reg_operand" "x,?y")
9145                                        (const_int 0)])
9146                       (return)
9147                       (pc)))]
9148   "direct_return ()"
9149   "{%C0bcr|%C0bclr} %t0,%j0"
9150   [(set_attr "type" "branch")
9151    (set_attr "length" "8")])
9152
9153 (define_insn ""
9154   [(set (pc)
9155         (if_then_else (match_operator 1 "branch_comparison_operator"
9156                                       [(match_operand 2
9157                                                       "cc_reg_operand" "x,?y")
9158                                        (const_int 0)])
9159                       (pc)
9160                       (label_ref (match_operand 0 "" ""))))]
9161   ""
9162   "*
9163 {
9164   if (get_attr_length (insn) == 8)
9165     return \"%C1bc %T1,%j1,%l0\";
9166   else
9167     return \"%C1bc %t1,%j1,%$+8\;b %l0\";
9168 }"
9169   [(set_attr "type" "branch")])
9170
9171 (define_insn ""
9172   [(set (pc)
9173         (if_then_else (match_operator 0 "branch_comparison_operator"
9174                                       [(match_operand 1
9175                                                       "cc_reg_operand" "x,?y")
9176                                        (const_int 0)])
9177                       (pc)
9178                       (return)))]
9179   "direct_return ()"
9180   "{%C0bcr|%C0bclr} %T0,%j0"
9181   [(set_attr "type" "branch")
9182    (set_attr "length" "8")])
9183
9184 ;; Unconditional branch and return.
9185
9186 (define_insn "jump"
9187   [(set (pc)
9188         (label_ref (match_operand 0 "" "")))]
9189   ""
9190   "b %l0"
9191   [(set_attr "type" "branch")])
9192
9193 (define_insn "return"
9194   [(return)]
9195   "direct_return ()"
9196   "{br|blr}"
9197   [(set_attr "type" "jmpreg")])
9198
9199 (define_insn "indirect_jump"
9200   [(set (pc) (match_operand:SI 0 "register_operand" "c,l"))]
9201   ""
9202   "@
9203    bctr
9204    {br|blr}"
9205   [(set_attr "type" "jmpreg")])
9206
9207 (define_insn ""
9208   [(set (pc) (match_operand:DI 0 "register_operand" "c,l"))]
9209   "TARGET_POWERPC64"
9210   "@
9211    bctr
9212    {br|blr}"
9213   [(set_attr "type" "jmpreg")])
9214
9215 ;; Table jump for switch statements:
9216 (define_expand "tablejump"
9217   [(use (match_operand 0 "" ""))
9218    (use (label_ref (match_operand 1 "" "")))]
9219   ""
9220   "
9221 {
9222   if (TARGET_32BIT)
9223     emit_jump_insn (gen_tablejumpsi (operands[0], operands[1]));
9224   else
9225     emit_jump_insn (gen_tablejumpdi (operands[0], operands[1]));
9226   DONE;
9227 }")
9228
9229 (define_expand "tablejumpsi"
9230   [(set (match_dup 3)
9231         (plus:SI (match_operand:SI 0 "" "")
9232                  (match_dup 2)))
9233    (parallel [(set (pc) (match_dup 3))
9234               (use (label_ref (match_operand 1 "" "")))])]
9235   ""
9236   "
9237 { operands[0] = force_reg (SImode, operands[0]);
9238   operands[2] = force_reg (SImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
9239   operands[3] = gen_reg_rtx (SImode);
9240 }")
9241
9242 (define_expand "tablejumpdi"
9243   [(set (match_dup 3)
9244         (plus:DI (match_operand:DI 0 "" "")
9245                  (match_dup 2)))
9246    (parallel [(set (pc) (match_dup 3))
9247               (use (label_ref (match_operand 1 "" "")))])]
9248   ""
9249   "
9250 { operands[0] = force_reg (DImode, operands[0]);
9251   operands[2] = force_reg (DImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
9252   operands[3] = gen_reg_rtx (DImode);
9253 }")
9254
9255 (define_insn ""
9256   [(set (pc)
9257         (match_operand:SI 0 "register_operand" "c,l"))
9258    (use (label_ref (match_operand 1 "" "")))]
9259   ""
9260   "@
9261    bctr
9262    {br|blr}"
9263   [(set_attr "type" "jmpreg")])
9264
9265 (define_insn ""
9266   [(set (pc)
9267         (match_operand:DI 0 "register_operand" "c,l"))
9268    (use (label_ref (match_operand 1 "" "")))]
9269   "TARGET_POWERPC64"
9270   "@
9271    bctr
9272    {br|blr}"
9273   [(set_attr "type" "jmpreg")])
9274
9275 (define_insn "nop"
9276   [(const_int 0)]
9277   ""
9278   "{cror 0,0,0|nop}")
9279 \f
9280 ;; Define the subtract-one-and-jump insns, starting with the template
9281 ;; so loop.c knows what to generate.
9282
9283 (define_expand "decrement_and_branch_on_count"
9284   [(parallel [(set (pc) (if_then_else (ne (match_operand:SI 0 "register_operand" "")
9285                                           (const_int 1))
9286                                       (label_ref (match_operand 1 "" ""))
9287                                       (pc)))
9288               (set (match_dup 0)
9289                    (plus:SI (match_dup 0)
9290                             (const_int -1)))
9291               (clobber (match_scratch:CC 2 ""))
9292               (clobber (match_scratch:SI 3 ""))])]
9293   ""
9294   "")
9295
9296 ;; We need to be able to do this for any operand, including MEM, or we
9297 ;; will cause reload to blow up since we don't allow output reloads on
9298 ;; JUMP_INSNs.
9299 ;; In order that the length attribute is calculated correctly, the
9300 ;; label MUST be operand 0.
9301
9302 (define_insn ""
9303   [(set (pc)
9304         (if_then_else (ne (match_operand:SI 1 "register_operand" "c,*r,*r")
9305                           (const_int 1))
9306                       (label_ref (match_operand 0 "" ""))
9307                       (pc)))
9308    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9309         (plus:SI (match_dup 1)
9310                  (const_int -1)))
9311    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9312    (clobber (match_scratch:SI 4 "=X,X,r"))]
9313   ""
9314   "*
9315 {
9316   if (which_alternative != 0)
9317     return \"#\";
9318   else if (get_attr_length (insn) == 8)
9319     return \"{bdn|bdnz} %l0\";
9320   else
9321     return \"bdz %$+8\;b %l0\";
9322 }"
9323   [(set_attr "type" "branch")
9324    (set_attr "length" "*,12,16")])
9325
9326 (define_insn ""
9327   [(set (pc)
9328         (if_then_else (ne (match_operand:SI 1 "register_operand" "c,*r,*r")
9329                           (const_int 1))
9330                       (pc)
9331                       (label_ref (match_operand 0 "" ""))))
9332    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9333         (plus:SI (match_dup 1)
9334                  (const_int -1)))
9335    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9336    (clobber (match_scratch:SI 4 "=X,X,r"))]
9337   ""
9338   "*
9339 {
9340   if (which_alternative != 0)
9341     return \"#\";
9342   else if (get_attr_length (insn) == 8)
9343     return \"bdz %l0\";
9344   else
9345     return \"{bdn|bdnz} %$+8\;b %l0\";
9346 }"
9347   [(set_attr "type" "branch")
9348    (set_attr "length" "*,12,16")])
9349
9350 ;; Similar, but we can use GE since we have a REG_NONNEG.
9351 (define_insn ""
9352   [(set (pc)
9353         (if_then_else (ge (match_operand:SI 1 "register_operand" "c,*r,*r")
9354                           (const_int 0))
9355                       (label_ref (match_operand 0 "" ""))
9356                       (pc)))
9357    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9358         (plus:SI (match_dup 1)
9359                  (const_int -1)))
9360    (clobber (match_scratch:CC 3 "=X,&x,&X"))
9361    (clobber (match_scratch:SI 4 "=X,X,r"))]
9362   "find_reg_note (insn, REG_NONNEG, 0)"
9363   "*
9364 {
9365   if (which_alternative != 0)
9366     return \"#\";
9367   else if (get_attr_length (insn) == 8)
9368     return \"{bdn|bdnz} %l0\";
9369   else
9370     return \"bdz %$+8\;b %l0\";
9371 }"
9372   [(set_attr "type" "branch")
9373    (set_attr "length" "*,12,16")])
9374
9375 (define_insn ""
9376   [(set (pc)
9377         (if_then_else (ge (match_operand:SI 1 "register_operand" "c,*r,*r")
9378                           (const_int 0))
9379                       (pc)
9380                       (label_ref (match_operand 0 "" ""))))
9381    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9382         (plus:SI (match_dup 1)
9383                  (const_int -1)))
9384    (clobber (match_scratch:CC 3 "=X,&x,&X"))
9385    (clobber (match_scratch:SI 4 "=X,X,r"))]
9386   "find_reg_note (insn, REG_NONNEG, 0)"
9387   "*
9388 {
9389   if (which_alternative != 0)
9390     return \"#\";
9391   else if (get_attr_length (insn) == 8)
9392     return \"bdz %l0\";
9393   else
9394     return \"{bdn|bdnz} %$+8\;b %l0\";
9395 }"
9396   [(set_attr "type" "branch")
9397    (set_attr "length" "*,12,16")])
9398
9399 (define_insn ""
9400   [(set (pc)
9401         (if_then_else (eq (match_operand:SI 1 "register_operand" "c,*r,*r")
9402                           (const_int 1))
9403                       (label_ref (match_operand 0 "" ""))
9404                       (pc)))
9405    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9406         (plus:SI (match_dup 1)
9407                  (const_int -1)))
9408    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9409    (clobber (match_scratch:SI 4 "=X,X,r"))]
9410   ""
9411   "*
9412 {
9413   if (which_alternative != 0)
9414     return \"#\";
9415   else if (get_attr_length (insn) == 8)
9416     return \"bdz %l0\";
9417   else
9418     return \"{bdn|bdnz} %$+8\;b %l0\";
9419 }"
9420   [(set_attr "type" "branch")
9421    (set_attr "length" "*,12,16")])
9422
9423 (define_insn ""
9424   [(set (pc)
9425         (if_then_else (eq (match_operand:SI 1 "register_operand" "c,*r,*r")
9426                           (const_int 1))
9427                       (pc)
9428                       (label_ref (match_operand 0 "" ""))))
9429    (set (match_operand:SI 2 "register_operand" "=1,*r,m*q*c*l")
9430         (plus:SI (match_dup 1)
9431                  (const_int -1)))
9432    (clobber (match_scratch:CC 3 "=X,&x,&x"))
9433    (clobber (match_scratch:SI 4 "=X,X,r"))]
9434   ""
9435   "*
9436 {
9437   if (which_alternative != 0)
9438     return \"#\";
9439   else if (get_attr_length (insn) == 8)
9440     return \"{bdn|bdnz} %l0\";
9441   else
9442     return \"bdz %$+8\;b %l0\";
9443 }"
9444   [(set_attr "type" "branch")
9445    (set_attr "length" "*,12,16")])
9446
9447 (define_split
9448   [(set (pc)
9449         (if_then_else (match_operator 2 "comparison_operator"
9450                                       [(match_operand:SI 1 "gpc_reg_operand" "")
9451                                        (const_int 1)])
9452                       (match_operand 5 "" "")
9453                       (match_operand 6 "" "")))
9454    (set (match_operand:SI 0 "gpc_reg_operand" "")
9455         (plus:SI (match_dup 1)
9456                  (const_int -1)))
9457    (clobber (match_scratch:CC 3 ""))
9458    (clobber (match_scratch:SI 4 ""))]
9459   "reload_completed"
9460   [(parallel [(set (match_dup 3)
9461                    (compare:CC (plus:SI (match_dup 1)
9462                                         (const_int -1))
9463                                (const_int 0)))
9464               (set (match_dup 0)
9465                    (plus:SI (match_dup 1)
9466                             (const_int -1)))])
9467    (set (pc) (if_then_else (match_dup 7)
9468                            (match_dup 5)
9469                            (match_dup 6)))]
9470   "
9471 { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
9472                          const0_rtx); }")
9473
9474 (define_split
9475   [(set (pc)
9476         (if_then_else (match_operator 2 "comparison_operator"
9477                                       [(match_operand:SI 1 "gpc_reg_operand" "")
9478                                        (const_int 1)])
9479                       (match_operand 5 "" "")
9480                       (match_operand 6 "" "")))
9481    (set (match_operand:SI 0 "general_operand" "")
9482         (plus:SI (match_dup 1) (const_int -1)))
9483    (clobber (match_scratch:CC 3 ""))
9484    (clobber (match_scratch:SI 4 ""))]
9485   "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
9486   [(parallel [(set (match_dup 3)
9487                    (compare:CC (plus:SI (match_dup 1)
9488                                         (const_int -1))
9489                                (const_int 0)))
9490               (set (match_dup 4)
9491                    (plus:SI (match_dup 1)
9492                             (const_int -1)))])
9493    (set (match_dup 0)
9494         (match_dup 4))
9495    (set (pc) (if_then_else (match_dup 7)
9496                            (match_dup 5)
9497                            (match_dup 6)))]
9498   "
9499 { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
9500                          const0_rtx); }")