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