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