OSDN Git Service

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