OSDN Git Service

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