OSDN Git Service

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