gcc/config/rs6000/rs6000.md

   1 ;; Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
   2 ;; Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3 ;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   4 ;; Free Software Foundation, Inc.
   5 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   6
   7 ;; This file is part of GCC.
   8
   9 ;; GCC is free software; you can redistribute it and/or modify it
  10 ;; under the terms of the GNU General Public License as published
  11 ;; by the Free Software Foundation; either version 3, or (at your
  12 ;; option) any later version.
  13
  14 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
  15 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17 ;; License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GCC; see the file COPYING3.  If not see
  21 ;; <http://www.gnu.org/licenses/>.
  22
  23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  24
  25 ;;
  26 ;; REGNOS
  27 ;;
  28
  29 (define_constants
  30   [(MQ_REGNO                    64)
  31    (LR_REGNO                    65)
  32    (CTR_REGNO                   66)
  33    (CR0_REGNO                   68)
  34    (CR1_REGNO                   69)
  35    (CR2_REGNO                   70)
  36    (CR3_REGNO                   71)
  37    (CR4_REGNO                   72)
  38    (CR5_REGNO                   73)
  39    (CR6_REGNO                   74)
  40    (CR7_REGNO                   75)
  41    (MAX_CR_REGNO                75)
  42    (XER_REGNO                   76)
  43    (FIRST_ALTIVEC_REGNO         77)
  44    (LAST_ALTIVEC_REGNO          108)
  45    (VRSAVE_REGNO                109)
  46    (VSCR_REGNO                  110)
  47    (SPE_ACC_REGNO               111)
  48    (SPEFSCR_REGNO               112)
  49    (SFP_REGNO                   113)
  50   ])
  51
  52 ;;
  53 ;; UNSPEC usage
  54 ;;
  55
  56 (define_constants
  57   [(UNSPEC_FRSP                 0)      ; frsp for POWER machines
  58    (UNSPEC_TIE                  5)      ; tie stack contents and stack pointer
  59    (UNSPEC_TOCPTR               6)      ; address of a word pointing to the TOC
  60    (UNSPEC_TOC                  7)      ; address of the TOC (more-or-less)
  61    (UNSPEC_MOVSI_GOT            8)
  62    (UNSPEC_MV_CR_OV             9)      ; move_from_CR_ov_bit
  63    (UNSPEC_FCTIWZ               10)
  64    (UNSPEC_FRIM                 11)
  65    (UNSPEC_FRIN                 12)
  66    (UNSPEC_FRIP                 13)
  67    (UNSPEC_FRIZ                 14)
  68    (UNSPEC_LD_MPIC              15)     ; load_macho_picbase
  69    (UNSPEC_MPIC_CORRECT         16)     ; macho_correct_pic
  70    (UNSPEC_TLSGD                17)
  71    (UNSPEC_TLSLD                18)
  72    (UNSPEC_MOVESI_FROM_CR       19)
  73    (UNSPEC_MOVESI_TO_CR         20)
  74    (UNSPEC_TLSDTPREL            21)
  75    (UNSPEC_TLSDTPRELHA          22)
  76    (UNSPEC_TLSDTPRELLO          23)
  77    (UNSPEC_TLSGOTDTPREL         24)
  78    (UNSPEC_TLSTPREL             25)
  79    (UNSPEC_TLSTPRELHA           26)
  80    (UNSPEC_TLSTPRELLO           27)
  81    (UNSPEC_TLSGOTTPREL          28)
  82    (UNSPEC_TLSTLS               29)
  83    (UNSPEC_FIX_TRUNC_TF         30)     ; fadd, rounding towards zero
  84    (UNSPEC_MV_CR_GT             31)     ; move_from_CR_gt_bit
  85    (UNSPEC_STFIWX               32)
  86    (UNSPEC_POPCNTB              33)
  87    (UNSPEC_FRES                 34)
  88    (UNSPEC_SP_SET               35)
  89    (UNSPEC_SP_TEST              36)
  90    (UNSPEC_SYNC                 37)
  91    (UNSPEC_LWSYNC               38)
  92    (UNSPEC_ISYNC                39)
  93    (UNSPEC_SYNC_OP              40)
  94    (UNSPEC_ATOMIC               41)
  95    (UNSPEC_CMPXCHG              42)
  96    (UNSPEC_XCHG                 43)
  97    (UNSPEC_AND                  44)
  98    (UNSPEC_DLMZB                45)
  99    (UNSPEC_DLMZB_CR             46)
 100    (UNSPEC_DLMZB_STRLEN         47)
 101   ])
 102
 103 ;;
 104 ;; UNSPEC_VOLATILE usage
 105 ;;
 106
 107 (define_constants
 108   [(UNSPECV_BLOCK               0)
 109    (UNSPECV_LL                  1)      ; load-locked
 110    (UNSPECV_SC                  2)      ; store-conditional
 111    (UNSPECV_EH_RR               9)      ; eh_reg_restore
 112   ])
 113 \f
 114 ;; Define an insn type attribute.  This is used in function unit delay
 115 ;; computations.
 116 (define_attr "type" "integer,two,three,load,load_ext,load_ext_u,load_ext_ux,load_ux,load_u,store,store_ux,store_u,fpload,fpload_ux,fpload_u,fpstore,fpstore_ux,fpstore_u,vecload,vecstore,imul,imul2,imul3,lmul,idiv,ldiv,insert_word,branch,cmp,fast_compare,compare,var_delayed_compare,delayed_compare,imul_compare,lmul_compare,fpcompare,cr_logical,delayed_cr,mfcr,mfcrf,mtcr,mfjmpr,mtjmpr,fp,fpsimple,dmul,sdiv,ddiv,ssqrt,dsqrt,jmpreg,brinc,vecsimple,veccomplex,vecdiv,veccmp,veccmpsimple,vecperm,vecfloat,vecfdiv,isync,sync,load_l,store_c,shift,trap,insert_dword,var_shift_rotate,cntlz,exts,mffgpr,mftgpr"
 117   (const_string "integer"))
 118
 119 ;; Length (in bytes).
 120 ; '(pc)' in the following doesn't include the instruction itself; it is
 121 ; calculated as if the instruction had zero size.
 122 (define_attr "length" ""
 123   (if_then_else (eq_attr "type" "branch")
 124                 (if_then_else (and (ge (minus (match_dup 0) (pc))
 125                                        (const_int -32768))
 126                                    (lt (minus (match_dup 0) (pc))
 127                                        (const_int 32764)))
 128                               (const_int 4)
 129                               (const_int 8))
 130                 (const_int 4)))
 131
 132 ;; Processor type -- this attribute must exactly match the processor_type
 133 ;; enumeration in rs6000.h.
 134
 135 (define_attr "cpu" "rios1,rios2,rs64a,mpccore,ppc403,ppc405,ppc440,ppc601,ppc603,ppc604,ppc604e,ppc620,ppc630,ppc750,ppc7400,ppc7450,ppc8540,power4,power5,power6,cell"
 136   (const (symbol_ref "rs6000_cpu_attr")))
 137
 138
 139 ;; If this instruction is microcoded on the CELL processor
 140 ; The default for load and stores is conditional
 141 ; The default for load extended and the recorded instructions is always microcoded
 142 (define_attr "cell_micro" "not,conditional,always"
 143   (if_then_else (ior (ior (eq_attr "type" "load")
 144                           (eq_attr "type" "store"))
 145                      (ior (eq_attr "type" "fpload")
 146                           (eq_attr "type" "fpstore")))
 147                 (const_string "conditional")
 148                 (if_then_else (ior (eq_attr "type" "load_ext")
 149                                    (ior (eq_attr "type" "compare")
 150                                         (eq_attr "type" "delayed_compare")))
 151                               (const_string "always")
 152                               (const_string "not"))))
 153
 154
 155 (automata_option "ndfa")
 156
 157 (include "rios1.md")
 158 (include "rios2.md")
 159 (include "rs64.md")
 160 (include "mpc.md")
 161 (include "40x.md")
 162 (include "440.md")
 163 (include "603.md")
 164 (include "6xx.md")
 165 (include "7xx.md")
 166 (include "7450.md")
 167 (include "8540.md")
 168 (include "power4.md")
 169 (include "power5.md")
 170 (include "power6.md")
 171 (include "cell.md")
 172
 173 (include "predicates.md")
 174 (include "constraints.md")
 175
 176 (include "darwin.md")
 177
 178 \f
 179 ;; Mode iterators
 180
 181 ; This mode iterator allows :GPR to be used to indicate the allowable size
 182 ; of whole values in GPRs.
 183 (define_mode_iterator GPR [SI (DI "TARGET_POWERPC64")])
 184
 185 ; Any supported integer mode.
 186 (define_mode_iterator INT [QI HI SI DI TI])
 187
 188 ; Any supported integer mode that fits in one register.
 189 (define_mode_iterator INT1 [QI HI SI (DI "TARGET_POWERPC64")])
 190
 191 ; extend modes for DImode
 192 (define_mode_iterator QHSI [QI HI SI])
 193
 194 ; SImode or DImode, even if DImode doesn't fit in GPRs.
 195 (define_mode_iterator SDI [SI DI])
 196
 197 ; The size of a pointer.  Also, the size of the value that a record-condition
 198 ; (one with a '.') will compare.
 199 (define_mode_iterator P [(SI "TARGET_32BIT") (DI "TARGET_64BIT")])
 200
 201 ; Any hardware-supported floating-point mode
 202 (define_mode_iterator FP [(SF "TARGET_HARD_FLOAT")
 203   (DF "TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)")
 204   (TF "!TARGET_IEEEQUAD
 205    && TARGET_HARD_FLOAT
 206    && (TARGET_FPRS || TARGET_E500_DOUBLE)
 207    && TARGET_LONG_DOUBLE_128")
 208   (DD "TARGET_DFP")
 209   (TD "TARGET_DFP")])
 210
 211 ; Various instructions that come in SI and DI forms.
 212 ; A generic w/d attribute, for things like cmpw/cmpd.
 213 (define_mode_attr wd [(QI "b") (HI "h") (SI "w") (DI "d")])
 214
 215 ; DImode bits
 216 (define_mode_attr dbits [(QI "56") (HI "48") (SI "32")])
 217
 218 \f
 219 ;; Start with fixed-point load and store insns.  Here we put only the more
 220 ;; complex forms.  Basic data transfer is done later.
 221
 222 (define_expand "zero_extend<mode>di2"
 223   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 224         (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "")))]
 225   "TARGET_POWERPC64"
 226   "")
 227
 228 (define_insn "*zero_extend<mode>di2_internal1"
 229   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 230         (zero_extend:DI (match_operand:QHSI 1 "reg_or_mem_operand" "m,r")))]
 231   "TARGET_POWERPC64"
 232   "@
 233    l<wd>z%U1%X1 %0,%1
 234    rldicl %0,%1,0,<dbits>"
 235   [(set_attr "type" "load,*")])
 236
 237 (define_insn "*zero_extend<mode>di2_internal2"
 238   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 239         (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
 240                     (const_int 0)))
 241    (clobber (match_scratch:DI 2 "=r,r"))]
 242   "TARGET_64BIT"
 243   "@
 244    rldicl. %2,%1,0,<dbits>
 245    #"
 246   [(set_attr "type" "compare")
 247    (set_attr "length" "4,8")])
 248
 249 (define_split
 250   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 251         (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
 252                     (const_int 0)))
 253    (clobber (match_scratch:DI 2 ""))]
 254   "TARGET_POWERPC64 && reload_completed"
 255   [(set (match_dup 2)
 256         (zero_extend:DI (match_dup 1)))
 257    (set (match_dup 0)
 258         (compare:CC (match_dup 2)
 259                     (const_int 0)))]
 260   "")
 261
 262 (define_insn "*zero_extend<mode>di2_internal3"
 263   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 264         (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" "r,r"))
 265                     (const_int 0)))
 266    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 267         (zero_extend:DI (match_dup 1)))]
 268   "TARGET_64BIT"
 269   "@
 270    rldicl. %0,%1,0,<dbits>
 271    #"
 272   [(set_attr "type" "compare")
 273    (set_attr "length" "4,8")])
 274
 275 (define_split
 276   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 277         (compare:CC (zero_extend:DI (match_operand:QHSI 1 "gpc_reg_operand" ""))
 278                     (const_int 0)))
 279    (set (match_operand:DI 0 "gpc_reg_operand" "")
 280         (zero_extend:DI (match_dup 1)))]
 281   "TARGET_POWERPC64 && reload_completed"
 282   [(set (match_dup 0)
 283         (zero_extend:DI (match_dup 1)))
 284    (set (match_dup 2)
 285         (compare:CC (match_dup 0)
 286                     (const_int 0)))]
 287   "")
 288
 289 (define_insn "extendqidi2"
 290   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
 291         (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 292   "TARGET_POWERPC64"
 293   "extsb %0,%1"
 294   [(set_attr "type" "exts")])
 295
 296 (define_insn ""
 297   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 298         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 299                     (const_int 0)))
 300    (clobber (match_scratch:DI 2 "=r,r"))]
 301   "TARGET_64BIT"
 302   "@
 303    extsb. %2,%1
 304    #"
 305   [(set_attr "type" "compare")
 306    (set_attr "length" "4,8")])
 307
 308 (define_split
 309   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 310         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
 311                     (const_int 0)))
 312    (clobber (match_scratch:DI 2 ""))]
 313   "TARGET_POWERPC64 && reload_completed"
 314   [(set (match_dup 2)
 315         (sign_extend:DI (match_dup 1)))
 316    (set (match_dup 0)
 317         (compare:CC (match_dup 2)
 318                     (const_int 0)))]
 319   "")
 320
 321 (define_insn ""
 322   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 323         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 324                     (const_int 0)))
 325    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 326         (sign_extend:DI (match_dup 1)))]
 327   "TARGET_64BIT"
 328   "@
 329    extsb. %0,%1
 330    #"
 331   [(set_attr "type" "compare")
 332    (set_attr "length" "4,8")])
 333
 334 (define_split
 335   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 336         (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" ""))
 337                     (const_int 0)))
 338    (set (match_operand:DI 0 "gpc_reg_operand" "")
 339         (sign_extend:DI (match_dup 1)))]
 340   "TARGET_POWERPC64 && reload_completed"
 341   [(set (match_dup 0)
 342         (sign_extend:DI (match_dup 1)))
 343    (set (match_dup 2)
 344         (compare:CC (match_dup 0)
 345                     (const_int 0)))]
 346   "")
 347
 348 (define_expand "extendhidi2"
 349   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 350         (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
 351   "TARGET_POWERPC64"
 352   "")
 353
 354 (define_insn ""
 355   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 356         (sign_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 357   "TARGET_POWERPC64"
 358   "@
 359    lha%U1%X1 %0,%1
 360    extsh %0,%1"
 361   [(set_attr "type" "load_ext,exts")])
 362
 363 (define_insn ""
 364   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 365         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 366                     (const_int 0)))
 367    (clobber (match_scratch:DI 2 "=r,r"))]
 368   "TARGET_64BIT"
 369   "@
 370    extsh. %2,%1
 371    #"
 372   [(set_attr "type" "compare")
 373    (set_attr "length" "4,8")])
 374
 375 (define_split
 376   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 377         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
 378                     (const_int 0)))
 379    (clobber (match_scratch:DI 2 ""))]
 380   "TARGET_POWERPC64 && reload_completed"
 381   [(set (match_dup 2)
 382         (sign_extend:DI (match_dup 1)))
 383    (set (match_dup 0)
 384         (compare:CC (match_dup 2)
 385                     (const_int 0)))]
 386   "")
 387
 388 (define_insn ""
 389   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 390         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 391                     (const_int 0)))
 392    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 393         (sign_extend:DI (match_dup 1)))]
 394   "TARGET_64BIT"
 395   "@
 396    extsh. %0,%1
 397    #"
 398   [(set_attr "type" "compare")
 399    (set_attr "length" "4,8")])
 400
 401 (define_split
 402   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 403         (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" ""))
 404                     (const_int 0)))
 405    (set (match_operand:DI 0 "gpc_reg_operand" "")
 406         (sign_extend:DI (match_dup 1)))]
 407   "TARGET_POWERPC64 && reload_completed"
 408   [(set (match_dup 0)
 409         (sign_extend:DI (match_dup 1)))
 410    (set (match_dup 2)
 411         (compare:CC (match_dup 0)
 412                     (const_int 0)))]
 413   "")
 414
 415 (define_expand "extendsidi2"
 416   [(set (match_operand:DI 0 "gpc_reg_operand" "")
 417         (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
 418   "TARGET_POWERPC64"
 419   "")
 420
 421 (define_insn ""
 422   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 423         (sign_extend:DI (match_operand:SI 1 "lwa_operand" "m,r")))]
 424   "TARGET_POWERPC64"
 425   "@
 426    lwa%U1%X1 %0,%1
 427    extsw %0,%1"
 428   [(set_attr "type" "load_ext,exts")])
 429
 430 (define_insn ""
 431   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 432         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
 433                     (const_int 0)))
 434    (clobber (match_scratch:DI 2 "=r,r"))]
 435   "TARGET_64BIT"
 436   "@
 437    extsw. %2,%1
 438    #"
 439   [(set_attr "type" "compare")
 440    (set_attr "length" "4,8")])
 441
 442 (define_split
 443   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 444         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
 445                     (const_int 0)))
 446    (clobber (match_scratch:DI 2 ""))]
 447   "TARGET_POWERPC64 && reload_completed"
 448   [(set (match_dup 2)
 449         (sign_extend:DI (match_dup 1)))
 450    (set (match_dup 0)
 451         (compare:CC (match_dup 2)
 452                     (const_int 0)))]
 453   "")
 454
 455 (define_insn ""
 456   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 457         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
 458                     (const_int 0)))
 459    (set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
 460         (sign_extend:DI (match_dup 1)))]
 461   "TARGET_64BIT"
 462   "@
 463    extsw. %0,%1
 464    #"
 465   [(set_attr "type" "compare")
 466    (set_attr "length" "4,8")])
 467
 468 (define_split
 469   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 470         (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
 471                     (const_int 0)))
 472    (set (match_operand:DI 0 "gpc_reg_operand" "")
 473         (sign_extend:DI (match_dup 1)))]
 474   "TARGET_POWERPC64 && reload_completed"
 475   [(set (match_dup 0)
 476         (sign_extend:DI (match_dup 1)))
 477    (set (match_dup 2)
 478         (compare:CC (match_dup 0)
 479                     (const_int 0)))]
 480   "")
 481
 482 (define_expand "zero_extendqisi2"
 483   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 484         (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
 485   ""
 486   "")
 487
 488 (define_insn ""
 489   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 490         (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
 491   ""
 492   "@
 493    lbz%U1%X1 %0,%1
 494    {rlinm|rlwinm} %0,%1,0,0xff"
 495   [(set_attr "type" "load,*")])
 496
 497 (define_insn ""
 498   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 499         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 500                     (const_int 0)))
 501    (clobber (match_scratch:SI 2 "=r,r"))]
 502   ""
 503   "@
 504    {andil.|andi.} %2,%1,0xff
 505    #"
 506   [(set_attr "type" "compare")
 507    (set_attr "length" "4,8")])
 508
 509 (define_split
 510   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 511         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
 512                     (const_int 0)))
 513    (clobber (match_scratch:SI 2 ""))]
 514   "reload_completed"
 515   [(set (match_dup 2)
 516         (zero_extend:SI (match_dup 1)))
 517    (set (match_dup 0)
 518         (compare:CC (match_dup 2)
 519                     (const_int 0)))]
 520   "")
 521
 522 (define_insn ""
 523   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 524         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 525                     (const_int 0)))
 526    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 527         (zero_extend:SI (match_dup 1)))]
 528   ""
 529   "@
 530    {andil.|andi.} %0,%1,0xff
 531    #"
 532   [(set_attr "type" "compare")
 533    (set_attr "length" "4,8")])
 534
 535 (define_split
 536   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 537         (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
 538                     (const_int 0)))
 539    (set (match_operand:SI 0 "gpc_reg_operand" "")
 540         (zero_extend:SI (match_dup 1)))]
 541   "reload_completed"
 542   [(set (match_dup 0)
 543         (zero_extend:SI (match_dup 1)))
 544    (set (match_dup 2)
 545         (compare:CC (match_dup 0)
 546                     (const_int 0)))]
 547   "")
 548
 549 (define_expand "extendqisi2"
 550   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
 551    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
 552   ""
 553   "
 554 {
 555   if (TARGET_POWERPC)
 556     emit_insn (gen_extendqisi2_ppc (operands[0], operands[1]));
 557   else if (TARGET_POWER)
 558     emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
 559   else
 560     emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
 561   DONE;
 562 }")
 563
 564 (define_insn "extendqisi2_ppc"
 565   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 566         (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 567   "TARGET_POWERPC"
 568   "extsb %0,%1"
 569   [(set_attr "type" "exts")])
 570
 571 (define_insn ""
 572   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 573         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 574                     (const_int 0)))
 575    (clobber (match_scratch:SI 2 "=r,r"))]
 576   "TARGET_POWERPC"
 577   "@
 578    extsb. %2,%1
 579    #"
 580   [(set_attr "type" "compare")
 581    (set_attr "length" "4,8")])
 582
 583 (define_split
 584   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 585         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
 586                     (const_int 0)))
 587    (clobber (match_scratch:SI 2 ""))]
 588   "TARGET_POWERPC && reload_completed"
 589   [(set (match_dup 2)
 590         (sign_extend:SI (match_dup 1)))
 591    (set (match_dup 0)
 592         (compare:CC (match_dup 2)
 593                     (const_int 0)))]
 594   "")
 595
 596 (define_insn ""
 597   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 598         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 599                     (const_int 0)))
 600    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 601         (sign_extend:SI (match_dup 1)))]
 602   "TARGET_POWERPC"
 603   "@
 604    extsb. %0,%1
 605    #"
 606   [(set_attr "type" "compare")
 607    (set_attr "length" "4,8")])
 608
 609 (define_split
 610   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 611         (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" ""))
 612                     (const_int 0)))
 613    (set (match_operand:SI 0 "gpc_reg_operand" "")
 614         (sign_extend:SI (match_dup 1)))]
 615   "TARGET_POWERPC && reload_completed"
 616   [(set (match_dup 0)
 617         (sign_extend:SI (match_dup 1)))
 618    (set (match_dup 2)
 619         (compare:CC (match_dup 0)
 620                     (const_int 0)))]
 621   "")
 622
 623 (define_expand "extendqisi2_power"
 624   [(parallel [(set (match_dup 2)
 625                    (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 626                               (const_int 24)))
 627               (clobber (scratch:SI))])
 628    (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
 629                    (ashiftrt:SI (match_dup 2)
 630                                 (const_int 24)))
 631               (clobber (scratch:SI))])]
 632   "TARGET_POWER"
 633   "
 634 { operands[1] = gen_lowpart (SImode, operands[1]);
 635   operands[2] = gen_reg_rtx (SImode); }")
 636
 637 (define_expand "extendqisi2_no_power"
 638   [(set (match_dup 2)
 639         (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 640                    (const_int 24)))
 641    (set (match_operand:SI 0 "gpc_reg_operand" "")
 642         (ashiftrt:SI (match_dup 2)
 643                      (const_int 24)))]
 644   "! TARGET_POWER && ! TARGET_POWERPC"
 645   "
 646 { operands[1] = gen_lowpart (SImode, operands[1]);
 647   operands[2] = gen_reg_rtx (SImode); }")
 648
 649 (define_expand "zero_extendqihi2"
 650   [(set (match_operand:HI 0 "gpc_reg_operand" "")
 651         (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
 652   ""
 653   "")
 654
 655 (define_insn ""
 656   [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
 657         (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
 658   ""
 659   "@
 660    lbz%U1%X1 %0,%1
 661    {rlinm|rlwinm} %0,%1,0,0xff"
 662   [(set_attr "type" "load,*")])
 663
 664 (define_insn ""
 665   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 666         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 667                     (const_int 0)))
 668    (clobber (match_scratch:HI 2 "=r,r"))]
 669   ""
 670   "@
 671    {andil.|andi.} %2,%1,0xff
 672    #"
 673   [(set_attr "type" "compare")
 674    (set_attr "length" "4,8")])
 675
 676 (define_split
 677   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 678         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
 679                     (const_int 0)))
 680    (clobber (match_scratch:HI 2 ""))]
 681   "reload_completed"
 682   [(set (match_dup 2)
 683         (zero_extend:HI (match_dup 1)))
 684    (set (match_dup 0)
 685         (compare:CC (match_dup 2)
 686                     (const_int 0)))]
 687   "")
 688
 689 (define_insn ""
 690   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 691         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 692                     (const_int 0)))
 693    (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
 694         (zero_extend:HI (match_dup 1)))]
 695   ""
 696   "@
 697    {andil.|andi.} %0,%1,0xff
 698    #"
 699   [(set_attr "type" "compare")
 700    (set_attr "length" "4,8")])
 701
 702 (define_split
 703   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 704         (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
 705                     (const_int 0)))
 706    (set (match_operand:HI 0 "gpc_reg_operand" "")
 707         (zero_extend:HI (match_dup 1)))]
 708   "reload_completed"
 709   [(set (match_dup 0)
 710         (zero_extend:HI (match_dup 1)))
 711    (set (match_dup 2)
 712         (compare:CC (match_dup 0)
 713                     (const_int 0)))]
 714   "")
 715
 716 (define_expand "extendqihi2"
 717   [(use (match_operand:HI 0 "gpc_reg_operand" ""))
 718    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
 719   ""
 720   "
 721 {
 722   if (TARGET_POWERPC)
 723     emit_insn (gen_extendqihi2_ppc (operands[0], operands[1]));
 724   else if (TARGET_POWER)
 725     emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
 726   else
 727     emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
 728   DONE;
 729 }")
 730
 731 (define_insn "extendqihi2_ppc"
 732   [(set (match_operand:HI 0 "gpc_reg_operand" "=r")
 733         (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r")))]
 734   "TARGET_POWERPC"
 735   "extsb %0,%1"
 736   [(set_attr "type" "exts")])
 737
 738 (define_insn ""
 739   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 740         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 741                     (const_int 0)))
 742    (clobber (match_scratch:HI 2 "=r,r"))]
 743   "TARGET_POWERPC"
 744   "@
 745    extsb. %2,%1
 746    #"
 747   [(set_attr "type" "compare")
 748    (set_attr "length" "4,8")])
 749
 750 (define_split
 751   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 752         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
 753                     (const_int 0)))
 754    (clobber (match_scratch:HI 2 ""))]
 755   "TARGET_POWERPC && reload_completed"
 756   [(set (match_dup 2)
 757         (sign_extend:HI (match_dup 1)))
 758    (set (match_dup 0)
 759         (compare:CC (match_dup 2)
 760                     (const_int 0)))]
 761   "")
 762
 763 (define_insn ""
 764   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 765         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r,r"))
 766                     (const_int 0)))
 767    (set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
 768         (sign_extend:HI (match_dup 1)))]
 769   "TARGET_POWERPC"
 770   "@
 771    extsb. %0,%1
 772    #"
 773   [(set_attr "type" "compare")
 774    (set_attr "length" "4,8")])
 775
 776 (define_split
 777   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 778         (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" ""))
 779                     (const_int 0)))
 780    (set (match_operand:HI 0 "gpc_reg_operand" "")
 781         (sign_extend:HI (match_dup 1)))]
 782   "TARGET_POWERPC && reload_completed"
 783   [(set (match_dup 0)
 784         (sign_extend:HI (match_dup 1)))
 785    (set (match_dup 2)
 786         (compare:CC (match_dup 0)
 787                     (const_int 0)))]
 788   "")
 789
 790 (define_expand "extendqihi2_power"
 791   [(parallel [(set (match_dup 2)
 792                    (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 793                               (const_int 24)))
 794               (clobber (scratch:SI))])
 795    (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
 796                    (ashiftrt:SI (match_dup 2)
 797                                 (const_int 24)))
 798               (clobber (scratch:SI))])]
 799   "TARGET_POWER"
 800   "
 801 { operands[0] = gen_lowpart (SImode, operands[0]);
 802   operands[1] = gen_lowpart (SImode, operands[1]);
 803   operands[2] = gen_reg_rtx (SImode); }")
 804
 805 (define_expand "extendqihi2_no_power"
 806   [(set (match_dup 2)
 807         (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
 808                    (const_int 24)))
 809    (set (match_operand:HI 0 "gpc_reg_operand" "")
 810         (ashiftrt:SI (match_dup 2)
 811                      (const_int 24)))]
 812   "! TARGET_POWER && ! TARGET_POWERPC"
 813   "
 814 { operands[0] = gen_lowpart (SImode, operands[0]);
 815   operands[1] = gen_lowpart (SImode, operands[1]);
 816   operands[2] = gen_reg_rtx (SImode); }")
 817
 818 (define_expand "zero_extendhisi2"
 819   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 820         (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
 821   ""
 822   "")
 823
 824 (define_insn ""
 825   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 826         (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 827   ""
 828   "@
 829    lhz%U1%X1 %0,%1
 830    {rlinm|rlwinm} %0,%1,0,0xffff"
 831   [(set_attr "type" "load,*")])
 832
 833 (define_insn ""
 834   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 835         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 836                     (const_int 0)))
 837    (clobber (match_scratch:SI 2 "=r,r"))]
 838   ""
 839   "@
 840    {andil.|andi.} %2,%1,0xffff
 841    #"
 842   [(set_attr "type" "compare")
 843    (set_attr "length" "4,8")])
 844
 845 (define_split
 846   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 847         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
 848                     (const_int 0)))
 849    (clobber (match_scratch:SI 2 ""))]
 850   "reload_completed"
 851   [(set (match_dup 2)
 852         (zero_extend:SI (match_dup 1)))
 853    (set (match_dup 0)
 854         (compare:CC (match_dup 2)
 855                     (const_int 0)))]
 856   "")
 857
 858 (define_insn ""
 859   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 860         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 861                     (const_int 0)))
 862    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 863         (zero_extend:SI (match_dup 1)))]
 864   ""
 865   "@
 866    {andil.|andi.} %0,%1,0xffff
 867    #"
 868   [(set_attr "type" "compare")
 869    (set_attr "length" "4,8")])
 870
 871 (define_split
 872   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
 873         (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
 874                     (const_int 0)))
 875    (set (match_operand:SI 0 "gpc_reg_operand" "")
 876         (zero_extend:SI (match_dup 1)))]
 877   "reload_completed"
 878   [(set (match_dup 0)
 879         (zero_extend:SI (match_dup 1)))
 880    (set (match_dup 2)
 881         (compare:CC (match_dup 0)
 882                     (const_int 0)))]
 883   "")
 884
 885 (define_expand "extendhisi2"
 886   [(set (match_operand:SI 0 "gpc_reg_operand" "")
 887         (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
 888   ""
 889   "")
 890
 891 (define_insn ""
 892   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 893         (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
 894   ""
 895   "@
 896    lha%U1%X1 %0,%1
 897    {exts|extsh} %0,%1"
 898   [(set_attr "type" "load_ext,exts")])
 899
 900 (define_insn ""
 901   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
 902         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 903                     (const_int 0)))
 904    (clobber (match_scratch:SI 2 "=r,r"))]
 905   ""
 906   "@
 907    {exts.|extsh.} %2,%1
 908    #"
 909   [(set_attr "type" "compare")
 910    (set_attr "length" "4,8")])
 911
 912 (define_split
 913   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
 914         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
 915                     (const_int 0)))
 916    (clobber (match_scratch:SI 2 ""))]
 917   "reload_completed"
 918   [(set (match_dup 2)
 919         (sign_extend:SI (match_dup 1)))
 920    (set (match_dup 0)
 921         (compare:CC (match_dup 2)
 922                     (const_int 0)))]
 923   "")
 924
 925 (define_insn ""
 926   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
 927         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r,r"))
 928                     (const_int 0)))
 929    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
 930         (sign_extend:SI (match_dup 1)))]
 931   ""
 932   "@
 933    {exts.|extsh.} %0,%1
 934    #"
 935   [(set_attr "type" "compare")
 936    (set_attr "length" "4,8")])
 937 \f
 938 ;; IBM 405 and 440 half-word multiplication operations.
 939
 940 (define_insn "*macchwc"
 941   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
 942         (compare:CC (plus:SI (mult:SI (ashiftrt:SI
 943                                        (match_operand:SI 2 "gpc_reg_operand" "r")
 944                                        (const_int 16))
 945                                       (sign_extend:SI
 946                                        (match_operand:HI 1 "gpc_reg_operand" "r")))
 947                              (match_operand:SI 4 "gpc_reg_operand" "0"))
 948                     (const_int 0)))
 949    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 950         (plus:SI (mult:SI (ashiftrt:SI
 951                            (match_dup 2)
 952                            (const_int 16))
 953                           (sign_extend:SI
 954                            (match_dup 1)))
 955                  (match_dup 4)))]
 956   "TARGET_MULHW"
 957   "macchw. %0, %1, %2"
 958   [(set_attr "type" "imul3")])
 959
 960 (define_insn "*macchw"
 961   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 962         (plus:SI (mult:SI (ashiftrt:SI
 963                            (match_operand:SI 2 "gpc_reg_operand" "r")
 964                            (const_int 16))
 965                           (sign_extend:SI
 966                            (match_operand:HI 1 "gpc_reg_operand" "r")))
 967                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
 968   "TARGET_MULHW"
 969   "macchw %0, %1, %2"
 970   [(set_attr "type" "imul3")])
 971
 972 (define_insn "*macchwuc"
 973   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
 974         (compare:CC (plus:SI (mult:SI (lshiftrt:SI
 975                                        (match_operand:SI 2 "gpc_reg_operand" "r")
 976                                        (const_int 16))
 977                                       (zero_extend:SI
 978                                        (match_operand:HI 1 "gpc_reg_operand" "r")))
 979                              (match_operand:SI 4 "gpc_reg_operand" "0"))
 980                     (const_int 0)))
 981    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
 982         (plus:SI (mult:SI (lshiftrt:SI
 983                            (match_dup 2)
 984                            (const_int 16))
 985                           (zero_extend:SI
 986                            (match_dup 1)))
 987                  (match_dup 4)))]
 988   "TARGET_MULHW"
 989   "macchwu. %0, %1, %2"
 990   [(set_attr "type" "imul3")])
 991
 992 (define_insn "*macchwu"
 993   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
 994         (plus:SI (mult:SI (lshiftrt:SI
 995                            (match_operand:SI 2 "gpc_reg_operand" "r")
 996                            (const_int 16))
 997                           (zero_extend:SI
 998                            (match_operand:HI 1 "gpc_reg_operand" "r")))
 999                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
1000   "TARGET_MULHW"
1001   "macchwu %0, %1, %2"
1002   [(set_attr "type" "imul3")])
1003
1004 (define_insn "*machhwc"
1005   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1006         (compare:CC (plus:SI (mult:SI (ashiftrt:SI
1007                                        (match_operand:SI 1 "gpc_reg_operand" "%r")
1008                                        (const_int 16))
1009                                       (ashiftrt:SI
1010                                        (match_operand:SI 2 "gpc_reg_operand" "r")
1011                                        (const_int 16)))
1012                              (match_operand:SI 4 "gpc_reg_operand" "0"))
1013                     (const_int 0)))
1014    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1015         (plus:SI (mult:SI (ashiftrt:SI
1016                            (match_dup 1)
1017                            (const_int 16))
1018                           (ashiftrt:SI
1019                            (match_dup 2)
1020                            (const_int 16)))
1021                  (match_dup 4)))]
1022   "TARGET_MULHW"
1023   "machhw. %0, %1, %2"
1024   [(set_attr "type" "imul3")])
1025
1026 (define_insn "*machhw"
1027   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1028         (plus:SI (mult:SI (ashiftrt:SI
1029                            (match_operand:SI 1 "gpc_reg_operand" "%r")
1030                            (const_int 16))
1031                           (ashiftrt:SI
1032                            (match_operand:SI 2 "gpc_reg_operand" "r")
1033                            (const_int 16)))
1034                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
1035   "TARGET_MULHW"
1036   "machhw %0, %1, %2"
1037   [(set_attr "type" "imul3")])
1038
1039 (define_insn "*machhwuc"
1040   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1041         (compare:CC (plus:SI (mult:SI (lshiftrt:SI
1042                                        (match_operand:SI 1 "gpc_reg_operand" "%r")
1043                                        (const_int 16))
1044                                       (lshiftrt:SI
1045                                        (match_operand:SI 2 "gpc_reg_operand" "r")
1046                                        (const_int 16)))
1047                              (match_operand:SI 4 "gpc_reg_operand" "0"))
1048                     (const_int 0)))
1049    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1050         (plus:SI (mult:SI (lshiftrt:SI
1051                            (match_dup 1)
1052                            (const_int 16))
1053                           (lshiftrt:SI
1054                            (match_dup 2)
1055                            (const_int 16)))
1056                  (match_dup 4)))]
1057   "TARGET_MULHW"
1058   "machhwu. %0, %1, %2"
1059   [(set_attr "type" "imul3")])
1060
1061 (define_insn "*machhwu"
1062   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1063         (plus:SI (mult:SI (lshiftrt:SI
1064                            (match_operand:SI 1 "gpc_reg_operand" "%r")
1065                            (const_int 16))
1066                           (lshiftrt:SI
1067                            (match_operand:SI 2 "gpc_reg_operand" "r")
1068                            (const_int 16)))
1069                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
1070   "TARGET_MULHW"
1071   "machhwu %0, %1, %2"
1072   [(set_attr "type" "imul3")])
1073
1074 (define_insn "*maclhwc"
1075   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1076         (compare:CC (plus:SI (mult:SI (sign_extend:SI
1077                                        (match_operand:HI 1 "gpc_reg_operand" "%r"))
1078                                       (sign_extend:SI
1079                                        (match_operand:HI 2 "gpc_reg_operand" "r")))
1080                              (match_operand:SI 4 "gpc_reg_operand" "0"))
1081                     (const_int 0)))
1082    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1083         (plus:SI (mult:SI (sign_extend:SI
1084                            (match_dup 1))
1085                           (sign_extend:SI
1086                            (match_dup 2)))
1087                  (match_dup 4)))]
1088   "TARGET_MULHW"
1089   "maclhw. %0, %1, %2"
1090   [(set_attr "type" "imul3")])
1091
1092 (define_insn "*maclhw"
1093   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1094         (plus:SI (mult:SI (sign_extend:SI
1095                            (match_operand:HI 1 "gpc_reg_operand" "%r"))
1096                           (sign_extend:SI
1097                            (match_operand:HI 2 "gpc_reg_operand" "r")))
1098                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
1099   "TARGET_MULHW"
1100   "maclhw %0, %1, %2"
1101   [(set_attr "type" "imul3")])
1102
1103 (define_insn "*maclhwuc"
1104   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1105         (compare:CC (plus:SI (mult:SI (zero_extend:SI
1106                                        (match_operand:HI 1 "gpc_reg_operand" "%r"))
1107                                       (zero_extend:SI
1108                                        (match_operand:HI 2 "gpc_reg_operand" "r")))
1109                              (match_operand:SI 4 "gpc_reg_operand" "0"))
1110                     (const_int 0)))
1111    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1112         (plus:SI (mult:SI (zero_extend:SI
1113                            (match_dup 1))
1114                           (zero_extend:SI
1115                            (match_dup 2)))
1116                  (match_dup 4)))]
1117   "TARGET_MULHW"
1118   "maclhwu. %0, %1, %2"
1119   [(set_attr "type" "imul3")])
1120
1121 (define_insn "*maclhwu"
1122   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1123         (plus:SI (mult:SI (zero_extend:SI
1124                            (match_operand:HI 1 "gpc_reg_operand" "%r"))
1125                           (zero_extend:SI
1126                            (match_operand:HI 2 "gpc_reg_operand" "r")))
1127                  (match_operand:SI 3 "gpc_reg_operand" "0")))]
1128   "TARGET_MULHW"
1129   "maclhwu %0, %1, %2"
1130   [(set_attr "type" "imul3")])
1131
1132 (define_insn "*nmacchwc"
1133   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1134         (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1135                               (mult:SI (ashiftrt:SI
1136                                         (match_operand:SI 2 "gpc_reg_operand" "r")
1137                                         (const_int 16))
1138                                        (sign_extend:SI
1139                                         (match_operand:HI 1 "gpc_reg_operand" "r"))))
1140                     (const_int 0)))
1141    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1142         (minus:SI (match_dup 4)
1143                   (mult:SI (ashiftrt:SI
1144                             (match_dup 2)
1145                             (const_int 16))
1146                            (sign_extend:SI
1147                             (match_dup 1)))))]
1148   "TARGET_MULHW"
1149   "nmacchw. %0, %1, %2"
1150   [(set_attr "type" "imul3")])
1151
1152 (define_insn "*nmacchw"
1153   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1154         (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1155                   (mult:SI (ashiftrt:SI
1156                             (match_operand:SI 2 "gpc_reg_operand" "r")
1157                             (const_int 16))
1158                            (sign_extend:SI
1159                             (match_operand:HI 1 "gpc_reg_operand" "r")))))]
1160   "TARGET_MULHW"
1161   "nmacchw %0, %1, %2"
1162   [(set_attr "type" "imul3")])
1163
1164 (define_insn "*nmachhwc"
1165   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1166         (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1167                               (mult:SI (ashiftrt:SI
1168                                         (match_operand:SI 1 "gpc_reg_operand" "%r")
1169                                         (const_int 16))
1170                                        (ashiftrt:SI
1171                                         (match_operand:SI 2 "gpc_reg_operand" "r")
1172                                         (const_int 16))))
1173                     (const_int 0)))
1174    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1175         (minus:SI (match_dup 4)
1176                   (mult:SI (ashiftrt:SI
1177                             (match_dup 1)
1178                             (const_int 16))
1179                            (ashiftrt:SI
1180                             (match_dup 2)
1181                             (const_int 16)))))]
1182   "TARGET_MULHW"
1183   "nmachhw. %0, %1, %2"
1184   [(set_attr "type" "imul3")])
1185
1186 (define_insn "*nmachhw"
1187   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1188         (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1189                   (mult:SI (ashiftrt:SI
1190                             (match_operand:SI 1 "gpc_reg_operand" "%r")
1191                             (const_int 16))
1192                            (ashiftrt:SI
1193                             (match_operand:SI 2 "gpc_reg_operand" "r")
1194                             (const_int 16)))))]
1195   "TARGET_MULHW"
1196   "nmachhw %0, %1, %2"
1197   [(set_attr "type" "imul3")])
1198
1199 (define_insn "*nmaclhwc"
1200   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1201         (compare:CC (minus:SI (match_operand:SI 4 "gpc_reg_operand" "0")
1202                               (mult:SI (sign_extend:SI
1203                                         (match_operand:HI 1 "gpc_reg_operand" "%r"))
1204                                        (sign_extend:SI
1205                                         (match_operand:HI 2 "gpc_reg_operand" "r"))))
1206                     (const_int 0)))
1207    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1208         (minus:SI (match_dup 4)
1209                   (mult:SI (sign_extend:SI
1210                             (match_dup 1))
1211                            (sign_extend:SI
1212                             (match_dup 2)))))]
1213   "TARGET_MULHW"
1214   "nmaclhw. %0, %1, %2"
1215   [(set_attr "type" "imul3")])
1216
1217 (define_insn "*nmaclhw"
1218   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1219         (minus:SI (match_operand:SI 3 "gpc_reg_operand" "0")
1220                   (mult:SI (sign_extend:SI
1221                             (match_operand:HI 1 "gpc_reg_operand" "%r"))
1222                            (sign_extend:SI
1223                             (match_operand:HI 2 "gpc_reg_operand" "r")))))]
1224   "TARGET_MULHW"
1225   "nmaclhw %0, %1, %2"
1226   [(set_attr "type" "imul3")])
1227
1228 (define_insn "*mulchwc"
1229   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1230         (compare:CC (mult:SI (ashiftrt:SI
1231                               (match_operand:SI 2 "gpc_reg_operand" "r")
1232                               (const_int 16))
1233                              (sign_extend:SI
1234                               (match_operand:HI 1 "gpc_reg_operand" "r")))
1235                     (const_int 0)))
1236    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1237         (mult:SI (ashiftrt:SI
1238                   (match_dup 2)
1239                   (const_int 16))
1240                  (sign_extend:SI
1241                   (match_dup 1))))]
1242   "TARGET_MULHW"
1243   "mulchw. %0, %1, %2"
1244   [(set_attr "type" "imul3")])
1245
1246 (define_insn "*mulchw"
1247   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1248         (mult:SI (ashiftrt:SI
1249                   (match_operand:SI 2 "gpc_reg_operand" "r")
1250                   (const_int 16))
1251                  (sign_extend:SI
1252                   (match_operand:HI 1 "gpc_reg_operand" "r"))))]
1253   "TARGET_MULHW"
1254   "mulchw %0, %1, %2"
1255   [(set_attr "type" "imul3")])
1256
1257 (define_insn "*mulchwuc"
1258   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1259         (compare:CC (mult:SI (lshiftrt:SI
1260                               (match_operand:SI 2 "gpc_reg_operand" "r")
1261                               (const_int 16))
1262                              (zero_extend:SI
1263                               (match_operand:HI 1 "gpc_reg_operand" "r")))
1264                     (const_int 0)))
1265    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1266         (mult:SI (lshiftrt:SI
1267                   (match_dup 2)
1268                   (const_int 16))
1269                  (zero_extend:SI
1270                   (match_dup 1))))]
1271   "TARGET_MULHW"
1272   "mulchwu. %0, %1, %2"
1273   [(set_attr "type" "imul3")])
1274
1275 (define_insn "*mulchwu"
1276   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1277         (mult:SI (lshiftrt:SI
1278                   (match_operand:SI 2 "gpc_reg_operand" "r")
1279                   (const_int 16))
1280                  (zero_extend:SI
1281                   (match_operand:HI 1 "gpc_reg_operand" "r"))))]
1282   "TARGET_MULHW"
1283   "mulchwu %0, %1, %2"
1284   [(set_attr "type" "imul3")])
1285
1286 (define_insn "*mulhhwc"
1287   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1288         (compare:CC (mult:SI (ashiftrt:SI
1289                               (match_operand:SI 1 "gpc_reg_operand" "%r")
1290                               (const_int 16))
1291                              (ashiftrt:SI
1292                               (match_operand:SI 2 "gpc_reg_operand" "r")
1293                               (const_int 16)))
1294                     (const_int 0)))
1295    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1296         (mult:SI (ashiftrt:SI
1297                   (match_dup 1)
1298                   (const_int 16))
1299                  (ashiftrt:SI
1300                   (match_dup 2)
1301                   (const_int 16))))]
1302   "TARGET_MULHW"
1303   "mulhhw. %0, %1, %2"
1304   [(set_attr "type" "imul3")])
1305
1306 (define_insn "*mulhhw"
1307   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1308         (mult:SI (ashiftrt:SI
1309                   (match_operand:SI 1 "gpc_reg_operand" "%r")
1310                   (const_int 16))
1311                  (ashiftrt:SI
1312                   (match_operand:SI 2 "gpc_reg_operand" "r")
1313                   (const_int 16))))]
1314   "TARGET_MULHW"
1315   "mulhhw %0, %1, %2"
1316   [(set_attr "type" "imul3")])
1317
1318 (define_insn "*mulhhwuc"
1319   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1320         (compare:CC (mult:SI (lshiftrt:SI
1321                               (match_operand:SI 1 "gpc_reg_operand" "%r")
1322                               (const_int 16))
1323                              (lshiftrt:SI
1324                               (match_operand:SI 2 "gpc_reg_operand" "r")
1325                               (const_int 16)))
1326                     (const_int 0)))
1327    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1328         (mult:SI (lshiftrt:SI
1329                   (match_dup 1)
1330                   (const_int 16))
1331                  (lshiftrt:SI
1332                   (match_dup 2)
1333                   (const_int 16))))]
1334   "TARGET_MULHW"
1335   "mulhhwu. %0, %1, %2"
1336   [(set_attr "type" "imul3")])
1337
1338 (define_insn "*mulhhwu"
1339   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1340         (mult:SI (lshiftrt:SI
1341                   (match_operand:SI 1 "gpc_reg_operand" "%r")
1342                   (const_int 16))
1343                  (lshiftrt:SI
1344                   (match_operand:SI 2 "gpc_reg_operand" "r")
1345                   (const_int 16))))]
1346   "TARGET_MULHW"
1347   "mulhhwu %0, %1, %2"
1348   [(set_attr "type" "imul3")])
1349
1350 (define_insn "*mullhwc"
1351   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1352         (compare:CC (mult:SI (sign_extend:SI
1353                               (match_operand:HI 1 "gpc_reg_operand" "%r"))
1354                              (sign_extend:SI
1355                               (match_operand:HI 2 "gpc_reg_operand" "r")))
1356                     (const_int 0)))
1357    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1358         (mult:SI (sign_extend:SI
1359                   (match_dup 1))
1360                  (sign_extend:SI
1361                   (match_dup 2))))]
1362   "TARGET_MULHW"
1363   "mullhw. %0, %1, %2"
1364   [(set_attr "type" "imul3")])
1365
1366 (define_insn "*mullhw"
1367   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1368         (mult:SI (sign_extend:SI
1369                   (match_operand:HI 1 "gpc_reg_operand" "%r"))
1370                  (sign_extend:SI
1371                   (match_operand:HI 2 "gpc_reg_operand" "r"))))]
1372   "TARGET_MULHW"
1373   "mullhw %0, %1, %2"
1374   [(set_attr "type" "imul3")])
1375
1376 (define_insn "*mullhwuc"
1377   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1378         (compare:CC (mult:SI (zero_extend:SI
1379                               (match_operand:HI 1 "gpc_reg_operand" "%r"))
1380                              (zero_extend:SI
1381                               (match_operand:HI 2 "gpc_reg_operand" "r")))
1382                     (const_int 0)))
1383    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1384         (mult:SI (zero_extend:SI
1385                   (match_dup 1))
1386                  (zero_extend:SI
1387                   (match_dup 2))))]
1388   "TARGET_MULHW"
1389   "mullhwu. %0, %1, %2"
1390   [(set_attr "type" "imul3")])
1391
1392 (define_insn "*mullhwu"
1393   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1394         (mult:SI (zero_extend:SI
1395                   (match_operand:HI 1 "gpc_reg_operand" "%r"))
1396                  (zero_extend:SI
1397                   (match_operand:HI 2 "gpc_reg_operand" "r"))))]
1398   "TARGET_MULHW"
1399   "mullhwu %0, %1, %2"
1400   [(set_attr "type" "imul3")])
1401 \f
1402 ;; IBM 405 and 440 string-search dlmzb instruction support.
1403 (define_insn "dlmzb"
1404   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
1405         (unspec:CC [(match_operand:SI 1 "gpc_reg_operand" "r")
1406                     (match_operand:SI 2 "gpc_reg_operand" "r")]
1407                    UNSPEC_DLMZB_CR))
1408    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
1409         (unspec:SI [(match_dup 1)
1410                     (match_dup 2)]
1411                    UNSPEC_DLMZB))]
1412   "TARGET_DLMZB"
1413   "dlmzb. %0, %1, %2")
1414
1415 (define_expand "strlensi"
1416   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1417         (unspec:SI [(match_operand:BLK 1 "general_operand" "")
1418                     (match_operand:QI 2 "const_int_operand" "")
1419                     (match_operand 3 "const_int_operand" "")]
1420                    UNSPEC_DLMZB_STRLEN))
1421    (clobber (match_scratch:CC 4 "=x"))]
1422   "TARGET_DLMZB && WORDS_BIG_ENDIAN && !optimize_size"
1423 {
1424   rtx result = operands[0];
1425   rtx src = operands[1];
1426   rtx search_char = operands[2];
1427   rtx align = operands[3];
1428   rtx addr, scratch_string, word1, word2, scratch_dlmzb;
1429   rtx loop_label, end_label, mem, cr0, cond;
1430   if (search_char != const0_rtx
1431       || GET_CODE (align) != CONST_INT
1432       || INTVAL (align) < 8)
1433         FAIL;
1434   word1 = gen_reg_rtx (SImode);
1435   word2 = gen_reg_rtx (SImode);
1436   scratch_dlmzb = gen_reg_rtx (SImode);
1437   scratch_string = gen_reg_rtx (Pmode);
1438   loop_label = gen_label_rtx ();
1439   end_label = gen_label_rtx ();
1440   addr = force_reg (Pmode, XEXP (src, 0));
1441   emit_move_insn (scratch_string, addr);
1442   emit_label (loop_label);
1443   mem = change_address (src, SImode, scratch_string);
1444   emit_move_insn (word1, mem);
1445   emit_move_insn (word2, adjust_address (mem, SImode, 4));
1446   cr0 = gen_rtx_REG (CCmode, CR0_REGNO);
1447   emit_insn (gen_dlmzb (scratch_dlmzb, word1, word2, cr0));
1448   cond = gen_rtx_NE (VOIDmode, cr0, const0_rtx);
1449   emit_jump_insn (gen_rtx_SET (VOIDmode,
1450                                pc_rtx,
1451                                gen_rtx_IF_THEN_ELSE (VOIDmode,
1452                                                      cond,
1453                                                      gen_rtx_LABEL_REF
1454                                                        (VOIDmode,
1455                                                         end_label),
1456                                                      pc_rtx)));
1457   emit_insn (gen_addsi3 (scratch_string, scratch_string, GEN_INT (8)));
1458   emit_jump_insn (gen_rtx_SET (VOIDmode,
1459                                pc_rtx,
1460                                gen_rtx_LABEL_REF (VOIDmode, loop_label)));
1461   emit_barrier ();
1462   emit_label (end_label);
1463   emit_insn (gen_addsi3 (scratch_string, scratch_string, scratch_dlmzb));
1464   emit_insn (gen_subsi3 (result, scratch_string, addr));
1465   emit_insn (gen_subsi3 (result, result, const1_rtx));
1466   DONE;
1467 })
1468 \f
1469 (define_split
1470   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
1471         (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" ""))
1472                     (const_int 0)))
1473    (set (match_operand:SI 0 "gpc_reg_operand" "")
1474         (sign_extend:SI (match_dup 1)))]
1475   "reload_completed"
1476   [(set (match_dup 0)
1477         (sign_extend:SI (match_dup 1)))
1478    (set (match_dup 2)
1479         (compare:CC (match_dup 0)
1480                     (const_int 0)))]
1481   "")
1482
1483 ;; Fixed-point arithmetic insns.
1484
1485 (define_expand "add<mode>3"
1486   [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1487         (plus:SDI (match_operand:SDI 1 "gpc_reg_operand" "")
1488                   (match_operand:SDI 2 "reg_or_add_cint_operand" "")))]
1489   ""
1490 {
1491   if (<MODE>mode == DImode && ! TARGET_POWERPC64)
1492     {
1493       if (non_short_cint_operand (operands[2], DImode))
1494         FAIL;
1495     }
1496   else if (GET_CODE (operands[2]) == CONST_INT
1497            && ! add_operand (operands[2], <MODE>mode))
1498     {
1499       rtx tmp = ((!can_create_pseudo_p ()
1500                   || rtx_equal_p (operands[0], operands[1]))
1501                  ? operands[0] : gen_reg_rtx (<MODE>mode));
1502
1503       HOST_WIDE_INT val = INTVAL (operands[2]);
1504       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1505       HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1506
1507       if (<MODE>mode == DImode && !satisfies_constraint_L (GEN_INT (rest)))
1508         FAIL;
1509
1510       /* The ordering here is important for the prolog expander.
1511          When space is allocated from the stack, adding 'low' first may
1512          produce a temporary deallocation (which would be bad).  */
1513       emit_insn (gen_add<mode>3 (tmp, operands[1], GEN_INT (rest)));
1514       emit_insn (gen_add<mode>3 (operands[0], tmp, GEN_INT (low)));
1515       DONE;
1516     }
1517 })
1518
1519 ;; Discourage ai/addic because of carry but provide it in an alternative
1520 ;; allowing register zero as source.
1521 (define_insn "*add<mode>3_internal1"
1522   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r,?r,r")
1523         (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "%r,b,r,b")
1524                   (match_operand:GPR 2 "add_operand" "r,I,I,L")))]
1525   "!DECIMAL_FLOAT_MODE_P (GET_MODE (operands[0])) && !DECIMAL_FLOAT_MODE_P (GET_MODE (operands[1]))"
1526   "@
1527    {cax|add} %0,%1,%2
1528    {cal %0,%2(%1)|addi %0,%1,%2}
1529    {ai|addic} %0,%1,%2
1530    {cau|addis} %0,%1,%v2"
1531   [(set_attr "length" "4,4,4,4")])
1532
1533 (define_insn "addsi3_high"
1534   [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
1535         (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
1536                  (high:SI (match_operand 2 "" ""))))]
1537   "TARGET_MACHO && !TARGET_64BIT"
1538   "{cau|addis} %0,%1,ha16(%2)"
1539   [(set_attr "length" "4")])
1540
1541 (define_insn "*add<mode>3_internal2"
1542   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
1543         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1544                             (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1545                     (const_int 0)))
1546    (clobber (match_scratch:P 3 "=r,r,r,r"))]
1547   ""
1548   "@
1549    {cax.|add.} %3,%1,%2
1550    {ai.|addic.} %3,%1,%2
1551    #
1552    #"
1553   [(set_attr "type" "fast_compare,compare,compare,compare")
1554    (set_attr "length" "4,4,8,8")])
1555
1556 (define_split
1557   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1558         (compare:CC (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1559                               (match_operand:GPR 2 "reg_or_short_operand" ""))
1560                     (const_int 0)))
1561    (clobber (match_scratch:GPR 3 ""))]
1562   "reload_completed"
1563   [(set (match_dup 3)
1564         (plus:GPR (match_dup 1)
1565                  (match_dup 2)))
1566    (set (match_dup 0)
1567         (compare:CC (match_dup 3)
1568                     (const_int 0)))]
1569   "")
1570
1571 (define_insn "*add<mode>3_internal3"
1572   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
1573         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1574                             (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1575                     (const_int 0)))
1576    (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
1577         (plus:P (match_dup 1)
1578                 (match_dup 2)))]
1579   ""
1580   "@
1581    {cax.|add.} %0,%1,%2
1582    {ai.|addic.} %0,%1,%2
1583    #
1584    #"
1585   [(set_attr "type" "fast_compare,compare,compare,compare")
1586    (set_attr "length" "4,4,8,8")])
1587
1588 (define_split
1589   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1590         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "")
1591                             (match_operand:P 2 "reg_or_short_operand" ""))
1592                     (const_int 0)))
1593    (set (match_operand:P 0 "gpc_reg_operand" "")
1594         (plus:P (match_dup 1) (match_dup 2)))]
1595   "reload_completed"
1596   [(set (match_dup 0)
1597         (plus:P (match_dup 1)
1598                 (match_dup 2)))
1599    (set (match_dup 3)
1600         (compare:CC (match_dup 0)
1601                     (const_int 0)))]
1602   "")
1603
1604 ;; Split an add that we can't do in one insn into two insns, each of which
1605 ;; does one 16-bit part.  This is used by combine.  Note that the low-order
1606 ;; add should be last in case the result gets used in an address.
1607
1608 (define_split
1609   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1610         (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1611                   (match_operand:GPR 2 "non_add_cint_operand" "")))]
1612   ""
1613   [(set (match_dup 0) (plus:GPR (match_dup 1) (match_dup 3)))
1614    (set (match_dup 0) (plus:GPR (match_dup 0) (match_dup 4)))]
1615 {
1616   HOST_WIDE_INT val = INTVAL (operands[2]);
1617   HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1618   HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1619
1620   operands[4] = GEN_INT (low);
1621   if (<MODE>mode == SImode || satisfies_constraint_L (GEN_INT (rest)))
1622     operands[3] = GEN_INT (rest);
1623   else if (can_create_pseudo_p ())
1624     {
1625       operands[3] = gen_reg_rtx (DImode);
1626       emit_move_insn (operands[3], operands[2]);
1627       emit_insn (gen_adddi3 (operands[0], operands[1], operands[3]));
1628       DONE;
1629     }
1630   else
1631     FAIL;
1632 })
1633
1634 (define_insn "one_cmpl<mode>2"
1635   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1636         (not:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1637   ""
1638   "nor %0,%1,%1")
1639
1640 (define_insn ""
1641   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1642         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1643                     (const_int 0)))
1644    (clobber (match_scratch:P 2 "=r,r"))]
1645   ""
1646   "@
1647    nor. %2,%1,%1
1648    #"
1649   [(set_attr "type" "compare")
1650    (set_attr "length" "4,8")])
1651
1652 (define_split
1653   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1654         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1655                     (const_int 0)))
1656    (clobber (match_scratch:P 2 ""))]
1657   "reload_completed"
1658   [(set (match_dup 2)
1659         (not:P (match_dup 1)))
1660    (set (match_dup 0)
1661         (compare:CC (match_dup 2)
1662                     (const_int 0)))]
1663   "")
1664
1665 (define_insn ""
1666   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
1667         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1668                     (const_int 0)))
1669    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1670         (not:P (match_dup 1)))]
1671   ""
1672   "@
1673    nor. %0,%1,%1
1674    #"
1675   [(set_attr "type" "compare")
1676    (set_attr "length" "4,8")])
1677
1678 (define_split
1679   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
1680         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1681                     (const_int 0)))
1682    (set (match_operand:P 0 "gpc_reg_operand" "")
1683         (not:P (match_dup 1)))]
1684   "reload_completed"
1685   [(set (match_dup 0)
1686         (not:P (match_dup 1)))
1687    (set (match_dup 2)
1688         (compare:CC (match_dup 0)
1689                     (const_int 0)))]
1690   "")
1691
1692 (define_insn ""
1693   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1694         (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
1695                   (match_operand:SI 2 "gpc_reg_operand" "r")))]
1696   "! TARGET_POWERPC"
1697   "{sf%I1|subf%I1c} %0,%2,%1")
1698
1699 (define_insn ""
1700   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r")
1701         (minus:GPR (match_operand:GPR 1 "reg_or_short_operand" "r,I")
1702                    (match_operand:GPR 2 "gpc_reg_operand" "r,r")))]
1703   "TARGET_POWERPC"
1704   "@
1705    subf %0,%2,%1
1706    subfic %0,%2,%1")
1707
1708 (define_insn ""
1709   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1710         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1711                               (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1712                     (const_int 0)))
1713    (clobber (match_scratch:SI 3 "=r,r"))]
1714   "! TARGET_POWERPC"
1715   "@
1716    {sf.|subfc.} %3,%2,%1
1717    #"
1718   [(set_attr "type" "compare")
1719    (set_attr "length" "4,8")])
1720
1721 (define_insn ""
1722   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1723         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1724                              (match_operand:P 2 "gpc_reg_operand" "r,r"))
1725                     (const_int 0)))
1726    (clobber (match_scratch:P 3 "=r,r"))]
1727   "TARGET_POWERPC"
1728   "@
1729    subf. %3,%2,%1
1730    #"
1731   [(set_attr "type" "fast_compare")
1732    (set_attr "length" "4,8")])
1733
1734 (define_split
1735   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1736         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1737                              (match_operand:P 2 "gpc_reg_operand" ""))
1738                     (const_int 0)))
1739    (clobber (match_scratch:P 3 ""))]
1740   "reload_completed"
1741   [(set (match_dup 3)
1742         (minus:P (match_dup 1)
1743                   (match_dup 2)))
1744    (set (match_dup 0)
1745         (compare:CC (match_dup 3)
1746                     (const_int 0)))]
1747   "")
1748
1749 (define_insn ""
1750   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1751         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1752                               (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1753                     (const_int 0)))
1754    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1755         (minus:SI (match_dup 1) (match_dup 2)))]
1756   "! TARGET_POWERPC"
1757   "@
1758    {sf.|subfc.} %0,%2,%1
1759    #"
1760   [(set_attr "type" "compare")
1761    (set_attr "length" "4,8")])
1762
1763 (define_insn ""
1764   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1765         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1766                              (match_operand:P 2 "gpc_reg_operand" "r,r"))
1767                     (const_int 0)))
1768    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1769         (minus:P (match_dup 1)
1770                   (match_dup 2)))]
1771   "TARGET_POWERPC"
1772   "@
1773    subf. %0,%2,%1
1774    #"
1775   [(set_attr "type" "fast_compare")
1776    (set_attr "length" "4,8")])
1777
1778 (define_split
1779   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1780         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1781                              (match_operand:P 2 "gpc_reg_operand" ""))
1782                     (const_int 0)))
1783    (set (match_operand:P 0 "gpc_reg_operand" "")
1784         (minus:P (match_dup 1)
1785                   (match_dup 2)))]
1786   "reload_completed"
1787   [(set (match_dup 0)
1788         (minus:P (match_dup 1)
1789                   (match_dup 2)))
1790    (set (match_dup 3)
1791         (compare:CC (match_dup 0)
1792                     (const_int 0)))]
1793   "")
1794
1795 (define_expand "sub<mode>3"
1796   [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1797         (minus:SDI (match_operand:SDI 1 "reg_or_short_operand" "")
1798                    (match_operand:SDI 2 "reg_or_sub_cint_operand" "")))]
1799   ""
1800   "
1801 {
1802   if (GET_CODE (operands[2]) == CONST_INT)
1803     {
1804       emit_insn (gen_add<mode>3 (operands[0], operands[1],
1805                                  negate_rtx (<MODE>mode, operands[2])));
1806       DONE;
1807     }
1808 }")
1809
1810 ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
1811 ;; instruction and some auxiliary computations.  Then we just have a single
1812 ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
1813 ;; combine.
1814
1815 (define_expand "sminsi3"
1816   [(set (match_dup 3)
1817         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1818                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1819                          (const_int 0)
1820                          (minus:SI (match_dup 2) (match_dup 1))))
1821    (set (match_operand:SI 0 "gpc_reg_operand" "")
1822         (minus:SI (match_dup 2) (match_dup 3)))]
1823   "TARGET_POWER || TARGET_ISEL"
1824   "
1825 {
1826   if (TARGET_ISEL)
1827     {
1828       operands[2] = force_reg (SImode, operands[2]);
1829       rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]);
1830       DONE;
1831     }
1832
1833   operands[3] = gen_reg_rtx (SImode);
1834 }")
1835
1836 (define_split
1837   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1838         (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
1839                  (match_operand:SI 2 "reg_or_short_operand" "")))
1840    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1841   "TARGET_POWER"
1842   [(set (match_dup 3)
1843         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1844                          (const_int 0)
1845                          (minus:SI (match_dup 2) (match_dup 1))))
1846    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
1847   "")
1848
1849 (define_expand "smaxsi3"
1850   [(set (match_dup 3)
1851         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1852                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1853                          (const_int 0)
1854                          (minus:SI (match_dup 2) (match_dup 1))))
1855    (set (match_operand:SI 0 "gpc_reg_operand" "")
1856         (plus:SI (match_dup 3) (match_dup 1)))]
1857   "TARGET_POWER || TARGET_ISEL"
1858   "
1859 {
1860   if (TARGET_ISEL)
1861     {
1862       operands[2] = force_reg (SImode, operands[2]);
1863       rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]);
1864       DONE;
1865     }
1866   operands[3] = gen_reg_rtx (SImode);
1867 }")
1868
1869 (define_split
1870   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1871         (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
1872                  (match_operand:SI 2 "reg_or_short_operand" "")))
1873    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1874   "TARGET_POWER"
1875   [(set (match_dup 3)
1876         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1877                          (const_int 0)
1878                          (minus:SI (match_dup 2) (match_dup 1))))
1879    (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
1880   "")
1881
1882 (define_expand "uminsi3"
1883   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1884                               (match_dup 5)))
1885    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1886                               (match_dup 5)))
1887    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1888                                        (const_int 0)
1889                                        (minus:SI (match_dup 4) (match_dup 3))))
1890    (set (match_operand:SI 0 "gpc_reg_operand" "")
1891         (minus:SI (match_dup 2) (match_dup 3)))]
1892   "TARGET_POWER || TARGET_ISEL"
1893   "
1894 {
1895   if (TARGET_ISEL)
1896     {
1897       rs6000_emit_minmax (operands[0], UMIN, operands[1], operands[2]);
1898       DONE;
1899     }
1900   operands[3] = gen_reg_rtx (SImode);
1901   operands[4] = gen_reg_rtx (SImode);
1902   operands[5] = GEN_INT (-2147483647 - 1);
1903 }")
1904
1905 (define_expand "umaxsi3"
1906   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1907                               (match_dup 5)))
1908    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1909                               (match_dup 5)))
1910    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1911                                        (const_int 0)
1912                                        (minus:SI (match_dup 4) (match_dup 3))))
1913    (set (match_operand:SI 0 "gpc_reg_operand" "")
1914         (plus:SI (match_dup 3) (match_dup 1)))]
1915   "TARGET_POWER || TARGET_ISEL"
1916   "
1917 {
1918   if (TARGET_ISEL)
1919     {
1920       rs6000_emit_minmax (operands[0], UMAX, operands[1], operands[2]);
1921       DONE;
1922     }
1923   operands[3] = gen_reg_rtx (SImode);
1924   operands[4] = gen_reg_rtx (SImode);
1925   operands[5] = GEN_INT (-2147483647 - 1);
1926 }")
1927
1928 (define_insn ""
1929   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1930         (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1931                              (match_operand:SI 2 "reg_or_short_operand" "rI"))
1932                          (const_int 0)
1933                          (minus:SI (match_dup 2) (match_dup 1))))]
1934   "TARGET_POWER"
1935   "doz%I2 %0,%1,%2")
1936
1937 (define_insn ""
1938   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1939         (compare:CC
1940          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1941                               (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1942                           (const_int 0)
1943                           (minus:SI (match_dup 2) (match_dup 1)))
1944          (const_int 0)))
1945    (clobber (match_scratch:SI 3 "=r,r"))]
1946   "TARGET_POWER"
1947   "@
1948    doz%I2. %3,%1,%2
1949    #"
1950   [(set_attr "type" "delayed_compare")
1951    (set_attr "length" "4,8")])
1952
1953 (define_split
1954   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1955         (compare:CC
1956          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1957                               (match_operand:SI 2 "reg_or_short_operand" ""))
1958                           (const_int 0)
1959                           (minus:SI (match_dup 2) (match_dup 1)))
1960          (const_int 0)))
1961    (clobber (match_scratch:SI 3 ""))]
1962   "TARGET_POWER && reload_completed"
1963   [(set (match_dup 3)
1964         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1965                           (const_int 0)
1966                           (minus:SI (match_dup 2) (match_dup 1))))
1967    (set (match_dup 0)
1968         (compare:CC (match_dup 3)
1969                     (const_int 0)))]
1970   "")
1971
1972 (define_insn ""
1973   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1974         (compare:CC
1975          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1976                               (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1977                           (const_int 0)
1978                           (minus:SI (match_dup 2) (match_dup 1)))
1979          (const_int 0)))
1980    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1981         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1982                          (const_int 0)
1983                          (minus:SI (match_dup 2) (match_dup 1))))]
1984   "TARGET_POWER"
1985   "@
1986    doz%I2. %0,%1,%2
1987    #"
1988   [(set_attr "type" "delayed_compare")
1989    (set_attr "length" "4,8")])
1990
1991 (define_split
1992   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1993         (compare:CC
1994          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1995                               (match_operand:SI 2 "reg_or_short_operand" ""))
1996                           (const_int 0)
1997                           (minus:SI (match_dup 2) (match_dup 1)))
1998          (const_int 0)))
1999    (set (match_operand:SI 0 "gpc_reg_operand" "")
2000         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
2001                          (const_int 0)
2002                          (minus:SI (match_dup 2) (match_dup 1))))]
2003   "TARGET_POWER && reload_completed"
2004   [(set (match_dup 0)
2005         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
2006                          (const_int 0)
2007                          (minus:SI (match_dup 2) (match_dup 1))))
2008    (set (match_dup 3)
2009         (compare:CC (match_dup 0)
2010                     (const_int 0)))]
2011   "")
2012
2013 ;; We don't need abs with condition code because such comparisons should
2014 ;; never be done.
2015 (define_expand "abssi2"
2016   [(set (match_operand:SI 0 "gpc_reg_operand" "")
2017         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
2018   ""
2019   "
2020 {
2021   if (TARGET_ISEL)
2022     {
2023       emit_insn (gen_abssi2_isel (operands[0], operands[1]));
2024       DONE;
2025     }
2026   else if (! TARGET_POWER)
2027     {
2028       emit_insn (gen_abssi2_nopower (operands[0], operands[1]));
2029       DONE;
2030     }
2031 }")
2032
2033 (define_insn "*abssi2_power"
2034   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2035         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
2036   "TARGET_POWER"
2037   "abs %0,%1")
2038
2039 (define_insn_and_split "abssi2_isel"
2040   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2041         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
2042    (clobber (match_scratch:SI 2 "=&b"))
2043    (clobber (match_scratch:CC 3 "=y"))]
2044   "TARGET_ISEL"
2045   "#"
2046   "&& reload_completed"
2047   [(set (match_dup 2) (neg:SI (match_dup 1)))
2048    (set (match_dup 3)
2049         (compare:CC (match_dup 1)
2050                     (const_int 0)))
2051    (set (match_dup 0)
2052         (if_then_else:SI (ge (match_dup 3)
2053                              (const_int 0))
2054                          (match_dup 1)
2055                          (match_dup 2)))]
2056   "")
2057
2058 (define_insn_and_split "abssi2_nopower"
2059   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2060         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
2061    (clobber (match_scratch:SI 2 "=&r,&r"))]
2062   "! TARGET_POWER && ! TARGET_ISEL"
2063   "#"
2064   "&& reload_completed"
2065   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2066    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2067    (set (match_dup 0) (minus:SI (match_dup 0) (match_dup 2)))]
2068   "")
2069
2070 (define_insn "*nabs_power"
2071   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2072         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
2073   "TARGET_POWER"
2074   "nabs %0,%1")
2075
2076 (define_insn_and_split "*nabs_nopower"
2077   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2078         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
2079    (clobber (match_scratch:SI 2 "=&r,&r"))]
2080   "! TARGET_POWER"
2081   "#"
2082   "&& reload_completed"
2083   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2084    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2085    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 0)))]
2086   "")
2087
2088 (define_expand "neg<mode>2"
2089   [(set (match_operand:SDI 0 "gpc_reg_operand" "")
2090         (neg:SDI (match_operand:SDI 1 "gpc_reg_operand" "")))]
2091   ""
2092   "")
2093
2094 (define_insn "*neg<mode>2_internal"
2095   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2096         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2097   ""
2098   "neg %0,%1")
2099
2100 (define_insn ""
2101   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2102         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2103                     (const_int 0)))
2104    (clobber (match_scratch:P 2 "=r,r"))]
2105   ""
2106   "@
2107    neg. %2,%1
2108    #"
2109   [(set_attr "type" "fast_compare")
2110    (set_attr "length" "4,8")])
2111
2112 (define_split
2113   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2114         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2115                     (const_int 0)))
2116    (clobber (match_scratch:P 2 ""))]
2117   "reload_completed"
2118   [(set (match_dup 2)
2119         (neg:P (match_dup 1)))
2120    (set (match_dup 0)
2121         (compare:CC (match_dup 2)
2122                     (const_int 0)))]
2123   "")
2124
2125 (define_insn ""
2126   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
2127         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2128                     (const_int 0)))
2129    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2130         (neg:P (match_dup 1)))]
2131   ""
2132   "@
2133    neg. %0,%1
2134    #"
2135   [(set_attr "type" "fast_compare")
2136    (set_attr "length" "4,8")])
2137
2138 (define_split
2139   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
2140         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2141                     (const_int 0)))
2142    (set (match_operand:P 0 "gpc_reg_operand" "")
2143         (neg:P (match_dup 1)))]
2144   "reload_completed"
2145   [(set (match_dup 0)
2146         (neg:P (match_dup 1)))
2147    (set (match_dup 2)
2148         (compare:CC (match_dup 0)
2149                     (const_int 0)))]
2150   "")
2151
2152 (define_insn "clz<mode>2"
2153   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2154         (clz:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2155   ""
2156   "{cntlz|cntlz<wd>} %0,%1"
2157   [(set_attr "type" "cntlz")])
2158
2159 (define_expand "ctz<mode>2"
2160   [(set (match_dup 2)
2161         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2162    (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2163                                           (match_dup 2)))
2164               (clobber (scratch:CC))])
2165    (set (match_dup 4) (clz:GPR (match_dup 3)))
2166    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2167         (minus:GPR (match_dup 5) (match_dup 4)))]
2168   ""
2169   {
2170      operands[2] = gen_reg_rtx (<MODE>mode);
2171      operands[3] = gen_reg_rtx (<MODE>mode);
2172      operands[4] = gen_reg_rtx (<MODE>mode);
2173      operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - 1);
2174   })
2175
2176 (define_expand "ffs<mode>2"
2177   [(set (match_dup 2)
2178         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2179    (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2180                                           (match_dup 2)))
2181               (clobber (scratch:CC))])
2182    (set (match_dup 4) (clz:GPR (match_dup 3)))
2183    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2184         (minus:GPR (match_dup 5) (match_dup 4)))]
2185   ""
2186   {
2187      operands[2] = gen_reg_rtx (<MODE>mode);
2188      operands[3] = gen_reg_rtx (<MODE>mode);
2189      operands[4] = gen_reg_rtx (<MODE>mode);
2190      operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode));
2191   })
2192
2193 (define_insn "popcntb<mode>2"
2194   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2195         (unspec:GPR [(match_operand:GPR 1 "gpc_reg_operand" "r")]
2196                      UNSPEC_POPCNTB))]
2197   "TARGET_POPCNTB"
2198   "popcntb %0,%1")
2199
2200 (define_expand "popcount<mode>2"
2201   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2202         (popcount:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2203   "TARGET_POPCNTB"
2204   {
2205     rs6000_emit_popcount (operands[0], operands[1]);
2206     DONE;
2207   })
2208
2209 (define_expand "parity<mode>2"
2210   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2211         (parity:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2212   "TARGET_POPCNTB"
2213   {
2214     rs6000_emit_parity (operands[0], operands[1]);
2215     DONE;
2216   })
2217
2218 (define_insn "bswapsi2"
2219   [(set (match_operand:SI 0 "reg_or_mem_operand" "=r,Z,&r")
2220         (bswap:SI (match_operand:SI 1 "reg_or_mem_operand" "Z,r,r")))]
2221   ""
2222   "@
2223    {lbrx|lwbrx} %0,%y1
2224    {stbrx|stwbrx} %1,%y0
2225    #"
2226   [(set_attr "length" "4,4,12")])
2227
2228 (define_split
2229   [(set (match_operand:SI 0 "gpc_reg_operand" "")
2230         (bswap:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
2231   "reload_completed"
2232   [(set (match_dup 0)
2233         (rotate:SI (match_dup 1) (const_int 8)))
2234    (set (zero_extract:SI (match_dup 0)
2235                          (const_int 8)
2236                          (const_int 0))
2237         (match_dup 1))
2238    (set (zero_extract:SI (match_dup 0)
2239                          (const_int 8)
2240                          (const_int 16))
2241         (rotate:SI (match_dup 1)
2242                    (const_int 16)))]
2243   "")
2244
2245 (define_expand "mulsi3"
2246   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
2247    (use (match_operand:SI 1 "gpc_reg_operand" ""))
2248    (use (match_operand:SI 2 "reg_or_short_operand" ""))]
2249   ""
2250   "
2251 {
2252   if (TARGET_POWER)
2253     emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
2254   else
2255     emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
2256   DONE;
2257 }")
2258
2259 (define_insn "mulsi3_mq"
2260   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2261         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2262                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))
2263    (clobber (match_scratch:SI 3 "=q,q"))]
2264   "TARGET_POWER"
2265   "@
2266    {muls|mullw} %0,%1,%2
2267    {muli|mulli} %0,%1,%2"
2268    [(set (attr "type")
2269       (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2270                 (const_string "imul3")
2271              (match_operand:SI 2 "short_cint_operand" "")
2272                 (const_string "imul2")]
2273         (const_string "imul")))])
2274
2275 (define_insn "mulsi3_no_mq"
2276   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2277         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2278                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
2279   "! TARGET_POWER"
2280   "@
2281    {muls|mullw} %0,%1,%2
2282    {muli|mulli} %0,%1,%2"
2283    [(set (attr "type")
2284       (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2285                 (const_string "imul3")
2286              (match_operand:SI 2 "short_cint_operand" "")
2287                 (const_string "imul2")]
2288         (const_string "imul")))])
2289
2290 (define_insn "*mulsi3_mq_internal1"
2291   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2292         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2293                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2294                     (const_int 0)))
2295    (clobber (match_scratch:SI 3 "=r,r"))
2296    (clobber (match_scratch:SI 4 "=q,q"))]
2297   "TARGET_POWER"
2298   "@
2299    {muls.|mullw.} %3,%1,%2
2300    #"
2301   [(set_attr "type" "imul_compare")
2302    (set_attr "length" "4,8")])
2303
2304 (define_split
2305   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2306         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2307                              (match_operand:SI 2 "gpc_reg_operand" ""))
2308                     (const_int 0)))
2309    (clobber (match_scratch:SI 3 ""))
2310    (clobber (match_scratch:SI 4 ""))]
2311   "TARGET_POWER && reload_completed"
2312   [(parallel [(set (match_dup 3)
2313         (mult:SI (match_dup 1) (match_dup 2)))
2314    (clobber (match_dup 4))])
2315    (set (match_dup 0)
2316         (compare:CC (match_dup 3)
2317                     (const_int 0)))]
2318   "")
2319
2320 (define_insn "*mulsi3_no_mq_internal1"
2321   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2322         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2323                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2324                     (const_int 0)))
2325    (clobber (match_scratch:SI 3 "=r,r"))]
2326   "! TARGET_POWER"
2327   "@
2328    {muls.|mullw.} %3,%1,%2
2329    #"
2330   [(set_attr "type" "imul_compare")
2331    (set_attr "length" "4,8")])
2332
2333 (define_split
2334   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2335         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2336                              (match_operand:SI 2 "gpc_reg_operand" ""))
2337                     (const_int 0)))
2338    (clobber (match_scratch:SI 3 ""))]
2339   "! TARGET_POWER && reload_completed"
2340   [(set (match_dup 3)
2341         (mult:SI (match_dup 1) (match_dup 2)))
2342    (set (match_dup 0)
2343         (compare:CC (match_dup 3)
2344                     (const_int 0)))]
2345   "")
2346
2347 (define_insn "*mulsi3_mq_internal2"
2348   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2349         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2350                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2351                     (const_int 0)))
2352    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2353         (mult:SI (match_dup 1) (match_dup 2)))
2354    (clobber (match_scratch:SI 4 "=q,q"))]
2355   "TARGET_POWER"
2356   "@
2357    {muls.|mullw.} %0,%1,%2
2358    #"
2359   [(set_attr "type" "imul_compare")
2360    (set_attr "length" "4,8")])
2361
2362 (define_split
2363   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2364         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2365                              (match_operand:SI 2 "gpc_reg_operand" ""))
2366                     (const_int 0)))
2367    (set (match_operand:SI 0 "gpc_reg_operand" "")
2368         (mult:SI (match_dup 1) (match_dup 2)))
2369    (clobber (match_scratch:SI 4 ""))]
2370   "TARGET_POWER && reload_completed"
2371   [(parallel [(set (match_dup 0)
2372         (mult:SI (match_dup 1) (match_dup 2)))
2373    (clobber (match_dup 4))])
2374    (set (match_dup 3)
2375         (compare:CC (match_dup 0)
2376                     (const_int 0)))]
2377   "")
2378
2379 (define_insn "*mulsi3_no_mq_internal2"
2380   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2381         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2382                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2383                     (const_int 0)))
2384    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2385         (mult:SI (match_dup 1) (match_dup 2)))]
2386   "! TARGET_POWER"
2387   "@
2388    {muls.|mullw.} %0,%1,%2
2389    #"
2390   [(set_attr "type" "imul_compare")
2391    (set_attr "length" "4,8")])
2392
2393 (define_split
2394   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2395         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2396                              (match_operand:SI 2 "gpc_reg_operand" ""))
2397                     (const_int 0)))
2398    (set (match_operand:SI 0 "gpc_reg_operand" "")
2399         (mult:SI (match_dup 1) (match_dup 2)))]
2400   "! TARGET_POWER && reload_completed"
2401   [(set (match_dup 0)
2402         (mult:SI (match_dup 1) (match_dup 2)))
2403    (set (match_dup 3)
2404         (compare:CC (match_dup 0)
2405                     (const_int 0)))]
2406   "")
2407
2408 ;; Operand 1 is divided by operand 2; quotient goes to operand
2409 ;; 0 and remainder to operand 3.
2410 ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
2411
2412 (define_expand "divmodsi4"
2413   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2414                    (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
2415                            (match_operand:SI 2 "gpc_reg_operand" "")))
2416               (set (match_operand:SI 3 "register_operand" "")
2417                    (mod:SI (match_dup 1) (match_dup 2)))])]
2418   "TARGET_POWER || (! TARGET_POWER && ! TARGET_POWERPC)"
2419   "
2420 {
2421   if (! TARGET_POWER && ! TARGET_POWERPC)
2422     {
2423       emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2424       emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2425       emit_insn (gen_divss_call ());
2426       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2427       emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2428       DONE;
2429     }
2430 }")
2431
2432 (define_insn "*divmodsi4_internal"
2433   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2434         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2435                 (match_operand:SI 2 "gpc_reg_operand" "r")))
2436    (set (match_operand:SI 3 "register_operand" "=q")
2437         (mod:SI (match_dup 1) (match_dup 2)))]
2438   "TARGET_POWER"
2439   "divs %0,%1,%2"
2440   [(set_attr "type" "idiv")])
2441
2442 (define_expand "udiv<mode>3"
2443   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2444         (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2445                   (match_operand:GPR 2 "gpc_reg_operand" "")))]
2446   "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
2447   "
2448 {
2449   if (! TARGET_POWER && ! TARGET_POWERPC)
2450     {
2451       emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2452       emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2453       emit_insn (gen_quous_call ());
2454       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2455       DONE;
2456     }
2457   else if (TARGET_POWER)
2458     {
2459       emit_insn (gen_udivsi3_mq (operands[0], operands[1], operands[2]));
2460       DONE;
2461     }
2462 }")
2463
2464 (define_insn "udivsi3_mq"
2465   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2466         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2467                  (match_operand:SI 2 "gpc_reg_operand" "r")))
2468    (clobber (match_scratch:SI 3 "=q"))]
2469   "TARGET_POWERPC && TARGET_POWER"
2470   "divwu %0,%1,%2"
2471   [(set_attr "type" "idiv")])
2472
2473 (define_insn "*udivsi3_no_mq"
2474   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2475         (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2476                   (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2477   "TARGET_POWERPC && ! TARGET_POWER"
2478   "div<wd>u %0,%1,%2"
2479    [(set (attr "type")
2480       (cond [(match_operand:SI 0 "" "")
2481                 (const_string "idiv")]
2482         (const_string "ldiv")))])
2483
2484
2485 ;; For powers of two we can do srai/aze for divide and then adjust for
2486 ;; modulus.  If it isn't a power of two, FAIL on POWER so divmodsi4 will be
2487 ;; used; for PowerPC, force operands into register and do a normal divide;
2488 ;; for AIX common-mode, use quoss call on register operands.
2489 (define_expand "div<mode>3"
2490   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2491         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2492                  (match_operand:GPR 2 "reg_or_cint_operand" "")))]
2493   ""
2494   "
2495 {
2496   if (GET_CODE (operands[2]) == CONST_INT
2497       && INTVAL (operands[2]) > 0
2498       && exact_log2 (INTVAL (operands[2])) >= 0)
2499     ;
2500   else if (TARGET_POWERPC)
2501     {
2502       operands[2] = force_reg (<MODE>mode, operands[2]);
2503       if (TARGET_POWER)
2504         {
2505           emit_insn (gen_divsi3_mq (operands[0], operands[1], operands[2]));
2506           DONE;
2507         }
2508     }
2509   else if (TARGET_POWER)
2510     FAIL;
2511   else
2512     {
2513       emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2514       emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2515       emit_insn (gen_quoss_call ());
2516       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2517       DONE;
2518     }
2519 }")
2520
2521 (define_insn "divsi3_mq"
2522   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2523         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2524                 (match_operand:SI 2 "gpc_reg_operand" "r")))
2525    (clobber (match_scratch:SI 3 "=q"))]
2526   "TARGET_POWERPC && TARGET_POWER"
2527   "divw %0,%1,%2"
2528   [(set_attr "type" "idiv")])
2529
2530 (define_insn "*div<mode>3_no_mq"
2531   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2532         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2533                  (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2534   "TARGET_POWERPC && ! TARGET_POWER"
2535   "div<wd> %0,%1,%2"
2536   [(set (attr "type")
2537      (cond [(match_operand:SI 0 "" "")
2538                 (const_string "idiv")]
2539         (const_string "ldiv")))])
2540
2541 (define_expand "mod<mode>3"
2542   [(use (match_operand:GPR 0 "gpc_reg_operand" ""))
2543    (use (match_operand:GPR 1 "gpc_reg_operand" ""))
2544    (use (match_operand:GPR 2 "reg_or_cint_operand" ""))]
2545   ""
2546   "
2547 {
2548   int i;
2549   rtx temp1;
2550   rtx temp2;
2551
2552   if (GET_CODE (operands[2]) != CONST_INT
2553       || INTVAL (operands[2]) <= 0
2554       || (i = exact_log2 (INTVAL (operands[2]))) < 0)
2555     FAIL;
2556
2557   temp1 = gen_reg_rtx (<MODE>mode);
2558   temp2 = gen_reg_rtx (<MODE>mode);
2559
2560   emit_insn (gen_div<mode>3 (temp1, operands[1], operands[2]));
2561   emit_insn (gen_ashl<mode>3 (temp2, temp1, GEN_INT (i)));
2562   emit_insn (gen_sub<mode>3 (operands[0], operands[1], temp2));
2563   DONE;
2564 }")
2565
2566 (define_insn ""
2567   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2568         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2569                  (match_operand:GPR 2 "exact_log2_cint_operand" "N")))]
2570   ""
2571   "{srai|sra<wd>i} %0,%1,%p2\;{aze|addze} %0,%0"
2572   [(set_attr "type" "two")
2573    (set_attr "length" "8")])
2574
2575 (define_insn ""
2576   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2577         (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
2578                            (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
2579                     (const_int 0)))
2580    (clobber (match_scratch:P 3 "=r,r"))]
2581   ""
2582   "@
2583    {srai|sra<wd>i} %3,%1,%p2\;{aze.|addze.} %3,%3
2584    #"
2585   [(set_attr "type" "compare")
2586    (set_attr "length" "8,12")])
2587
2588 (define_split
2589   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2590         (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2591                              (match_operand:GPR 2 "exact_log2_cint_operand"
2592                               ""))
2593                     (const_int 0)))
2594    (clobber (match_scratch:GPR 3 ""))]
2595   "reload_completed"
2596   [(set (match_dup 3)
2597         (div:<MODE> (match_dup 1) (match_dup 2)))
2598    (set (match_dup 0)
2599         (compare:CC (match_dup 3)
2600                     (const_int 0)))]
2601   "")
2602
2603 (define_insn ""
2604   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2605         (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
2606                            (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
2607                     (const_int 0)))
2608    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2609         (div:P (match_dup 1) (match_dup 2)))]
2610   ""
2611   "@
2612    {srai|sra<wd>i} %0,%1,%p2\;{aze.|addze.} %0,%0
2613    #"
2614   [(set_attr "type" "compare")
2615    (set_attr "length" "8,12")])
2616
2617 (define_split
2618   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2619         (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2620                              (match_operand:GPR 2 "exact_log2_cint_operand"
2621                               ""))
2622                     (const_int 0)))
2623    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2624         (div:GPR (match_dup 1) (match_dup 2)))]
2625   "reload_completed"
2626   [(set (match_dup 0)
2627         (div:<MODE> (match_dup 1) (match_dup 2)))
2628    (set (match_dup 3)
2629         (compare:CC (match_dup 0)
2630                     (const_int 0)))]
2631   "")
2632
2633 (define_insn ""
2634   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2635         (udiv:SI
2636          (plus:DI (ashift:DI
2637                    (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
2638                    (const_int 32))
2639                   (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
2640          (match_operand:SI 3 "gpc_reg_operand" "r")))
2641    (set (match_operand:SI 2 "register_operand" "=*q")
2642         (umod:SI
2643          (plus:DI (ashift:DI
2644                    (zero_extend:DI (match_dup 1)) (const_int 32))
2645                   (zero_extend:DI (match_dup 4)))
2646          (match_dup 3)))]
2647   "TARGET_POWER"
2648   "div %0,%1,%3"
2649   [(set_attr "type" "idiv")])
2650
2651 ;; To do unsigned divide we handle the cases of the divisor looking like a
2652 ;; negative number.  If it is a constant that is less than 2**31, we don't
2653 ;; have to worry about the branches.  So make a few subroutines here.
2654 ;;
2655 ;; First comes the normal case.
2656 (define_expand "udivmodsi4_normal"
2657   [(set (match_dup 4) (const_int 0))
2658    (parallel [(set (match_operand:SI 0 "" "")
2659                    (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2660                                                 (const_int 32))
2661                                      (zero_extend:DI (match_operand:SI 1 "" "")))
2662                             (match_operand:SI 2 "" "")))
2663               (set (match_operand:SI 3 "" "")
2664                    (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2665                                                 (const_int 32))
2666                                      (zero_extend:DI (match_dup 1)))
2667                             (match_dup 2)))])]
2668   "TARGET_POWER"
2669   "
2670 { operands[4] = gen_reg_rtx (SImode); }")
2671
2672 ;; This handles the branches.
2673 (define_expand "udivmodsi4_tests"
2674   [(set (match_operand:SI 0 "" "") (const_int 0))
2675    (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
2676    (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
2677    (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
2678                            (label_ref (match_operand:SI 4 "" "")) (pc)))
2679    (set (match_dup 0) (const_int 1))
2680    (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
2681    (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
2682    (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
2683                            (label_ref (match_dup 4)) (pc)))]
2684   "TARGET_POWER"
2685   "
2686 { operands[5] = gen_reg_rtx (CCUNSmode);
2687   operands[6] = gen_reg_rtx (CCmode);
2688 }")
2689
2690 (define_expand "udivmodsi4"
2691   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2692                    (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
2693                             (match_operand:SI 2 "reg_or_cint_operand" "")))
2694               (set (match_operand:SI 3 "gpc_reg_operand" "")
2695                    (umod:SI (match_dup 1) (match_dup 2)))])]
2696   ""
2697   "
2698 {
2699   rtx label = 0;
2700
2701   if (! TARGET_POWER)
2702     {
2703       if (! TARGET_POWERPC)
2704         {
2705           emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2706           emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2707           emit_insn (gen_divus_call ());
2708           emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2709           emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2710           DONE;
2711         }
2712       else
2713         FAIL;
2714     }
2715
2716   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
2717     {
2718       operands[2] = force_reg (SImode, operands[2]);
2719       label = gen_label_rtx ();
2720       emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
2721                                   operands[3], label));
2722     }
2723   else
2724     operands[2] = force_reg (SImode, operands[2]);
2725
2726   emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
2727                                operands[3]));
2728   if (label)
2729     emit_label (label);
2730
2731   DONE;
2732 }")
2733
2734 ;; AIX architecture-independent common-mode multiply (DImode),
2735 ;; divide/modulus, and quotient subroutine calls.  Input operands in R3 and
2736 ;; R4; results in R3 and sometimes R4; link register always clobbered by bla
2737 ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
2738 ;; assumed unused if generating common-mode, so ignore.
2739 (define_insn "mulh_call"
2740   [(set (reg:SI 3)
2741         (truncate:SI
2742          (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
2743                                (sign_extend:DI (reg:SI 4)))
2744                       (const_int 32))))
2745    (clobber (reg:SI LR_REGNO))]
2746   "! TARGET_POWER && ! TARGET_POWERPC"
2747   "bla __mulh"
2748   [(set_attr "type" "imul")])
2749
2750 (define_insn "mull_call"
2751   [(set (reg:DI 3)
2752         (mult:DI (sign_extend:DI (reg:SI 3))
2753                  (sign_extend:DI (reg:SI 4))))
2754    (clobber (reg:SI LR_REGNO))
2755    (clobber (reg:SI 0))]
2756   "! TARGET_POWER && ! TARGET_POWERPC"
2757   "bla __mull"
2758   [(set_attr "type" "imul")])
2759
2760 (define_insn "divss_call"
2761   [(set (reg:SI 3)
2762         (div:SI (reg:SI 3) (reg:SI 4)))
2763    (set (reg:SI 4)
2764         (mod:SI (reg:SI 3) (reg:SI 4)))
2765    (clobber (reg:SI LR_REGNO))
2766    (clobber (reg:SI 0))]
2767   "! TARGET_POWER && ! TARGET_POWERPC"
2768   "bla __divss"
2769   [(set_attr "type" "idiv")])
2770
2771 (define_insn "divus_call"
2772   [(set (reg:SI 3)
2773         (udiv:SI (reg:SI 3) (reg:SI 4)))
2774    (set (reg:SI 4)
2775         (umod:SI (reg:SI 3) (reg:SI 4)))
2776    (clobber (reg:SI LR_REGNO))
2777    (clobber (reg:SI 0))
2778    (clobber (match_scratch:CC 0 "=x"))
2779    (clobber (reg:CC CR1_REGNO))]
2780   "! TARGET_POWER && ! TARGET_POWERPC"
2781   "bla __divus"
2782   [(set_attr "type" "idiv")])
2783
2784 (define_insn "quoss_call"
2785   [(set (reg:SI 3)
2786         (div:SI (reg:SI 3) (reg:SI 4)))
2787    (clobber (reg:SI LR_REGNO))]
2788   "! TARGET_POWER && ! TARGET_POWERPC"
2789   "bla __quoss"
2790   [(set_attr "type" "idiv")])
2791
2792 (define_insn "quous_call"
2793   [(set (reg:SI 3)
2794         (udiv:SI (reg:SI 3) (reg:SI 4)))
2795    (clobber (reg:SI LR_REGNO))
2796    (clobber (reg:SI 0))
2797    (clobber (match_scratch:CC 0 "=x"))
2798    (clobber (reg:CC CR1_REGNO))]
2799   "! TARGET_POWER && ! TARGET_POWERPC"
2800   "bla __quous"
2801   [(set_attr "type" "idiv")])
2802 \f
2803 ;; Logical instructions
2804 ;; The logical instructions are mostly combined by using match_operator,
2805 ;; but the plain AND insns are somewhat different because there is no
2806 ;; plain 'andi' (only 'andi.'), no plain 'andis', and there are all
2807 ;; those rotate-and-mask operations.  Thus, the AND insns come first.
2808
2809 (define_insn "andsi3"
2810   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
2811         (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
2812                 (match_operand:SI 2 "and_operand" "?r,T,K,L")))
2813    (clobber (match_scratch:CC 3 "=X,X,x,x"))]
2814   ""
2815   "@
2816    and %0,%1,%2
2817    {rlinm|rlwinm} %0,%1,0,%m2,%M2
2818    {andil.|andi.} %0,%1,%b2
2819    {andiu.|andis.} %0,%1,%u2"
2820   [(set_attr "type" "*,*,compare,compare")])
2821
2822 ;; Note to set cr's other than cr0 we do the and immediate and then
2823 ;; the test again -- this avoids a mfcr which on the higher end
2824 ;; machines causes an execution serialization
2825
2826 (define_insn "*andsi3_internal2"
2827   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2828         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2829                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2830                     (const_int 0)))
2831    (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2832    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2833   "TARGET_32BIT"
2834   "@
2835    and. %3,%1,%2
2836    {andil.|andi.} %3,%1,%b2
2837    {andiu.|andis.} %3,%1,%u2
2838    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2839    #
2840    #
2841    #
2842    #"
2843   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2844    (set_attr "length" "4,4,4,4,8,8,8,8")])
2845
2846 (define_insn "*andsi3_internal3"
2847   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2848         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2849                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2850                     (const_int 0)))
2851    (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2852    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2853   "TARGET_64BIT"
2854   "@
2855    #
2856    {andil.|andi.} %3,%1,%b2
2857    {andiu.|andis.} %3,%1,%u2
2858    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2859    #
2860    #
2861    #
2862    #"
2863   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2864    (set_attr "length" "8,4,4,4,8,8,8,8")])
2865
2866 (define_split
2867   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2868         (compare:CC (and:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2869                              (match_operand:GPR 2 "and_operand" ""))
2870                     (const_int 0)))
2871    (clobber (match_scratch:GPR 3 ""))
2872    (clobber (match_scratch:CC 4 ""))]
2873   "reload_completed"
2874   [(parallel [(set (match_dup 3)
2875                    (and:<MODE> (match_dup 1)
2876                                (match_dup 2)))
2877               (clobber (match_dup 4))])
2878    (set (match_dup 0)
2879         (compare:CC (match_dup 3)
2880                     (const_int 0)))]
2881   "")
2882
2883 ;; We don't have a 32 bit "and. rt,ra,rb" for ppc64.  cr is set from the
2884 ;; whole 64 bit reg, and we don't know what is in the high 32 bits.
2885
2886 (define_split
2887   [(set (match_operand:CC 0 "cc_reg_operand" "")
2888         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2889                             (match_operand:SI 2 "gpc_reg_operand" ""))
2890                     (const_int 0)))
2891    (clobber (match_scratch:SI 3 ""))
2892    (clobber (match_scratch:CC 4 ""))]
2893   "TARGET_POWERPC64 && reload_completed"
2894   [(parallel [(set (match_dup 3)
2895                    (and:SI (match_dup 1)
2896                            (match_dup 2)))
2897               (clobber (match_dup 4))])
2898    (set (match_dup 0)
2899         (compare:CC (match_dup 3)
2900                     (const_int 0)))]
2901   "")
2902
2903 (define_insn "*andsi3_internal4"
2904   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2905         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2906                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2907                     (const_int 0)))
2908    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2909         (and:SI (match_dup 1)
2910                 (match_dup 2)))
2911    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2912   "TARGET_32BIT"
2913   "@
2914    and. %0,%1,%2
2915    {andil.|andi.} %0,%1,%b2
2916    {andiu.|andis.} %0,%1,%u2
2917    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2918    #
2919    #
2920    #
2921    #"
2922   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2923    (set_attr "length" "4,4,4,4,8,8,8,8")])
2924
2925 (define_insn "*andsi3_internal5"
2926   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2927         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2928                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2929                     (const_int 0)))
2930    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2931         (and:SI (match_dup 1)
2932                 (match_dup 2)))
2933    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2934   "TARGET_64BIT"
2935   "@
2936    #
2937    {andil.|andi.} %0,%1,%b2
2938    {andiu.|andis.} %0,%1,%u2
2939    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2940    #
2941    #
2942    #
2943    #"
2944   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2945    (set_attr "length" "8,4,4,4,8,8,8,8")])
2946
2947 (define_split
2948   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2949         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2950                             (match_operand:SI 2 "and_operand" ""))
2951                     (const_int 0)))
2952    (set (match_operand:SI 0 "gpc_reg_operand" "")
2953         (and:SI (match_dup 1)
2954                 (match_dup 2)))
2955    (clobber (match_scratch:CC 4 ""))]
2956   "reload_completed"
2957   [(parallel [(set (match_dup 0)
2958                    (and:SI (match_dup 1)
2959                            (match_dup 2)))
2960               (clobber (match_dup 4))])
2961    (set (match_dup 3)
2962         (compare:CC (match_dup 0)
2963                     (const_int 0)))]
2964   "")
2965
2966 (define_split
2967   [(set (match_operand:CC 3 "cc_reg_operand" "")
2968         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2969                             (match_operand:SI 2 "gpc_reg_operand" ""))
2970                     (const_int 0)))
2971    (set (match_operand:SI 0 "gpc_reg_operand" "")
2972         (and:SI (match_dup 1)
2973                 (match_dup 2)))
2974    (clobber (match_scratch:CC 4 ""))]
2975   "TARGET_POWERPC64 && reload_completed"
2976   [(parallel [(set (match_dup 0)
2977                    (and:SI (match_dup 1)
2978                            (match_dup 2)))
2979               (clobber (match_dup 4))])
2980    (set (match_dup 3)
2981         (compare:CC (match_dup 0)
2982                     (const_int 0)))]
2983   "")
2984
2985 ;; Handle the PowerPC64 rlwinm corner case
2986
2987 (define_insn_and_split "*andsi3_internal6"
2988   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2989         (and:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2990                 (match_operand:SI 2 "mask_operand_wrap" "i")))]
2991   "TARGET_POWERPC64"
2992   "#"
2993   "TARGET_POWERPC64"
2994   [(set (match_dup 0)
2995         (and:SI (rotate:SI (match_dup 1) (match_dup 3))
2996                 (match_dup 4)))
2997    (set (match_dup 0)
2998         (rotate:SI (match_dup 0) (match_dup 5)))]
2999   "
3000 {
3001   int mb = extract_MB (operands[2]);
3002   int me = extract_ME (operands[2]);
3003   operands[3] = GEN_INT (me + 1);
3004   operands[5] = GEN_INT (32 - (me + 1));
3005   operands[4] = GEN_INT (~((HOST_WIDE_INT) -1 << (33 + me - mb)));
3006 }"
3007   [(set_attr "length" "8")])
3008
3009 (define_expand "iorsi3"
3010   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3011         (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
3012                 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
3013   ""
3014   "
3015 {
3016   if (GET_CODE (operands[2]) == CONST_INT
3017       && ! logical_operand (operands[2], SImode))
3018     {
3019       HOST_WIDE_INT value = INTVAL (operands[2]);
3020       rtx tmp = ((!can_create_pseudo_p ()
3021                   || rtx_equal_p (operands[0], operands[1]))
3022                  ? operands[0] : gen_reg_rtx (SImode));
3023
3024       emit_insn (gen_iorsi3 (tmp, operands[1],
3025                              GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
3026       emit_insn (gen_iorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
3027       DONE;
3028     }
3029 }")
3030
3031 (define_expand "xorsi3"
3032   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3033         (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
3034                 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
3035   ""
3036   "
3037 {
3038   if (GET_CODE (operands[2]) == CONST_INT
3039       && ! logical_operand (operands[2], SImode))
3040     {
3041       HOST_WIDE_INT value = INTVAL (operands[2]);
3042       rtx tmp = ((!can_create_pseudo_p ()
3043                   || rtx_equal_p (operands[0], operands[1]))
3044                  ? operands[0] : gen_reg_rtx (SImode));
3045
3046       emit_insn (gen_xorsi3 (tmp, operands[1],
3047                              GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
3048       emit_insn (gen_xorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
3049       DONE;
3050     }
3051 }")
3052
3053 (define_insn "*boolsi3_internal1"
3054   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
3055         (match_operator:SI 3 "boolean_or_operator"
3056          [(match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
3057           (match_operand:SI 2 "logical_operand" "r,K,L")]))]
3058   ""
3059   "@
3060    %q3 %0,%1,%2
3061    {%q3il|%q3i} %0,%1,%b2
3062    {%q3iu|%q3is} %0,%1,%u2")
3063
3064 (define_insn "*boolsi3_internal2"
3065   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3066         (compare:CC (match_operator:SI 4 "boolean_or_operator"
3067          [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3068           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3069          (const_int 0)))
3070    (clobber (match_scratch:SI 3 "=r,r"))]
3071   "TARGET_32BIT"
3072   "@
3073    %q4. %3,%1,%2
3074    #"
3075   [(set_attr "type" "compare")
3076    (set_attr "length" "4,8")])
3077
3078 (define_split
3079   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3080         (compare:CC (match_operator:SI 4 "boolean_operator"
3081          [(match_operand:SI 1 "gpc_reg_operand" "")
3082           (match_operand:SI 2 "gpc_reg_operand" "")])
3083          (const_int 0)))
3084    (clobber (match_scratch:SI 3 ""))]
3085   "TARGET_32BIT && reload_completed"
3086   [(set (match_dup 3) (match_dup 4))
3087    (set (match_dup 0)
3088         (compare:CC (match_dup 3)
3089                     (const_int 0)))]
3090   "")
3091
3092 (define_insn "*boolsi3_internal3"
3093   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3094         (compare:CC (match_operator:SI 4 "boolean_operator"
3095          [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3096           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3097          (const_int 0)))
3098    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3099         (match_dup 4))]
3100   "TARGET_32BIT"
3101   "@
3102    %q4. %0,%1,%2
3103    #"
3104   [(set_attr "type" "compare")
3105    (set_attr "length" "4,8")])
3106
3107 (define_split
3108   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3109         (compare:CC (match_operator:SI 4 "boolean_operator"
3110          [(match_operand:SI 1 "gpc_reg_operand" "")
3111           (match_operand:SI 2 "gpc_reg_operand" "")])
3112          (const_int 0)))
3113    (set (match_operand:SI 0 "gpc_reg_operand" "")
3114         (match_dup 4))]
3115   "TARGET_32BIT && reload_completed"
3116   [(set (match_dup 0) (match_dup 4))
3117    (set (match_dup 3)
3118         (compare:CC (match_dup 0)
3119                     (const_int 0)))]
3120   "")
3121
3122 ;; Split a logical operation that we can't do in one insn into two insns,
3123 ;; each of which does one 16-bit part.  This is used by combine.
3124
3125 (define_split
3126   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3127         (match_operator:SI 3 "boolean_or_operator"
3128          [(match_operand:SI 1 "gpc_reg_operand" "")
3129           (match_operand:SI 2 "non_logical_cint_operand" "")]))]
3130   ""
3131   [(set (match_dup 0) (match_dup 4))
3132    (set (match_dup 0) (match_dup 5))]
3133 "
3134 {
3135   rtx i;
3136   i = GEN_INT (INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
3137   operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3138                                 operands[1], i);
3139   i = GEN_INT (INTVAL (operands[2]) & 0xffff);
3140   operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3141                                 operands[0], i);
3142 }")
3143
3144 (define_insn "*boolcsi3_internal1"
3145   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3146         (match_operator:SI 3 "boolean_operator"
3147          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3148           (match_operand:SI 2 "gpc_reg_operand" "r")]))]
3149   ""
3150   "%q3 %0,%2,%1")
3151
3152 (define_insn "*boolcsi3_internal2"
3153   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3154         (compare:CC (match_operator:SI 4 "boolean_operator"
3155          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3156           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3157          (const_int 0)))
3158    (clobber (match_scratch:SI 3 "=r,r"))]
3159   "TARGET_32BIT"
3160   "@
3161    %q4. %3,%2,%1
3162    #"
3163   [(set_attr "type" "compare")
3164    (set_attr "length" "4,8")])
3165
3166 (define_split
3167   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3168         (compare:CC (match_operator:SI 4 "boolean_operator"
3169          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3170           (match_operand:SI 2 "gpc_reg_operand" "")])
3171          (const_int 0)))
3172    (clobber (match_scratch:SI 3 ""))]
3173   "TARGET_32BIT && reload_completed"
3174   [(set (match_dup 3) (match_dup 4))
3175    (set (match_dup 0)
3176         (compare:CC (match_dup 3)
3177                     (const_int 0)))]
3178   "")
3179
3180 (define_insn "*boolcsi3_internal3"
3181   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3182         (compare:CC (match_operator:SI 4 "boolean_operator"
3183          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3184           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3185          (const_int 0)))
3186    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3187         (match_dup 4))]
3188   "TARGET_32BIT"
3189   "@
3190    %q4. %0,%2,%1
3191    #"
3192   [(set_attr "type" "compare")
3193    (set_attr "length" "4,8")])
3194
3195 (define_split
3196   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3197         (compare:CC (match_operator:SI 4 "boolean_operator"
3198          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3199           (match_operand:SI 2 "gpc_reg_operand" "")])
3200          (const_int 0)))
3201    (set (match_operand:SI 0 "gpc_reg_operand" "")
3202         (match_dup 4))]
3203   "TARGET_32BIT && reload_completed"
3204   [(set (match_dup 0) (match_dup 4))
3205    (set (match_dup 3)
3206         (compare:CC (match_dup 0)
3207                     (const_int 0)))]
3208   "")
3209
3210 (define_insn "*boolccsi3_internal1"
3211   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3212         (match_operator:SI 3 "boolean_operator"
3213          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3214           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))]))]
3215   ""
3216   "%q3 %0,%1,%2")
3217
3218 (define_insn "*boolccsi3_internal2"
3219   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3220         (compare:CC (match_operator:SI 4 "boolean_operator"
3221          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3222           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3223          (const_int 0)))
3224    (clobber (match_scratch:SI 3 "=r,r"))]
3225   "TARGET_32BIT"
3226   "@
3227    %q4. %3,%1,%2
3228    #"
3229   [(set_attr "type" "compare")
3230    (set_attr "length" "4,8")])
3231
3232 (define_split
3233   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3234         (compare:CC (match_operator:SI 4 "boolean_operator"
3235          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3236           (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3237          (const_int 0)))
3238    (clobber (match_scratch:SI 3 ""))]
3239   "TARGET_32BIT && reload_completed"
3240   [(set (match_dup 3) (match_dup 4))
3241    (set (match_dup 0)
3242         (compare:CC (match_dup 3)
3243                     (const_int 0)))]
3244   "")
3245
3246 (define_insn "*boolccsi3_internal3"
3247   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3248         (compare:CC (match_operator:SI 4 "boolean_operator"
3249          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3250           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3251          (const_int 0)))
3252    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3253         (match_dup 4))]
3254   "TARGET_32BIT"
3255   "@
3256    %q4. %0,%1,%2
3257    #"
3258   [(set_attr "type" "compare")
3259    (set_attr "length" "4,8")])
3260
3261 (define_split
3262   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3263         (compare:CC (match_operator:SI 4 "boolean_operator"
3264          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3265           (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3266          (const_int 0)))
3267    (set (match_operand:SI 0 "gpc_reg_operand" "")
3268         (match_dup 4))]
3269   "TARGET_32BIT && reload_completed"
3270   [(set (match_dup 0) (match_dup 4))
3271    (set (match_dup 3)
3272         (compare:CC (match_dup 0)
3273                     (const_int 0)))]
3274   "")
3275
3276 ;; maskir insn.  We need four forms because things might be in arbitrary
3277 ;; orde