OSDN Git Service

* config/rs6000/rs6000.c (create_TOC_reference): Wrap high part
[pf3gnuchains/gcc-fork.git] / 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