OSDN Git Service

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