OSDN Git Service

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