OSDN Git Service

1157c4e2ee349a12704896f24d29eb555abadade
[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 = ((!can_create_pseudo_p ()
1472                   || rtx_equal_p (operands[0], operands[1]))
1473                  ? operands[0] : gen_reg_rtx (<MODE>mode));
1474
1475       HOST_WIDE_INT val = INTVAL (operands[2]);
1476       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1477       HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1478
1479       if (<MODE>mode == DImode && !satisfies_constraint_L (GEN_INT (rest)))
1480         FAIL;
1481
1482       /* The ordering here is important for the prolog expander.
1483          When space is allocated from the stack, adding 'low' first may
1484          produce a temporary deallocation (which would be bad).  */
1485       emit_insn (gen_add<mode>3 (tmp, operands[1], GEN_INT (rest)));
1486       emit_insn (gen_add<mode>3 (operands[0], tmp, GEN_INT (low)));
1487       DONE;
1488     }
1489 })
1490
1491 ;; Discourage ai/addic because of carry but provide it in an alternative
1492 ;; allowing register zero as source.
1493 (define_insn "*add<mode>3_internal1"
1494   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r,?r,r")
1495         (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "%r,b,r,b")
1496                   (match_operand:GPR 2 "add_operand" "r,I,I,L")))]
1497   "!DECIMAL_FLOAT_MODE_P (GET_MODE (operands[0])) && !DECIMAL_FLOAT_MODE_P (GET_MODE (operands[1]))"
1498   "@
1499    {cax|add} %0,%1,%2
1500    {cal %0,%2(%1)|addi %0,%1,%2}
1501    {ai|addic} %0,%1,%2
1502    {cau|addis} %0,%1,%v2"
1503   [(set_attr "length" "4,4,4,4")])
1504
1505 (define_insn "addsi3_high"
1506   [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
1507         (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
1508                  (high:SI (match_operand 2 "" ""))))]
1509   "TARGET_MACHO && !TARGET_64BIT"
1510   "{cau|addis} %0,%1,ha16(%2)"
1511   [(set_attr "length" "4")])
1512
1513 (define_insn "*add<mode>3_internal2"
1514   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
1515         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1516                             (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1517                     (const_int 0)))
1518    (clobber (match_scratch:P 3 "=r,r,r,r"))]
1519   ""
1520   "@
1521    {cax.|add.} %3,%1,%2
1522    {ai.|addic.} %3,%1,%2
1523    #
1524    #"
1525   [(set_attr "type" "fast_compare,compare,compare,compare")
1526    (set_attr "length" "4,4,8,8")])
1527
1528 (define_split
1529   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1530         (compare:CC (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1531                               (match_operand:GPR 2 "reg_or_short_operand" ""))
1532                     (const_int 0)))
1533    (clobber (match_scratch:GPR 3 ""))]
1534   "reload_completed"
1535   [(set (match_dup 3)
1536         (plus:GPR (match_dup 1)
1537                  (match_dup 2)))
1538    (set (match_dup 0)
1539         (compare:CC (match_dup 3)
1540                     (const_int 0)))]
1541   "")
1542
1543 (define_insn "*add<mode>3_internal3"
1544   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,?y,?y")
1545         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "%r,r,r,r")
1546                             (match_operand:P 2 "reg_or_short_operand" "r,I,r,I"))
1547                     (const_int 0)))
1548    (set (match_operand:P 0 "gpc_reg_operand" "=r,r,r,r")
1549         (plus:P (match_dup 1)
1550                 (match_dup 2)))]
1551   ""
1552   "@
1553    {cax.|add.} %0,%1,%2
1554    {ai.|addic.} %0,%1,%2
1555    #
1556    #"
1557   [(set_attr "type" "fast_compare,compare,compare,compare")
1558    (set_attr "length" "4,4,8,8")])
1559
1560 (define_split
1561   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1562         (compare:CC (plus:P (match_operand:P 1 "gpc_reg_operand" "")
1563                             (match_operand:P 2 "reg_or_short_operand" ""))
1564                     (const_int 0)))
1565    (set (match_operand:P 0 "gpc_reg_operand" "")
1566         (plus:P (match_dup 1) (match_dup 2)))]
1567   "reload_completed"
1568   [(set (match_dup 0)
1569         (plus:P (match_dup 1)
1570                 (match_dup 2)))
1571    (set (match_dup 3)
1572         (compare:CC (match_dup 0)
1573                     (const_int 0)))]
1574   "")
1575
1576 ;; Split an add that we can't do in one insn into two insns, each of which
1577 ;; does one 16-bit part.  This is used by combine.  Note that the low-order
1578 ;; add should be last in case the result gets used in an address.
1579
1580 (define_split
1581   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
1582         (plus:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
1583                   (match_operand:GPR 2 "non_add_cint_operand" "")))]
1584   ""
1585   [(set (match_dup 0) (plus:GPR (match_dup 1) (match_dup 3)))
1586    (set (match_dup 0) (plus:GPR (match_dup 0) (match_dup 4)))]
1587 {
1588   HOST_WIDE_INT val = INTVAL (operands[2]);
1589   HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1590   HOST_WIDE_INT rest = trunc_int_for_mode (val - low, <MODE>mode);
1591
1592   operands[4] = GEN_INT (low);
1593   if (<MODE>mode == SImode || satisfies_constraint_L (GEN_INT (rest)))
1594     operands[3] = GEN_INT (rest);
1595   else if (can_create_pseudo_p ())
1596     {
1597       operands[3] = gen_reg_rtx (DImode);
1598       emit_move_insn (operands[3], operands[2]);
1599       emit_insn (gen_adddi3 (operands[0], operands[1], operands[3]));
1600       DONE;
1601     }
1602   else
1603     FAIL;
1604 })
1605
1606 (define_insn "one_cmpl<mode>2"
1607   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
1608         (not:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
1609   ""
1610   "nor %0,%1,%1")
1611
1612 (define_insn ""
1613   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1614         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1615                     (const_int 0)))
1616    (clobber (match_scratch:P 2 "=r,r"))]
1617   ""
1618   "@
1619    nor. %2,%1,%1
1620    #"
1621   [(set_attr "type" "compare")
1622    (set_attr "length" "4,8")])
1623
1624 (define_split
1625   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1626         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1627                     (const_int 0)))
1628    (clobber (match_scratch:P 2 ""))]
1629   "reload_completed"
1630   [(set (match_dup 2)
1631         (not:P (match_dup 1)))
1632    (set (match_dup 0)
1633         (compare:CC (match_dup 2)
1634                     (const_int 0)))]
1635   "")
1636
1637 (define_insn ""
1638   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
1639         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
1640                     (const_int 0)))
1641    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1642         (not:P (match_dup 1)))]
1643   ""
1644   "@
1645    nor. %0,%1,%1
1646    #"
1647   [(set_attr "type" "compare")
1648    (set_attr "length" "4,8")])
1649
1650 (define_split
1651   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
1652         (compare:CC (not:P (match_operand:P 1 "gpc_reg_operand" ""))
1653                     (const_int 0)))
1654    (set (match_operand:P 0 "gpc_reg_operand" "")
1655         (not:P (match_dup 1)))]
1656   "reload_completed"
1657   [(set (match_dup 0)
1658         (not:P (match_dup 1)))
1659    (set (match_dup 2)
1660         (compare:CC (match_dup 0)
1661                     (const_int 0)))]
1662   "")
1663
1664 (define_insn ""
1665   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1666         (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
1667                   (match_operand:SI 2 "gpc_reg_operand" "r")))]
1668   "! TARGET_POWERPC"
1669   "{sf%I1|subf%I1c} %0,%2,%1")
1670
1671 (define_insn ""
1672   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r,r")
1673         (minus:GPR (match_operand:GPR 1 "reg_or_short_operand" "r,I")
1674                    (match_operand:GPR 2 "gpc_reg_operand" "r,r")))]
1675   "TARGET_POWERPC"
1676   "@
1677    subf %0,%2,%1
1678    subfic %0,%2,%1")
1679
1680 (define_insn ""
1681   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1682         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1683                               (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1684                     (const_int 0)))
1685    (clobber (match_scratch:SI 3 "=r,r"))]
1686   "! TARGET_POWERPC"
1687   "@
1688    {sf.|subfc.} %3,%2,%1
1689    #"
1690   [(set_attr "type" "compare")
1691    (set_attr "length" "4,8")])
1692
1693 (define_insn ""
1694   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1695         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1696                              (match_operand:P 2 "gpc_reg_operand" "r,r"))
1697                     (const_int 0)))
1698    (clobber (match_scratch:P 3 "=r,r"))]
1699   "TARGET_POWERPC"
1700   "@
1701    subf. %3,%2,%1
1702    #"
1703   [(set_attr "type" "fast_compare")
1704    (set_attr "length" "4,8")])
1705
1706 (define_split
1707   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1708         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1709                              (match_operand:P 2 "gpc_reg_operand" ""))
1710                     (const_int 0)))
1711    (clobber (match_scratch:P 3 ""))]
1712   "reload_completed"
1713   [(set (match_dup 3)
1714         (minus:P (match_dup 1)
1715                   (match_dup 2)))
1716    (set (match_dup 0)
1717         (compare:CC (match_dup 3)
1718                     (const_int 0)))]
1719   "")
1720
1721 (define_insn ""
1722   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1723         (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
1724                               (match_operand:SI 2 "gpc_reg_operand" "r,r"))
1725                     (const_int 0)))
1726    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1727         (minus:SI (match_dup 1) (match_dup 2)))]
1728   "! TARGET_POWERPC"
1729   "@
1730    {sf.|subfc.} %0,%2,%1
1731    #"
1732   [(set_attr "type" "compare")
1733    (set_attr "length" "4,8")])
1734
1735 (define_insn ""
1736   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1737         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "r,r")
1738                              (match_operand:P 2 "gpc_reg_operand" "r,r"))
1739                     (const_int 0)))
1740    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
1741         (minus:P (match_dup 1)
1742                   (match_dup 2)))]
1743   "TARGET_POWERPC"
1744   "@
1745    subf. %0,%2,%1
1746    #"
1747   [(set_attr "type" "fast_compare")
1748    (set_attr "length" "4,8")])
1749
1750 (define_split
1751   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1752         (compare:CC (minus:P (match_operand:P 1 "gpc_reg_operand" "")
1753                              (match_operand:P 2 "gpc_reg_operand" ""))
1754                     (const_int 0)))
1755    (set (match_operand:P 0 "gpc_reg_operand" "")
1756         (minus:P (match_dup 1)
1757                   (match_dup 2)))]
1758   "reload_completed"
1759   [(set (match_dup 0)
1760         (minus:P (match_dup 1)
1761                   (match_dup 2)))
1762    (set (match_dup 3)
1763         (compare:CC (match_dup 0)
1764                     (const_int 0)))]
1765   "")
1766
1767 (define_expand "sub<mode>3"
1768   [(set (match_operand:SDI 0 "gpc_reg_operand" "")
1769         (minus:SDI (match_operand:SDI 1 "reg_or_short_operand" "")
1770                    (match_operand:SDI 2 "reg_or_sub_cint_operand" "")))]
1771   ""
1772   "
1773 {
1774   if (GET_CODE (operands[2]) == CONST_INT)
1775     {
1776       emit_insn (gen_add<mode>3 (operands[0], operands[1],
1777                                  negate_rtx (<MODE>mode, operands[2])));
1778       DONE;
1779     }
1780 }")
1781
1782 ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
1783 ;; instruction and some auxiliary computations.  Then we just have a single
1784 ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
1785 ;; combine.
1786
1787 (define_expand "sminsi3"
1788   [(set (match_dup 3)
1789         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1790                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1791                          (const_int 0)
1792                          (minus:SI (match_dup 2) (match_dup 1))))
1793    (set (match_operand:SI 0 "gpc_reg_operand" "")
1794         (minus:SI (match_dup 2) (match_dup 3)))]
1795   "TARGET_POWER || TARGET_ISEL"
1796   "
1797 {
1798   if (TARGET_ISEL)
1799     {
1800       operands[2] = force_reg (SImode, operands[2]);
1801       rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]);
1802       DONE;
1803     }
1804
1805   operands[3] = gen_reg_rtx (SImode);
1806 }")
1807
1808 (define_split
1809   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1810         (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
1811                  (match_operand:SI 2 "reg_or_short_operand" "")))
1812    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1813   "TARGET_POWER"
1814   [(set (match_dup 3)
1815         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1816                          (const_int 0)
1817                          (minus:SI (match_dup 2) (match_dup 1))))
1818    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
1819   "")
1820
1821 (define_expand "smaxsi3"
1822   [(set (match_dup 3)
1823         (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
1824                                 (match_operand:SI 2 "reg_or_short_operand" ""))
1825                          (const_int 0)
1826                          (minus:SI (match_dup 2) (match_dup 1))))
1827    (set (match_operand:SI 0 "gpc_reg_operand" "")
1828         (plus:SI (match_dup 3) (match_dup 1)))]
1829   "TARGET_POWER || TARGET_ISEL"
1830   "
1831 {
1832   if (TARGET_ISEL)
1833     {
1834       operands[2] = force_reg (SImode, operands[2]);
1835       rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]);
1836       DONE;
1837     }
1838   operands[3] = gen_reg_rtx (SImode);
1839 }")
1840
1841 (define_split
1842   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1843         (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
1844                  (match_operand:SI 2 "reg_or_short_operand" "")))
1845    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
1846   "TARGET_POWER"
1847   [(set (match_dup 3)
1848         (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
1849                          (const_int 0)
1850                          (minus:SI (match_dup 2) (match_dup 1))))
1851    (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
1852   "")
1853
1854 (define_expand "uminsi3"
1855   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1856                               (match_dup 5)))
1857    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1858                               (match_dup 5)))
1859    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1860                                        (const_int 0)
1861                                        (minus:SI (match_dup 4) (match_dup 3))))
1862    (set (match_operand:SI 0 "gpc_reg_operand" "")
1863         (minus:SI (match_dup 2) (match_dup 3)))]
1864   "TARGET_POWER || TARGET_ISEL"
1865   "
1866 {
1867   if (TARGET_ISEL)
1868     {
1869       rs6000_emit_minmax (operands[0], UMIN, operands[1], operands[2]);
1870       DONE;
1871     }
1872   operands[3] = gen_reg_rtx (SImode);
1873   operands[4] = gen_reg_rtx (SImode);
1874   operands[5] = GEN_INT (-2147483647 - 1);
1875 }")
1876
1877 (define_expand "umaxsi3"
1878   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
1879                               (match_dup 5)))
1880    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
1881                               (match_dup 5)))
1882    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
1883                                        (const_int 0)
1884                                        (minus:SI (match_dup 4) (match_dup 3))))
1885    (set (match_operand:SI 0 "gpc_reg_operand" "")
1886         (plus:SI (match_dup 3) (match_dup 1)))]
1887   "TARGET_POWER || TARGET_ISEL"
1888   "
1889 {
1890   if (TARGET_ISEL)
1891     {
1892       rs6000_emit_minmax (operands[0], UMAX, operands[1], operands[2]);
1893       DONE;
1894     }
1895   operands[3] = gen_reg_rtx (SImode);
1896   operands[4] = gen_reg_rtx (SImode);
1897   operands[5] = GEN_INT (-2147483647 - 1);
1898 }")
1899
1900 (define_insn ""
1901   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
1902         (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
1903                              (match_operand:SI 2 "reg_or_short_operand" "rI"))
1904                          (const_int 0)
1905                          (minus:SI (match_dup 2) (match_dup 1))))]
1906   "TARGET_POWER"
1907   "doz%I2 %0,%1,%2")
1908
1909 (define_insn ""
1910   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
1911         (compare:CC
1912          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1913                               (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1914                           (const_int 0)
1915                           (minus:SI (match_dup 2) (match_dup 1)))
1916          (const_int 0)))
1917    (clobber (match_scratch:SI 3 "=r,r"))]
1918   "TARGET_POWER"
1919   "@
1920    doz%I2. %3,%1,%2
1921    #"
1922   [(set_attr "type" "delayed_compare")
1923    (set_attr "length" "4,8")])
1924
1925 (define_split
1926   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
1927         (compare:CC
1928          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1929                               (match_operand:SI 2 "reg_or_short_operand" ""))
1930                           (const_int 0)
1931                           (minus:SI (match_dup 2) (match_dup 1)))
1932          (const_int 0)))
1933    (clobber (match_scratch:SI 3 ""))]
1934   "TARGET_POWER && reload_completed"
1935   [(set (match_dup 3)
1936         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1937                           (const_int 0)
1938                           (minus:SI (match_dup 2) (match_dup 1))))
1939    (set (match_dup 0)
1940         (compare:CC (match_dup 3)
1941                     (const_int 0)))]
1942   "")
1943
1944 (define_insn ""
1945   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
1946         (compare:CC
1947          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r,r")
1948                               (match_operand:SI 2 "reg_or_short_operand" "rI,rI"))
1949                           (const_int 0)
1950                           (minus:SI (match_dup 2) (match_dup 1)))
1951          (const_int 0)))
1952    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
1953         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1954                          (const_int 0)
1955                          (minus:SI (match_dup 2) (match_dup 1))))]
1956   "TARGET_POWER"
1957   "@
1958    doz%I2. %0,%1,%2
1959    #"
1960   [(set_attr "type" "delayed_compare")
1961    (set_attr "length" "4,8")])
1962
1963 (define_split
1964   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
1965         (compare:CC
1966          (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "")
1967                               (match_operand:SI 2 "reg_or_short_operand" ""))
1968                           (const_int 0)
1969                           (minus:SI (match_dup 2) (match_dup 1)))
1970          (const_int 0)))
1971    (set (match_operand:SI 0 "gpc_reg_operand" "")
1972         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1973                          (const_int 0)
1974                          (minus:SI (match_dup 2) (match_dup 1))))]
1975   "TARGET_POWER && reload_completed"
1976   [(set (match_dup 0)
1977         (if_then_else:SI (gt (match_dup 1) (match_dup 2))
1978                          (const_int 0)
1979                          (minus:SI (match_dup 2) (match_dup 1))))
1980    (set (match_dup 3)
1981         (compare:CC (match_dup 0)
1982                     (const_int 0)))]
1983   "")
1984
1985 ;; We don't need abs with condition code because such comparisons should
1986 ;; never be done.
1987 (define_expand "abssi2"
1988   [(set (match_operand:SI 0 "gpc_reg_operand" "")
1989         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
1990   ""
1991   "
1992 {
1993   if (TARGET_ISEL)
1994     {
1995       emit_insn (gen_abssi2_isel (operands[0], operands[1]));
1996       DONE;
1997     }
1998   else if (! TARGET_POWER)
1999     {
2000       emit_insn (gen_abssi2_nopower (operands[0], operands[1]));
2001       DONE;
2002     }
2003 }")
2004
2005 (define_insn "*abssi2_power"
2006   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2007         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
2008   "TARGET_POWER"
2009   "abs %0,%1")
2010
2011 (define_insn_and_split "abssi2_isel"
2012   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2013         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "b")))
2014    (clobber (match_scratch:SI 2 "=&b"))
2015    (clobber (match_scratch:CC 3 "=y"))]
2016   "TARGET_ISEL"
2017   "#"
2018   "&& reload_completed"
2019   [(set (match_dup 2) (neg:SI (match_dup 1)))
2020    (set (match_dup 3)
2021         (compare:CC (match_dup 1)
2022                     (const_int 0)))
2023    (set (match_dup 0)
2024         (if_then_else:SI (ge (match_dup 3)
2025                              (const_int 0))
2026                          (match_dup 1)
2027                          (match_dup 2)))]
2028   "")
2029
2030 (define_insn_and_split "abssi2_nopower"
2031   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2032         (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0")))
2033    (clobber (match_scratch:SI 2 "=&r,&r"))]
2034   "! TARGET_POWER && ! TARGET_ISEL"
2035   "#"
2036   "&& reload_completed"
2037   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2038    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2039    (set (match_dup 0) (minus:SI (match_dup 0) (match_dup 2)))]
2040   "")
2041
2042 (define_insn "*nabs_power"
2043   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2044         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
2045   "TARGET_POWER"
2046   "nabs %0,%1")
2047
2048 (define_insn_and_split "*nabs_nopower"
2049   [(set (match_operand:SI 0 "gpc_reg_operand" "=&r,r")
2050         (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r,0"))))
2051    (clobber (match_scratch:SI 2 "=&r,&r"))]
2052   "! TARGET_POWER"
2053   "#"
2054   "&& reload_completed"
2055   [(set (match_dup 2) (ashiftrt:SI (match_dup 1) (const_int 31)))
2056    (set (match_dup 0) (xor:SI (match_dup 2) (match_dup 1)))
2057    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 0)))]
2058   "")
2059
2060 (define_expand "neg<mode>2"
2061   [(set (match_operand:SDI 0 "gpc_reg_operand" "")
2062         (neg:SDI (match_operand:SDI 1 "gpc_reg_operand" "")))]
2063   ""
2064   "")
2065
2066 (define_insn "*neg<mode>2_internal"
2067   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2068         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2069   ""
2070   "neg %0,%1")
2071
2072 (define_insn ""
2073   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2074         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2075                     (const_int 0)))
2076    (clobber (match_scratch:P 2 "=r,r"))]
2077   ""
2078   "@
2079    neg. %2,%1
2080    #"
2081   [(set_attr "type" "fast_compare")
2082    (set_attr "length" "4,8")])
2083
2084 (define_split
2085   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2086         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2087                     (const_int 0)))
2088    (clobber (match_scratch:P 2 ""))]
2089   "reload_completed"
2090   [(set (match_dup 2)
2091         (neg:P (match_dup 1)))
2092    (set (match_dup 0)
2093         (compare:CC (match_dup 2)
2094                     (const_int 0)))]
2095   "")
2096
2097 (define_insn ""
2098   [(set (match_operand:CC 2 "cc_reg_operand" "=x,?y")
2099         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" "r,r"))
2100                     (const_int 0)))
2101    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2102         (neg:P (match_dup 1)))]
2103   ""
2104   "@
2105    neg. %0,%1
2106    #"
2107   [(set_attr "type" "fast_compare")
2108    (set_attr "length" "4,8")])
2109
2110 (define_split
2111   [(set (match_operand:CC 2 "cc_reg_not_cr0_operand" "")
2112         (compare:CC (neg:P (match_operand:P 1 "gpc_reg_operand" ""))
2113                     (const_int 0)))
2114    (set (match_operand:P 0 "gpc_reg_operand" "")
2115         (neg:P (match_dup 1)))]
2116   "reload_completed"
2117   [(set (match_dup 0)
2118         (neg:P (match_dup 1)))
2119    (set (match_dup 2)
2120         (compare:CC (match_dup 0)
2121                     (const_int 0)))]
2122   "")
2123
2124 (define_insn "clz<mode>2"
2125   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2126         (clz:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")))]
2127   ""
2128   "{cntlz|cntlz<wd>} %0,%1"
2129   [(set_attr "type" "cntlz")])
2130
2131 (define_expand "ctz<mode>2"
2132   [(set (match_dup 2)
2133         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2134    (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2135                                           (match_dup 2)))
2136               (clobber (scratch:CC))])
2137    (set (match_dup 4) (clz:GPR (match_dup 3)))
2138    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2139         (minus:GPR (match_dup 5) (match_dup 4)))]
2140   ""
2141   {
2142      operands[2] = gen_reg_rtx (<MODE>mode);
2143      operands[3] = gen_reg_rtx (<MODE>mode);
2144      operands[4] = gen_reg_rtx (<MODE>mode);
2145      operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - 1);
2146   })
2147
2148 (define_expand "ffs<mode>2"
2149   [(set (match_dup 2)
2150         (neg:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))
2151    (parallel [(set (match_dup 3) (and:GPR (match_dup 1)
2152                                           (match_dup 2)))
2153               (clobber (scratch:CC))])
2154    (set (match_dup 4) (clz:GPR (match_dup 3)))
2155    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2156         (minus:GPR (match_dup 5) (match_dup 4)))]
2157   ""
2158   {
2159      operands[2] = gen_reg_rtx (<MODE>mode);
2160      operands[3] = gen_reg_rtx (<MODE>mode);
2161      operands[4] = gen_reg_rtx (<MODE>mode);
2162      operands[5] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode));
2163   })
2164
2165 (define_insn "popcntb<mode>2"
2166   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2167         (unspec:GPR [(match_operand:GPR 1 "gpc_reg_operand" "r")]
2168                      UNSPEC_POPCNTB))]
2169   "TARGET_POPCNTB"
2170   "popcntb %0,%1")
2171
2172 (define_expand "popcount<mode>2"
2173   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2174         (popcount:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2175   "TARGET_POPCNTB"
2176   {
2177     rs6000_emit_popcount (operands[0], operands[1]);
2178     DONE;
2179   })
2180
2181 (define_expand "parity<mode>2"
2182   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2183         (parity:GPR (match_operand:GPR 1 "gpc_reg_operand" "")))]
2184   "TARGET_POPCNTB"
2185   {
2186     rs6000_emit_parity (operands[0], operands[1]);
2187     DONE;
2188   })
2189
2190 (define_insn "bswapsi2"
2191   [(set (match_operand:SI 0 "reg_or_mem_operand" "=r,Z,&r")
2192         (bswap:SI (match_operand:SI 1 "reg_or_mem_operand" "Z,r,r")))]
2193   ""
2194   "@
2195    {lbrx|lwbrx} %0,%y1
2196    {stbrx|stwbrx} %1,%y0
2197    #"
2198   [(set_attr "length" "4,4,12")])
2199
2200 (define_split
2201   [(set (match_operand:SI 0 "gpc_reg_operand" "")
2202         (bswap:SI (match_operand:SI 1 "gpc_reg_operand" "")))]
2203   "reload_completed"
2204   [(set (match_dup 0)
2205         (rotate:SI (match_dup 1) (const_int 8)))
2206    (set (zero_extract:SI (match_dup 0)
2207                          (const_int 8)
2208                          (const_int 0))
2209         (match_dup 1))
2210    (set (zero_extract:SI (match_dup 0)
2211                          (const_int 8)
2212                          (const_int 16))
2213         (rotate:SI (match_dup 1)
2214                    (const_int 16)))]
2215   "")
2216
2217 (define_expand "mulsi3"
2218   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
2219    (use (match_operand:SI 1 "gpc_reg_operand" ""))
2220    (use (match_operand:SI 2 "reg_or_short_operand" ""))]
2221   ""
2222   "
2223 {
2224   if (TARGET_POWER)
2225     emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
2226   else
2227     emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
2228   DONE;
2229 }")
2230
2231 (define_insn "mulsi3_mq"
2232   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2233         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2234                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))
2235    (clobber (match_scratch:SI 3 "=q,q"))]
2236   "TARGET_POWER"
2237   "@
2238    {muls|mullw} %0,%1,%2
2239    {muli|mulli} %0,%1,%2"
2240    [(set (attr "type")
2241       (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2242                 (const_string "imul3")
2243              (match_operand:SI 2 "short_cint_operand" "")
2244                 (const_string "imul2")]
2245         (const_string "imul")))])
2246
2247 (define_insn "mulsi3_no_mq"
2248   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2249         (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2250                  (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
2251   "! TARGET_POWER"
2252   "@
2253    {muls|mullw} %0,%1,%2
2254    {muli|mulli} %0,%1,%2"
2255    [(set (attr "type")
2256       (cond [(match_operand:SI 2 "s8bit_cint_operand" "")
2257                 (const_string "imul3")
2258              (match_operand:SI 2 "short_cint_operand" "")
2259                 (const_string "imul2")]
2260         (const_string "imul")))])
2261
2262 (define_insn "*mulsi3_mq_internal1"
2263   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2264         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2265                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2266                     (const_int 0)))
2267    (clobber (match_scratch:SI 3 "=r,r"))
2268    (clobber (match_scratch:SI 4 "=q,q"))]
2269   "TARGET_POWER"
2270   "@
2271    {muls.|mullw.} %3,%1,%2
2272    #"
2273   [(set_attr "type" "imul_compare")
2274    (set_attr "length" "4,8")])
2275
2276 (define_split
2277   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2278         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2279                              (match_operand:SI 2 "gpc_reg_operand" ""))
2280                     (const_int 0)))
2281    (clobber (match_scratch:SI 3 ""))
2282    (clobber (match_scratch:SI 4 ""))]
2283   "TARGET_POWER && reload_completed"
2284   [(parallel [(set (match_dup 3)
2285         (mult:SI (match_dup 1) (match_dup 2)))
2286    (clobber (match_dup 4))])
2287    (set (match_dup 0)
2288         (compare:CC (match_dup 3)
2289                     (const_int 0)))]
2290   "")
2291
2292 (define_insn "*mulsi3_no_mq_internal1"
2293   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
2294         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2295                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2296                     (const_int 0)))
2297    (clobber (match_scratch:SI 3 "=r,r"))]
2298   "! TARGET_POWER"
2299   "@
2300    {muls.|mullw.} %3,%1,%2
2301    #"
2302   [(set_attr "type" "imul_compare")
2303    (set_attr "length" "4,8")])
2304
2305 (define_split
2306   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2307         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2308                              (match_operand:SI 2 "gpc_reg_operand" ""))
2309                     (const_int 0)))
2310    (clobber (match_scratch:SI 3 ""))]
2311   "! TARGET_POWER && reload_completed"
2312   [(set (match_dup 3)
2313         (mult:SI (match_dup 1) (match_dup 2)))
2314    (set (match_dup 0)
2315         (compare:CC (match_dup 3)
2316                     (const_int 0)))]
2317   "")
2318
2319 (define_insn "*mulsi3_mq_internal2"
2320   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2321         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2322                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2323                     (const_int 0)))
2324    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2325         (mult:SI (match_dup 1) (match_dup 2)))
2326    (clobber (match_scratch:SI 4 "=q,q"))]
2327   "TARGET_POWER"
2328   "@
2329    {muls.|mullw.} %0,%1,%2
2330    #"
2331   [(set_attr "type" "imul_compare")
2332    (set_attr "length" "4,8")])
2333
2334 (define_split
2335   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2336         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2337                              (match_operand:SI 2 "gpc_reg_operand" ""))
2338                     (const_int 0)))
2339    (set (match_operand:SI 0 "gpc_reg_operand" "")
2340         (mult:SI (match_dup 1) (match_dup 2)))
2341    (clobber (match_scratch:SI 4 ""))]
2342   "TARGET_POWER && reload_completed"
2343   [(parallel [(set (match_dup 0)
2344         (mult:SI (match_dup 1) (match_dup 2)))
2345    (clobber (match_dup 4))])
2346    (set (match_dup 3)
2347         (compare:CC (match_dup 0)
2348                     (const_int 0)))]
2349   "")
2350
2351 (define_insn "*mulsi3_no_mq_internal2"
2352   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2353         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
2354                              (match_operand:SI 2 "gpc_reg_operand" "r,r"))
2355                     (const_int 0)))
2356    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
2357         (mult:SI (match_dup 1) (match_dup 2)))]
2358   "! TARGET_POWER"
2359   "@
2360    {muls.|mullw.} %0,%1,%2
2361    #"
2362   [(set_attr "type" "imul_compare")
2363    (set_attr "length" "4,8")])
2364
2365 (define_split
2366   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2367         (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "")
2368                              (match_operand:SI 2 "gpc_reg_operand" ""))
2369                     (const_int 0)))
2370    (set (match_operand:SI 0 "gpc_reg_operand" "")
2371         (mult:SI (match_dup 1) (match_dup 2)))]
2372   "! TARGET_POWER && reload_completed"
2373   [(set (match_dup 0)
2374         (mult:SI (match_dup 1) (match_dup 2)))
2375    (set (match_dup 3)
2376         (compare:CC (match_dup 0)
2377                     (const_int 0)))]
2378   "")
2379
2380 ;; Operand 1 is divided by operand 2; quotient goes to operand
2381 ;; 0 and remainder to operand 3.
2382 ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
2383
2384 (define_expand "divmodsi4"
2385   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2386                    (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
2387                            (match_operand:SI 2 "gpc_reg_operand" "")))
2388               (set (match_operand:SI 3 "register_operand" "")
2389                    (mod:SI (match_dup 1) (match_dup 2)))])]
2390   "TARGET_POWER || (! 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_divss_call ());
2398       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2399       emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2400       DONE;
2401     }
2402 }")
2403
2404 (define_insn "*divmodsi4_internal"
2405   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2406         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2407                 (match_operand:SI 2 "gpc_reg_operand" "r")))
2408    (set (match_operand:SI 3 "register_operand" "=q")
2409         (mod:SI (match_dup 1) (match_dup 2)))]
2410   "TARGET_POWER"
2411   "divs %0,%1,%2"
2412   [(set_attr "type" "idiv")])
2413
2414 (define_expand "udiv<mode>3"
2415   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2416         (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2417                   (match_operand:GPR 2 "gpc_reg_operand" "")))]
2418   "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
2419   "
2420 {
2421   if (! TARGET_POWER && ! TARGET_POWERPC)
2422     {
2423       emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2424       emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2425       emit_insn (gen_quous_call ());
2426       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2427       DONE;
2428     }
2429   else if (TARGET_POWER)
2430     {
2431       emit_insn (gen_udivsi3_mq (operands[0], operands[1], operands[2]));
2432       DONE;
2433     }
2434 }")
2435
2436 (define_insn "udivsi3_mq"
2437   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2438         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2439                  (match_operand:SI 2 "gpc_reg_operand" "r")))
2440    (clobber (match_scratch:SI 3 "=q"))]
2441   "TARGET_POWERPC && TARGET_POWER"
2442   "divwu %0,%1,%2"
2443   [(set_attr "type" "idiv")])
2444
2445 (define_insn "*udivsi3_no_mq"
2446   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2447         (udiv:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2448                   (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2449   "TARGET_POWERPC && ! TARGET_POWER"
2450   "div<wd>u %0,%1,%2"
2451    [(set (attr "type")
2452       (cond [(match_operand:SI 0 "" "")
2453                 (const_string "idiv")]
2454         (const_string "ldiv")))])
2455
2456
2457 ;; For powers of two we can do srai/aze for divide and then adjust for
2458 ;; modulus.  If it isn't a power of two, FAIL on POWER so divmodsi4 will be
2459 ;; used; for PowerPC, force operands into register and do a normal divide;
2460 ;; for AIX common-mode, use quoss call on register operands.
2461 (define_expand "div<mode>3"
2462   [(set (match_operand:GPR 0 "gpc_reg_operand" "")
2463         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2464                  (match_operand:GPR 2 "reg_or_cint_operand" "")))]
2465   ""
2466   "
2467 {
2468   if (GET_CODE (operands[2]) == CONST_INT
2469       && INTVAL (operands[2]) > 0
2470       && exact_log2 (INTVAL (operands[2])) >= 0)
2471     ;
2472   else if (TARGET_POWERPC)
2473     {
2474       operands[2] = force_reg (<MODE>mode, operands[2]);
2475       if (TARGET_POWER)
2476         {
2477           emit_insn (gen_divsi3_mq (operands[0], operands[1], operands[2]));
2478           DONE;
2479         }
2480     }
2481   else if (TARGET_POWER)
2482     FAIL;
2483   else
2484     {
2485       emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2486       emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2487       emit_insn (gen_quoss_call ());
2488       emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2489       DONE;
2490     }
2491 }")
2492
2493 (define_insn "divsi3_mq"
2494   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2495         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2496                 (match_operand:SI 2 "gpc_reg_operand" "r")))
2497    (clobber (match_scratch:SI 3 "=q"))]
2498   "TARGET_POWERPC && TARGET_POWER"
2499   "divw %0,%1,%2"
2500   [(set_attr "type" "idiv")])
2501
2502 (define_insn "*div<mode>3_no_mq"
2503   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2504         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2505                  (match_operand:GPR 2 "gpc_reg_operand" "r")))]
2506   "TARGET_POWERPC && ! TARGET_POWER"
2507   "div<wd> %0,%1,%2"
2508   [(set (attr "type")
2509      (cond [(match_operand:SI 0 "" "")
2510                 (const_string "idiv")]
2511         (const_string "ldiv")))])
2512
2513 (define_expand "mod<mode>3"
2514   [(use (match_operand:GPR 0 "gpc_reg_operand" ""))
2515    (use (match_operand:GPR 1 "gpc_reg_operand" ""))
2516    (use (match_operand:GPR 2 "reg_or_cint_operand" ""))]
2517   ""
2518   "
2519 {
2520   int i;
2521   rtx temp1;
2522   rtx temp2;
2523
2524   if (GET_CODE (operands[2]) != CONST_INT
2525       || INTVAL (operands[2]) <= 0
2526       || (i = exact_log2 (INTVAL (operands[2]))) < 0)
2527     FAIL;
2528
2529   temp1 = gen_reg_rtx (<MODE>mode);
2530   temp2 = gen_reg_rtx (<MODE>mode);
2531
2532   emit_insn (gen_div<mode>3 (temp1, operands[1], operands[2]));
2533   emit_insn (gen_ashl<mode>3 (temp2, temp1, GEN_INT (i)));
2534   emit_insn (gen_sub<mode>3 (operands[0], operands[1], temp2));
2535   DONE;
2536 }")
2537
2538 (define_insn ""
2539   [(set (match_operand:GPR 0 "gpc_reg_operand" "=r")
2540         (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "r")
2541                  (match_operand:GPR 2 "exact_log2_cint_operand" "N")))]
2542   ""
2543   "{srai|sra<wd>i} %0,%1,%p2\;{aze|addze} %0,%0"
2544   [(set_attr "type" "two")
2545    (set_attr "length" "8")])
2546
2547 (define_insn ""
2548   [(set (match_operand:CC 0 "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    (clobber (match_scratch:P 3 "=r,r"))]
2553   ""
2554   "@
2555    {srai|sra<wd>i} %3,%1,%p2\;{aze.|addze.} %3,%3
2556    #"
2557   [(set_attr "type" "compare")
2558    (set_attr "length" "8,12")])
2559
2560 (define_split
2561   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2562         (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2563                              (match_operand:GPR 2 "exact_log2_cint_operand"
2564                               ""))
2565                     (const_int 0)))
2566    (clobber (match_scratch:GPR 3 ""))]
2567   "reload_completed"
2568   [(set (match_dup 3)
2569         (div:<MODE> (match_dup 1) (match_dup 2)))
2570    (set (match_dup 0)
2571         (compare:CC (match_dup 3)
2572                     (const_int 0)))]
2573   "")
2574
2575 (define_insn ""
2576   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
2577         (compare:CC (div:P (match_operand:P 1 "gpc_reg_operand" "r,r")
2578                            (match_operand:P 2 "exact_log2_cint_operand" "N,N"))
2579                     (const_int 0)))
2580    (set (match_operand:P 0 "gpc_reg_operand" "=r,r")
2581         (div:P (match_dup 1) (match_dup 2)))]
2582   ""
2583   "@
2584    {srai|sra<wd>i} %0,%1,%p2\;{aze.|addze.} %0,%0
2585    #"
2586   [(set_attr "type" "compare")
2587    (set_attr "length" "8,12")])
2588
2589 (define_split
2590   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2591         (compare:CC (div:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2592                              (match_operand:GPR 2 "exact_log2_cint_operand"
2593                               ""))
2594                     (const_int 0)))
2595    (set (match_operand:GPR 0 "gpc_reg_operand" "")
2596         (div:GPR (match_dup 1) (match_dup 2)))]
2597   "reload_completed"
2598   [(set (match_dup 0)
2599         (div:<MODE> (match_dup 1) (match_dup 2)))
2600    (set (match_dup 3)
2601         (compare:CC (match_dup 0)
2602                     (const_int 0)))]
2603   "")
2604
2605 (define_insn ""
2606   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2607         (udiv:SI
2608          (plus:DI (ashift:DI
2609                    (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
2610                    (const_int 32))
2611                   (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
2612          (match_operand:SI 3 "gpc_reg_operand" "r")))
2613    (set (match_operand:SI 2 "register_operand" "=*q")
2614         (umod:SI
2615          (plus:DI (ashift:DI
2616                    (zero_extend:DI (match_dup 1)) (const_int 32))
2617                   (zero_extend:DI (match_dup 4)))
2618          (match_dup 3)))]
2619   "TARGET_POWER"
2620   "div %0,%1,%3"
2621   [(set_attr "type" "idiv")])
2622
2623 ;; To do unsigned divide we handle the cases of the divisor looking like a
2624 ;; negative number.  If it is a constant that is less than 2**31, we don't
2625 ;; have to worry about the branches.  So make a few subroutines here.
2626 ;;
2627 ;; First comes the normal case.
2628 (define_expand "udivmodsi4_normal"
2629   [(set (match_dup 4) (const_int 0))
2630    (parallel [(set (match_operand:SI 0 "" "")
2631                    (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2632                                                 (const_int 32))
2633                                      (zero_extend:DI (match_operand:SI 1 "" "")))
2634                             (match_operand:SI 2 "" "")))
2635               (set (match_operand:SI 3 "" "")
2636                    (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
2637                                                 (const_int 32))
2638                                      (zero_extend:DI (match_dup 1)))
2639                             (match_dup 2)))])]
2640   "TARGET_POWER"
2641   "
2642 { operands[4] = gen_reg_rtx (SImode); }")
2643
2644 ;; This handles the branches.
2645 (define_expand "udivmodsi4_tests"
2646   [(set (match_operand:SI 0 "" "") (const_int 0))
2647    (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
2648    (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
2649    (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
2650                            (label_ref (match_operand:SI 4 "" "")) (pc)))
2651    (set (match_dup 0) (const_int 1))
2652    (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
2653    (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
2654    (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
2655                            (label_ref (match_dup 4)) (pc)))]
2656   "TARGET_POWER"
2657   "
2658 { operands[5] = gen_reg_rtx (CCUNSmode);
2659   operands[6] = gen_reg_rtx (CCmode);
2660 }")
2661
2662 (define_expand "udivmodsi4"
2663   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
2664                    (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
2665                             (match_operand:SI 2 "reg_or_cint_operand" "")))
2666               (set (match_operand:SI 3 "gpc_reg_operand" "")
2667                    (umod:SI (match_dup 1) (match_dup 2)))])]
2668   ""
2669   "
2670 {
2671   rtx label = 0;
2672
2673   if (! TARGET_POWER)
2674     {
2675       if (! TARGET_POWERPC)
2676         {
2677           emit_move_insn (gen_rtx_REG (SImode, 3), operands[1]);
2678           emit_move_insn (gen_rtx_REG (SImode, 4), operands[2]);
2679           emit_insn (gen_divus_call ());
2680           emit_move_insn (operands[0], gen_rtx_REG (SImode, 3));
2681           emit_move_insn (operands[3], gen_rtx_REG (SImode, 4));
2682           DONE;
2683         }
2684       else
2685         FAIL;
2686     }
2687
2688   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
2689     {
2690       operands[2] = force_reg (SImode, operands[2]);
2691       label = gen_label_rtx ();
2692       emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
2693                                   operands[3], label));
2694     }
2695   else
2696     operands[2] = force_reg (SImode, operands[2]);
2697
2698   emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
2699                                operands[3]));
2700   if (label)
2701     emit_label (label);
2702
2703   DONE;
2704 }")
2705
2706 ;; AIX architecture-independent common-mode multiply (DImode),
2707 ;; divide/modulus, and quotient subroutine calls.  Input operands in R3 and
2708 ;; R4; results in R3 and sometimes R4; link register always clobbered by bla
2709 ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
2710 ;; assumed unused if generating common-mode, so ignore.
2711 (define_insn "mulh_call"
2712   [(set (reg:SI 3)
2713         (truncate:SI
2714          (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
2715                                (sign_extend:DI (reg:SI 4)))
2716                       (const_int 32))))
2717    (clobber (reg:SI 65))]
2718   "! TARGET_POWER && ! TARGET_POWERPC"
2719   "bla __mulh"
2720   [(set_attr "type" "imul")])
2721
2722 (define_insn "mull_call"
2723   [(set (reg:DI 3)
2724         (mult:DI (sign_extend:DI (reg:SI 3))
2725                  (sign_extend:DI (reg:SI 4))))
2726    (clobber (reg:SI 65))
2727    (clobber (reg:SI 0))]
2728   "! TARGET_POWER && ! TARGET_POWERPC"
2729   "bla __mull"
2730   [(set_attr "type" "imul")])
2731
2732 (define_insn "divss_call"
2733   [(set (reg:SI 3)
2734         (div:SI (reg:SI 3) (reg:SI 4)))
2735    (set (reg:SI 4)
2736         (mod:SI (reg:SI 3) (reg:SI 4)))
2737    (clobber (reg:SI 65))
2738    (clobber (reg:SI 0))]
2739   "! TARGET_POWER && ! TARGET_POWERPC"
2740   "bla __divss"
2741   [(set_attr "type" "idiv")])
2742
2743 (define_insn "divus_call"
2744   [(set (reg:SI 3)
2745         (udiv:SI (reg:SI 3) (reg:SI 4)))
2746    (set (reg:SI 4)
2747         (umod:SI (reg:SI 3) (reg:SI 4)))
2748    (clobber (reg:SI 65))
2749    (clobber (reg:SI 0))
2750    (clobber (match_scratch:CC 0 "=x"))
2751    (clobber (reg:CC 69))]
2752   "! TARGET_POWER && ! TARGET_POWERPC"
2753   "bla __divus"
2754   [(set_attr "type" "idiv")])
2755
2756 (define_insn "quoss_call"
2757   [(set (reg:SI 3)
2758         (div:SI (reg:SI 3) (reg:SI 4)))
2759    (clobber (reg:SI 65))]
2760   "! TARGET_POWER && ! TARGET_POWERPC"
2761   "bla __quoss"
2762   [(set_attr "type" "idiv")])
2763
2764 (define_insn "quous_call"
2765   [(set (reg:SI 3)
2766         (udiv:SI (reg:SI 3) (reg:SI 4)))
2767    (clobber (reg:SI 65))
2768    (clobber (reg:SI 0))
2769    (clobber (match_scratch:CC 0 "=x"))
2770    (clobber (reg:CC 69))]
2771   "! TARGET_POWER && ! TARGET_POWERPC"
2772   "bla __quous"
2773   [(set_attr "type" "idiv")])
2774 \f
2775 ;; Logical instructions
2776 ;; The logical instructions are mostly combined by using match_operator,
2777 ;; but the plain AND insns are somewhat different because there is no
2778 ;; plain 'andi' (only 'andi.'), no plain 'andis', and there are all
2779 ;; those rotate-and-mask operations.  Thus, the AND insns come first.
2780
2781 (define_insn "andsi3"
2782   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
2783         (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
2784                 (match_operand:SI 2 "and_operand" "?r,T,K,L")))
2785    (clobber (match_scratch:CC 3 "=X,X,x,x"))]
2786   ""
2787   "@
2788    and %0,%1,%2
2789    {rlinm|rlwinm} %0,%1,0,%m2,%M2
2790    {andil.|andi.} %0,%1,%b2
2791    {andiu.|andis.} %0,%1,%u2"
2792   [(set_attr "type" "*,*,compare,compare")])
2793
2794 ;; Note to set cr's other than cr0 we do the and immediate and then
2795 ;; the test again -- this avoids a mfcr which on the higher end
2796 ;; machines causes an execution serialization
2797
2798 (define_insn "*andsi3_internal2"
2799   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2800         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2801                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2802                     (const_int 0)))
2803    (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2804    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2805   "TARGET_32BIT"
2806   "@
2807    and. %3,%1,%2
2808    {andil.|andi.} %3,%1,%b2
2809    {andiu.|andis.} %3,%1,%u2
2810    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2811    #
2812    #
2813    #
2814    #"
2815   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2816    (set_attr "length" "4,4,4,4,8,8,8,8")])
2817
2818 (define_insn "*andsi3_internal3"
2819   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2820         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2821                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2822                     (const_int 0)))
2823    (clobber (match_scratch:SI 3 "=r,r,r,r,r,r,r,r"))
2824    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2825   "TARGET_64BIT"
2826   "@
2827    #
2828    {andil.|andi.} %3,%1,%b2
2829    {andiu.|andis.} %3,%1,%u2
2830    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2
2831    #
2832    #
2833    #
2834    #"
2835   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2836    (set_attr "length" "8,4,4,4,8,8,8,8")])
2837
2838 (define_split
2839   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
2840         (compare:CC (and:GPR (match_operand:GPR 1 "gpc_reg_operand" "")
2841                              (match_operand:GPR 2 "and_operand" ""))
2842                     (const_int 0)))
2843    (clobber (match_scratch:GPR 3 ""))
2844    (clobber (match_scratch:CC 4 ""))]
2845   "reload_completed"
2846   [(parallel [(set (match_dup 3)
2847                    (and:<MODE> (match_dup 1)
2848                                (match_dup 2)))
2849               (clobber (match_dup 4))])
2850    (set (match_dup 0)
2851         (compare:CC (match_dup 3)
2852                     (const_int 0)))]
2853   "")
2854
2855 ;; We don't have a 32 bit "and. rt,ra,rb" for ppc64.  cr is set from the
2856 ;; whole 64 bit reg, and we don't know what is in the high 32 bits.
2857
2858 (define_split
2859   [(set (match_operand:CC 0 "cc_reg_operand" "")
2860         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2861                             (match_operand:SI 2 "gpc_reg_operand" ""))
2862                     (const_int 0)))
2863    (clobber (match_scratch:SI 3 ""))
2864    (clobber (match_scratch:CC 4 ""))]
2865   "TARGET_POWERPC64 && reload_completed"
2866   [(parallel [(set (match_dup 3)
2867                    (and:SI (match_dup 1)
2868                            (match_dup 2)))
2869               (clobber (match_dup 4))])
2870    (set (match_dup 0)
2871         (compare:CC (match_dup 3)
2872                     (const_int 0)))]
2873   "")
2874
2875 (define_insn "*andsi3_internal4"
2876   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2877         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2878                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2879                     (const_int 0)))
2880    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2881         (and:SI (match_dup 1)
2882                 (match_dup 2)))
2883    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2884   "TARGET_32BIT"
2885   "@
2886    and. %0,%1,%2
2887    {andil.|andi.} %0,%1,%b2
2888    {andiu.|andis.} %0,%1,%u2
2889    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2890    #
2891    #
2892    #
2893    #"
2894   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2895    (set_attr "length" "4,4,4,4,8,8,8,8")])
2896
2897 (define_insn "*andsi3_internal5"
2898   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x,?y,??y,??y,?y")
2899         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r,r,r,r")
2900                             (match_operand:SI 2 "and_operand" "r,K,L,T,r,K,L,T"))
2901                     (const_int 0)))
2902    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r,r,r,r")
2903         (and:SI (match_dup 1)
2904                 (match_dup 2)))
2905    (clobber (match_scratch:CC 4 "=X,X,X,X,X,x,x,X"))]
2906   "TARGET_64BIT"
2907   "@
2908    #
2909    {andil.|andi.} %0,%1,%b2
2910    {andiu.|andis.} %0,%1,%u2
2911    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2
2912    #
2913    #
2914    #
2915    #"
2916   [(set_attr "type" "compare,compare,compare,delayed_compare,compare,compare,compare,compare")
2917    (set_attr "length" "8,4,4,4,8,8,8,8")])
2918
2919 (define_split
2920   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
2921         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2922                             (match_operand:SI 2 "and_operand" ""))
2923                     (const_int 0)))
2924    (set (match_operand:SI 0 "gpc_reg_operand" "")
2925         (and:SI (match_dup 1)
2926                 (match_dup 2)))
2927    (clobber (match_scratch:CC 4 ""))]
2928   "reload_completed"
2929   [(parallel [(set (match_dup 0)
2930                    (and:SI (match_dup 1)
2931                            (match_dup 2)))
2932               (clobber (match_dup 4))])
2933    (set (match_dup 3)
2934         (compare:CC (match_dup 0)
2935                     (const_int 0)))]
2936   "")
2937
2938 (define_split
2939   [(set (match_operand:CC 3 "cc_reg_operand" "")
2940         (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
2941                             (match_operand:SI 2 "gpc_reg_operand" ""))
2942                     (const_int 0)))
2943    (set (match_operand:SI 0 "gpc_reg_operand" "")
2944         (and:SI (match_dup 1)
2945                 (match_dup 2)))
2946    (clobber (match_scratch:CC 4 ""))]
2947   "TARGET_POWERPC64 && reload_completed"
2948   [(parallel [(set (match_dup 0)
2949                    (and:SI (match_dup 1)
2950                            (match_dup 2)))
2951               (clobber (match_dup 4))])
2952    (set (match_dup 3)
2953         (compare:CC (match_dup 0)
2954                     (const_int 0)))]
2955   "")
2956
2957 ;; Handle the PowerPC64 rlwinm corner case
2958
2959 (define_insn_and_split "*andsi3_internal6"
2960   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
2961         (and:SI (match_operand:SI 1 "gpc_reg_operand" "r")
2962                 (match_operand:SI 2 "mask_operand_wrap" "i")))]
2963   "TARGET_POWERPC64"
2964   "#"
2965   "TARGET_POWERPC64"
2966   [(set (match_dup 0)
2967         (and:SI (rotate:SI (match_dup 1) (match_dup 3))
2968                 (match_dup 4)))
2969    (set (match_dup 0)
2970         (rotate:SI (match_dup 0) (match_dup 5)))]
2971   "
2972 {
2973   int mb = extract_MB (operands[2]);
2974   int me = extract_ME (operands[2]);
2975   operands[3] = GEN_INT (me + 1);
2976   operands[5] = GEN_INT (32 - (me + 1));
2977   operands[4] = GEN_INT (~((HOST_WIDE_INT) -1 << (33 + me - mb)));
2978 }"
2979   [(set_attr "length" "8")])
2980
2981 (define_expand "iorsi3"
2982   [(set (match_operand:SI 0 "gpc_reg_operand" "")
2983         (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
2984                 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
2985   ""
2986   "
2987 {
2988   if (GET_CODE (operands[2]) == CONST_INT
2989       && ! logical_operand (operands[2], SImode))
2990     {
2991       HOST_WIDE_INT value = INTVAL (operands[2]);
2992       rtx tmp = ((!can_create_pseudo_p ()
2993                   || rtx_equal_p (operands[0], operands[1]))
2994                  ? operands[0] : gen_reg_rtx (SImode));
2995
2996       emit_insn (gen_iorsi3 (tmp, operands[1],
2997                              GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
2998       emit_insn (gen_iorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
2999       DONE;
3000     }
3001 }")
3002
3003 (define_expand "xorsi3"
3004   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3005         (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
3006                 (match_operand:SI 2 "reg_or_logical_cint_operand" "")))]
3007   ""
3008   "
3009 {
3010   if (GET_CODE (operands[2]) == CONST_INT
3011       && ! logical_operand (operands[2], SImode))
3012     {
3013       HOST_WIDE_INT value = INTVAL (operands[2]);
3014       rtx tmp = ((!can_create_pseudo_p ()
3015                   || rtx_equal_p (operands[0], operands[1]))
3016                  ? operands[0] : gen_reg_rtx (SImode));
3017
3018       emit_insn (gen_xorsi3 (tmp, operands[1],
3019                              GEN_INT (value & (~ (HOST_WIDE_INT) 0xffff))));
3020       emit_insn (gen_xorsi3 (operands[0], tmp, GEN_INT (value & 0xffff)));
3021       DONE;
3022     }
3023 }")
3024
3025 (define_insn "*boolsi3_internal1"
3026   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
3027         (match_operator:SI 3 "boolean_or_operator"
3028          [(match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
3029           (match_operand:SI 2 "logical_operand" "r,K,L")]))]
3030   ""
3031   "@
3032    %q3 %0,%1,%2
3033    {%q3il|%q3i} %0,%1,%b2
3034    {%q3iu|%q3is} %0,%1,%u2")
3035
3036 (define_insn "*boolsi3_internal2"
3037   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3038         (compare:CC (match_operator:SI 4 "boolean_or_operator"
3039          [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3040           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3041          (const_int 0)))
3042    (clobber (match_scratch:SI 3 "=r,r"))]
3043   "TARGET_32BIT"
3044   "@
3045    %q4. %3,%1,%2
3046    #"
3047   [(set_attr "type" "compare")
3048    (set_attr "length" "4,8")])
3049
3050 (define_split
3051   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3052         (compare:CC (match_operator:SI 4 "boolean_operator"
3053          [(match_operand:SI 1 "gpc_reg_operand" "")
3054           (match_operand:SI 2 "gpc_reg_operand" "")])
3055          (const_int 0)))
3056    (clobber (match_scratch:SI 3 ""))]
3057   "TARGET_32BIT && reload_completed"
3058   [(set (match_dup 3) (match_dup 4))
3059    (set (match_dup 0)
3060         (compare:CC (match_dup 3)
3061                     (const_int 0)))]
3062   "")
3063
3064 (define_insn "*boolsi3_internal3"
3065   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3066         (compare:CC (match_operator:SI 4 "boolean_operator"
3067          [(match_operand:SI 1 "gpc_reg_operand" "%r,r")
3068           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3069          (const_int 0)))
3070    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3071         (match_dup 4))]
3072   "TARGET_32BIT"
3073   "@
3074    %q4. %0,%1,%2
3075    #"
3076   [(set_attr "type" "compare")
3077    (set_attr "length" "4,8")])
3078
3079 (define_split
3080   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3081         (compare:CC (match_operator:SI 4 "boolean_operator"
3082          [(match_operand:SI 1 "gpc_reg_operand" "")
3083           (match_operand:SI 2 "gpc_reg_operand" "")])
3084          (const_int 0)))
3085    (set (match_operand:SI 0 "gpc_reg_operand" "")
3086         (match_dup 4))]
3087   "TARGET_32BIT && reload_completed"
3088   [(set (match_dup 0) (match_dup 4))
3089    (set (match_dup 3)
3090         (compare:CC (match_dup 0)
3091                     (const_int 0)))]
3092   "")
3093
3094 ;; Split a logical operation that we can't do in one insn into two insns,
3095 ;; each of which does one 16-bit part.  This is used by combine.
3096
3097 (define_split
3098   [(set (match_operand:SI 0 "gpc_reg_operand" "")
3099         (match_operator:SI 3 "boolean_or_operator"
3100          [(match_operand:SI 1 "gpc_reg_operand" "")
3101           (match_operand:SI 2 "non_logical_cint_operand" "")]))]
3102   ""
3103   [(set (match_dup 0) (match_dup 4))
3104    (set (match_dup 0) (match_dup 5))]
3105 "
3106 {
3107   rtx i;
3108   i = GEN_INT (INTVAL (operands[2]) & (~ (HOST_WIDE_INT) 0xffff));
3109   operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3110                                 operands[1], i);
3111   i = GEN_INT (INTVAL (operands[2]) & 0xffff);
3112   operands[5] = gen_rtx_fmt_ee (GET_CODE (operands[3]), SImode,
3113                                 operands[0], i);
3114 }")
3115
3116 (define_insn "*boolcsi3_internal1"
3117   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3118         (match_operator:SI 3 "boolean_operator"
3119          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3120           (match_operand:SI 2 "gpc_reg_operand" "r")]))]
3121   ""
3122   "%q3 %0,%2,%1")
3123
3124 (define_insn "*boolcsi3_internal2"
3125   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3126         (compare:CC (match_operator:SI 4 "boolean_operator"
3127          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3128           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3129          (const_int 0)))
3130    (clobber (match_scratch:SI 3 "=r,r"))]
3131   "TARGET_32BIT"
3132   "@
3133    %q4. %3,%2,%1
3134    #"
3135   [(set_attr "type" "compare")
3136    (set_attr "length" "4,8")])
3137
3138 (define_split
3139   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3140         (compare:CC (match_operator:SI 4 "boolean_operator"
3141          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3142           (match_operand:SI 2 "gpc_reg_operand" "")])
3143          (const_int 0)))
3144    (clobber (match_scratch:SI 3 ""))]
3145   "TARGET_32BIT && reload_completed"
3146   [(set (match_dup 3) (match_dup 4))
3147    (set (match_dup 0)
3148         (compare:CC (match_dup 3)
3149                     (const_int 0)))]
3150   "")
3151
3152 (define_insn "*boolcsi3_internal3"
3153   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3154         (compare:CC (match_operator:SI 4 "boolean_operator"
3155          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3156           (match_operand:SI 2 "gpc_reg_operand" "r,r")])
3157          (const_int 0)))
3158    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3159         (match_dup 4))]
3160   "TARGET_32BIT"
3161   "@
3162    %q4. %0,%2,%1
3163    #"
3164   [(set_attr "type" "compare")
3165    (set_attr "length" "4,8")])
3166
3167 (define_split
3168   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3169         (compare:CC (match_operator:SI 4 "boolean_operator"
3170          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3171           (match_operand:SI 2 "gpc_reg_operand" "")])
3172          (const_int 0)))
3173    (set (match_operand:SI 0 "gpc_reg_operand" "")
3174         (match_dup 4))]
3175   "TARGET_32BIT && reload_completed"
3176   [(set (match_dup 0) (match_dup 4))
3177    (set (match_dup 3)
3178         (compare:CC (match_dup 0)
3179                     (const_int 0)))]
3180   "")
3181
3182 (define_insn "*boolccsi3_internal1"
3183   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3184         (match_operator:SI 3 "boolean_operator"
3185          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
3186           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))]))]
3187   ""
3188   "%q3 %0,%1,%2")
3189
3190 (define_insn "*boolccsi3_internal2"
3191   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3192         (compare:CC (match_operator:SI 4 "boolean_operator"
3193          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "r,r"))
3194           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3195          (const_int 0)))
3196    (clobber (match_scratch:SI 3 "=r,r"))]
3197   "TARGET_32BIT"
3198   "@
3199    %q4. %3,%1,%2
3200    #"
3201   [(set_attr "type" "compare")
3202    (set_attr "length" "4,8")])
3203
3204 (define_split
3205   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3206         (compare:CC (match_operator:SI 4 "boolean_operator"
3207          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3208           (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3209          (const_int 0)))
3210    (clobber (match_scratch:SI 3 ""))]
3211   "TARGET_32BIT && reload_completed"
3212   [(set (match_dup 3) (match_dup 4))
3213    (set (match_dup 0)
3214         (compare:CC (match_dup 3)
3215                     (const_int 0)))]
3216   "")
3217
3218 (define_insn "*boolccsi3_internal3"
3219   [(set (match_operand:CC 3 "cc_reg_operand" "=x,?y")
3220         (compare:CC (match_operator:SI 4 "boolean_operator"
3221          [(not:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r"))
3222           (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))])
3223          (const_int 0)))
3224    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3225         (match_dup 4))]
3226   "TARGET_32BIT"
3227   "@
3228    %q4. %0,%1,%2
3229    #"
3230   [(set_attr "type" "compare")
3231    (set_attr "length" "4,8")])
3232
3233 (define_split
3234   [(set (match_operand:CC 3 "cc_reg_not_cr0_operand" "")
3235         (compare:CC (match_operator:SI 4 "boolean_operator"
3236          [(not:SI (match_operand:SI 1 "gpc_reg_operand" ""))
3237           (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))])
3238          (const_int 0)))
3239    (set (match_operand:SI 0 "gpc_reg_operand" "")
3240         (match_dup 4))]
3241   "TARGET_32BIT && reload_completed"
3242   [(set (match_dup 0) (match_dup 4))
3243    (set (match_dup 3)
3244         (compare:CC (match_dup 0)
3245                     (const_int 0)))]
3246   "")
3247
3248 ;; maskir insn.  We need four forms because things might be in arbitrary
3249 ;; orders.  Don't define forms that only set CR fields because these
3250 ;; would modify an input register.
3251
3252 (define_insn "*maskir_internal1"
3253   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3254         (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
3255                         (match_operand:SI 1 "gpc_reg_operand" "0"))
3256                 (and:SI (match_dup 2)
3257                         (match_operand:SI 3 "gpc_reg_operand" "r"))))]
3258   "TARGET_POWER"
3259   "maskir %0,%3,%2")
3260
3261 (define_insn "*maskir_internal2"
3262   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3263         (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
3264                         (match_operand:SI 1 "gpc_reg_operand" "0"))
3265                 (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3266                         (match_dup 2))))]
3267   "TARGET_POWER"
3268   "maskir %0,%3,%2")
3269
3270 (define_insn "*maskir_internal3"
3271   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3272         (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
3273                         (match_operand:SI 3 "gpc_reg_operand" "r"))
3274                 (and:SI (not:SI (match_dup 2))
3275                         (match_operand:SI 1 "gpc_reg_operand" "0"))))]
3276   "TARGET_POWER"
3277   "maskir %0,%3,%2")
3278
3279 (define_insn "*maskir_internal4"
3280   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3281         (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3282                         (match_operand:SI 2 "gpc_reg_operand" "r"))
3283                 (and:SI (not:SI (match_dup 2))
3284                         (match_operand:SI 1 "gpc_reg_operand" "0"))))]
3285   "TARGET_POWER"
3286   "maskir %0,%3,%2")
3287
3288 (define_insn "*maskir_internal5"
3289   [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3290         (compare:CC
3291          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3292                          (match_operand:SI 1 "gpc_reg_operand" "0,0"))
3293                  (and:SI (match_dup 2)
3294                          (match_operand:SI 3 "gpc_reg_operand" "r,r")))
3295          (const_int 0)))
3296    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3297         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3298                 (and:SI (match_dup 2) (match_dup 3))))]
3299   "TARGET_POWER"
3300   "@
3301    maskir. %0,%3,%2
3302    #"
3303   [(set_attr "type" "compare")
3304    (set_attr "length" "4,8")])
3305
3306 (define_split
3307   [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3308         (compare:CC
3309          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
3310                          (match_operand:SI 1 "gpc_reg_operand" ""))
3311                  (and:SI (match_dup 2)
3312                          (match_operand:SI 3 "gpc_reg_operand" "")))
3313          (const_int 0)))
3314    (set (match_operand:SI 0 "gpc_reg_operand" "")
3315         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3316                 (and:SI (match_dup 2) (match_dup 3))))]
3317   "TARGET_POWER && reload_completed"
3318   [(set (match_dup 0)
3319         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3320                 (and:SI (match_dup 2) (match_dup 3))))
3321    (set (match_dup 4)
3322         (compare:CC (match_dup 0)
3323                     (const_int 0)))]
3324   "")
3325
3326 (define_insn "*maskir_internal6"
3327   [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3328         (compare:CC
3329          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3330                          (match_operand:SI 1 "gpc_reg_operand" "0,0"))
3331                  (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
3332                          (match_dup 2)))
3333          (const_int 0)))
3334    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3335         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3336                 (and:SI (match_dup 3) (match_dup 2))))]
3337   "TARGET_POWER"
3338   "@
3339    maskir. %0,%3,%2
3340    #"
3341   [(set_attr "type" "compare")
3342    (set_attr "length" "4,8")])
3343
3344 (define_split
3345   [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3346         (compare:CC
3347          (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" ""))
3348                          (match_operand:SI 1 "gpc_reg_operand" ""))
3349                  (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
3350                          (match_dup 2)))
3351          (const_int 0)))
3352    (set (match_operand:SI 0 "gpc_reg_operand" "")
3353         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3354                 (and:SI (match_dup 3) (match_dup 2))))]
3355   "TARGET_POWER && reload_completed"
3356   [(set (match_dup 0)
3357         (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
3358                 (and:SI (match_dup 3) (match_dup 2))))
3359    (set (match_dup 4)
3360         (compare:CC (match_dup 0)
3361                     (const_int 0)))]
3362   "")
3363
3364 (define_insn "*maskir_internal7"
3365   [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3366         (compare:CC
3367          (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r,r")
3368                          (match_operand:SI 3 "gpc_reg_operand" "r,r"))
3369                  (and:SI (not:SI (match_dup 2))
3370                          (match_operand:SI 1 "gpc_reg_operand" "0,0")))
3371          (const_int 0)))
3372    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3373         (ior:SI (and:SI (match_dup 2) (match_dup 3))
3374                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3375   "TARGET_POWER"
3376   "@
3377    maskir. %0,%3,%2
3378    #"
3379   [(set_attr "type" "compare")
3380    (set_attr "length" "4,8")])
3381
3382 (define_split
3383   [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3384         (compare:CC
3385          (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "")
3386                          (match_operand:SI 3 "gpc_reg_operand" ""))
3387                  (and:SI (not:SI (match_dup 2))
3388                          (match_operand:SI 1 "gpc_reg_operand" "")))
3389          (const_int 0)))
3390    (set (match_operand:SI 0 "gpc_reg_operand" "")
3391         (ior:SI (and:SI (match_dup 2) (match_dup 3))
3392                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3393   "TARGET_POWER && reload_completed"
3394   [(set (match_dup 0)
3395         (ior:SI (and:SI (match_dup 2) (match_dup 3))
3396                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
3397    (set (match_dup 4)
3398         (compare:CC (match_dup 0)
3399                     (const_int 0)))]
3400   "")
3401
3402 (define_insn "*maskir_internal8"
3403   [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3404         (compare:CC
3405          (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r,r")
3406                          (match_operand:SI 2 "gpc_reg_operand" "r,r"))
3407                  (and:SI (not:SI (match_dup 2))
3408                          (match_operand:SI 1 "gpc_reg_operand" "0,0")))
3409          (const_int 0)))
3410    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3411         (ior:SI (and:SI (match_dup 3) (match_dup 2))
3412                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3413   "TARGET_POWER"
3414   "@
3415    maskir. %0,%3,%2
3416    #"
3417   [(set_attr "type" "compare")
3418    (set_attr "length" "4,8")])
3419
3420 (define_split
3421   [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3422         (compare:CC
3423          (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "")
3424                          (match_operand:SI 2 "gpc_reg_operand" ""))
3425                  (and:SI (not:SI (match_dup 2))
3426                          (match_operand:SI 1 "gpc_reg_operand" "")))
3427          (const_int 0)))
3428    (set (match_operand:SI 0 "gpc_reg_operand" "")
3429         (ior:SI (and:SI (match_dup 3) (match_dup 2))
3430                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
3431   "TARGET_POWER && reload_completed"
3432   [(set (match_dup 0)
3433         (ior:SI (and:SI (match_dup 3) (match_dup 2))
3434                 (and:SI (not:SI (match_dup 2)) (match_dup 1))))
3435    (set (match_dup 4)
3436         (compare:CC (match_dup 0)
3437                     (const_int 0)))]
3438   "")
3439 \f
3440 ;; Rotate and shift insns, in all their variants.  These support shifts,
3441 ;; field inserts and extracts, and various combinations thereof.
3442 (define_expand "insv"
3443   [(set (zero_extract (match_operand 0 "gpc_reg_operand" "")
3444                        (match_operand:SI 1 "const_int_operand" "")
3445                        (match_operand:SI 2 "const_int_operand" ""))
3446         (match_operand 3 "gpc_reg_operand" ""))]
3447   ""
3448   "
3449 {
3450   /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
3451      the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
3452      compiler if the address of the structure is taken later.  Likewise, do
3453      not handle invalid E500 subregs.  */
3454   if (GET_CODE (operands[0]) == SUBREG
3455       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD
3456           || ((TARGET_E500_DOUBLE || TARGET_SPE)
3457               && invalid_e500_subreg (operands[0], GET_MODE (operands[0])))))
3458     FAIL;
3459
3460   if (TARGET_POWERPC64 && GET_MODE (operands[0]) == DImode)
3461     emit_insn (gen_insvdi (operands[0], operands[1], operands[2], operands[3]));
3462   else
3463     emit_insn (gen_insvsi (operands[0], operands[1], operands[2], operands[3]));
3464   DONE;
3465 }")
3466
3467 (define_insn "insvsi"
3468   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3469                          (match_operand:SI 1 "const_int_operand" "i")
3470                          (match_operand:SI 2 "const_int_operand" "i"))
3471         (match_operand:SI 3 "gpc_reg_operand" "r"))]
3472   ""
3473   "*
3474 {
3475   int start = INTVAL (operands[2]) & 31;
3476   int size = INTVAL (operands[1]) & 31;
3477
3478   operands[4] = GEN_INT (32 - start - size);
3479   operands[1] = GEN_INT (start + size - 1);
3480   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3481 }"
3482   [(set_attr "type" "insert_word")])
3483
3484 (define_insn "*insvsi_internal1"
3485   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3486                          (match_operand:SI 1 "const_int_operand" "i")
3487                          (match_operand:SI 2 "const_int_operand" "i"))
3488         (rotate:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3489                    (match_operand:SI 4 "const_int_operand" "i")))]
3490   "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3491   "*
3492 {
3493   int shift = INTVAL (operands[4]) & 31;
3494   int start = INTVAL (operands[2]) & 31;
3495   int size = INTVAL (operands[1]) & 31;
3496
3497   operands[4] = GEN_INT (shift - start - size);
3498   operands[1] = GEN_INT (start + size - 1);
3499   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3500 }"
3501   [(set_attr "type" "insert_word")])
3502
3503 (define_insn "*insvsi_internal2"
3504   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3505                          (match_operand:SI 1 "const_int_operand" "i")
3506                          (match_operand:SI 2 "const_int_operand" "i"))
3507         (ashiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3508                      (match_operand:SI 4 "const_int_operand" "i")))]
3509   "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3510   "*
3511 {
3512   int shift = INTVAL (operands[4]) & 31;
3513   int start = INTVAL (operands[2]) & 31;
3514   int size = INTVAL (operands[1]) & 31;
3515
3516   operands[4] = GEN_INT (32 - shift - start - size);
3517   operands[1] = GEN_INT (start + size - 1);
3518   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3519 }"
3520   [(set_attr "type" "insert_word")])
3521
3522 (define_insn "*insvsi_internal3"
3523   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3524                          (match_operand:SI 1 "const_int_operand" "i")
3525                          (match_operand:SI 2 "const_int_operand" "i"))
3526         (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3527                      (match_operand:SI 4 "const_int_operand" "i")))]
3528   "(32 - (INTVAL (operands[4]) & 31)) >= INTVAL (operands[1])"
3529   "*
3530 {
3531   int shift = INTVAL (operands[4]) & 31;
3532   int start = INTVAL (operands[2]) & 31;
3533   int size = INTVAL (operands[1]) & 31;
3534
3535   operands[4] = GEN_INT (32 - shift - start - size);
3536   operands[1] = GEN_INT (start + size - 1);
3537   return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3538 }"
3539   [(set_attr "type" "insert_word")])
3540
3541 (define_insn "*insvsi_internal4"
3542   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
3543                          (match_operand:SI 1 "const_int_operand" "i")
3544                          (match_operand:SI 2 "const_int_operand" "i"))
3545         (zero_extract:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3546                          (match_operand:SI 4 "const_int_operand" "i")
3547                          (match_operand:SI 5 "const_int_operand" "i")))]
3548   "INTVAL (operands[4]) >= INTVAL (operands[1])"
3549   "*
3550 {
3551   int extract_start = INTVAL (operands[5]) & 31;
3552   int extract_size = INTVAL (operands[4]) & 31;
3553   int insert_start = INTVAL (operands[2]) & 31;
3554   int insert_size = INTVAL (operands[1]) & 31;
3555
3556 /* Align extract field with insert field */
3557   operands[5] = GEN_INT (extract_start + extract_size - insert_start - insert_size);
3558   operands[1] = GEN_INT (insert_start + insert_size - 1);
3559   return \"{rlimi|rlwimi} %0,%3,%h5,%h2,%h1\";
3560 }"
3561   [(set_attr "type" "insert_word")])
3562
3563 ;; combine patterns for rlwimi
3564 (define_insn "*insvsi_internal5"
3565   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3566         (ior:SI (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
3567                         (match_operand:SI 1 "mask_operand" "i"))
3568                 (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3569                                      (match_operand:SI 2 "const_int_operand" "i"))
3570                         (match_operand:SI 5 "mask_operand" "i"))))]
3571   "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
3572   "*
3573 {
3574  int me = extract_ME(operands[5]);
3575  int mb = extract_MB(operands[5]);
3576  operands[4] = GEN_INT(32 - INTVAL(operands[2]));
3577  operands[2] = GEN_INT(mb);
3578  operands[1] = GEN_INT(me);
3579  return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3580 }"
3581   [(set_attr "type" "insert_word")])
3582
3583 (define_insn "*insvsi_internal6"
3584   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3585         (ior:SI (and:SI (lshiftrt:SI (match_operand:SI 3 "gpc_reg_operand" "r")
3586                                      (match_operand:SI 2 "const_int_operand" "i"))
3587                         (match_operand:SI 5 "mask_operand" "i"))
3588                 (and:SI (match_operand:SI 4 "gpc_reg_operand" "0")
3589                         (match_operand:SI 1 "mask_operand" "i"))))]
3590   "TARGET_POWERPC && INTVAL(operands[1]) == ~INTVAL(operands[5])"
3591   "*
3592 {
3593  int me = extract_ME(operands[5]);
3594  int mb = extract_MB(operands[5]);
3595  operands[4] = GEN_INT(32 - INTVAL(operands[2]));
3596  operands[2] = GEN_INT(mb);
3597  operands[1] = GEN_INT(me);
3598  return \"{rlimi|rlwimi} %0,%3,%h4,%h2,%h1\";
3599 }"
3600   [(set_attr "type" "insert_word")])
3601
3602 (define_insn "insvdi"
3603   [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3604                          (match_operand:SI 1 "const_int_operand" "i")
3605                          (match_operand:SI 2 "const_int_operand" "i"))
3606         (match_operand:DI 3 "gpc_reg_operand" "r"))]
3607   "TARGET_POWERPC64"
3608   "*
3609 {
3610   int start = INTVAL (operands[2]) & 63;
3611   int size = INTVAL (operands[1]) & 63;
3612
3613   operands[1] = GEN_INT (64 - start - size);
3614   return \"rldimi %0,%3,%H1,%H2\";
3615 }"
3616   [(set_attr "type" "insert_dword")])
3617
3618 (define_insn "*insvdi_internal2"
3619   [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3620                          (match_operand:SI 1 "const_int_operand" "i")
3621                          (match_operand:SI 2 "const_int_operand" "i"))
3622         (ashiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3623                      (match_operand:SI 4 "const_int_operand" "i")))]
3624   "TARGET_POWERPC64
3625    && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3626   "*
3627 {
3628   int shift = INTVAL (operands[4]) & 63;
3629   int start = (INTVAL (operands[2]) & 63) - 32;
3630   int size = INTVAL (operands[1]) & 63;
3631
3632   operands[4] = GEN_INT (64 - shift - start - size);
3633   operands[2] = GEN_INT (start);
3634   operands[1] = GEN_INT (start + size - 1);
3635   return \"rlwimi %0,%3,%h4,%h2,%h1\";
3636 }")
3637
3638 (define_insn "*insvdi_internal3"
3639   [(set (zero_extract:DI (match_operand:DI 0 "gpc_reg_operand" "+r")
3640                          (match_operand:SI 1 "const_int_operand" "i")
3641                          (match_operand:SI 2 "const_int_operand" "i"))
3642         (lshiftrt:DI (match_operand:DI 3 "gpc_reg_operand" "r")
3643                      (match_operand:SI 4 "const_int_operand" "i")))]
3644   "TARGET_POWERPC64
3645    && insvdi_rshift_rlwimi_p (operands[1], operands[2], operands[4])"
3646   "*
3647 {
3648   int shift = INTVAL (operands[4]) & 63;
3649   int start = (INTVAL (operands[2]) & 63) - 32;
3650   int size = INTVAL (operands[1]) & 63;
3651
3652   operands[4] = GEN_INT (64 - shift - start - size);
3653   operands[2] = GEN_INT (start);
3654   operands[1] = GEN_INT (start + size - 1);
3655   return \"rlwimi %0,%3,%h4,%h2,%h1\";
3656 }")
3657
3658 (define_expand "extzv"
3659   [(set (match_operand 0 "gpc_reg_operand" "")
3660         (zero_extract (match_operand 1 "gpc_reg_operand" "")
3661                        (match_operand:SI 2 "const_int_operand" "")
3662                        (match_operand:SI 3 "const_int_operand" "")))]
3663   ""
3664   "
3665 {
3666   /* Do not handle 16/8 bit structures that fit in HI/QI modes directly, since
3667      the (SUBREG:SI (REG:HI xxx)) that is otherwise generated can confuse the
3668      compiler if the address of the structure is taken later.  */
3669   if (GET_CODE (operands[0]) == SUBREG
3670       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (operands[0]))) < UNITS_PER_WORD))
3671     FAIL;
3672
3673   if (TARGET_POWERPC64 && GET_MODE (operands[1]) == DImode)
3674     emit_insn (gen_extzvdi (operands[0], operands[1], operands[2], operands[3]));
3675   else
3676     emit_insn (gen_extzvsi (operands[0], operands[1], operands[2], operands[3]));
3677   DONE;
3678 }")
3679
3680 (define_insn "extzvsi"
3681   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
3682         (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
3683                          (match_operand:SI 2 "const_int_operand" "i")
3684                          (match_operand:SI 3 "const_int_operand" "i")))]
3685   ""
3686   "*
3687 {
3688   int start = INTVAL (operands[3]) & 31;
3689   int size = INTVAL (operands[2]) & 31;
3690
3691   if (start + size >= 32)
3692     operands[3] = const0_rtx;
3693   else
3694     operands[3] = GEN_INT (start + size);
3695   return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
3696 }")
3697
3698 (define_insn "*extzvsi_internal1"
3699   [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y")
3700         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3701                          (match_operand:SI 2 "const_int_operand" "i,i")
3702                          (match_operand:SI 3 "const_int_operand" "i,i"))
3703                     (const_int 0)))
3704    (clobber (match_scratch:SI 4 "=r,r"))]
3705   ""
3706   "*
3707 {
3708   int start = INTVAL (operands[3]) & 31;
3709   int size = INTVAL (operands[2]) & 31;
3710
3711   /* Force split for non-cc0 compare.  */
3712   if (which_alternative == 1)
3713      return \"#\";
3714
3715   /* If the bit-field being tested fits in the upper or lower half of a
3716      word, it is possible to use andiu. or andil. to test it.  This is
3717      useful because the condition register set-use delay is smaller for
3718      andi[ul]. than for rlinm.  This doesn't work when the starting bit
3719      position is 0 because the LT and GT bits may be set wrong.  */
3720
3721   if ((start > 0 && start + size <= 16) || start >= 16)
3722     {
3723       operands[3] = GEN_INT (((1 << (16 - (start & 15)))
3724                               - (1 << (16 - (start & 15) - size))));
3725       if (start < 16)
3726         return \"{andiu.|andis.} %4,%1,%3\";
3727       else
3728         return \"{andil.|andi.} %4,%1,%3\";
3729     }
3730
3731   if (start + size >= 32)
3732     operands[3] = const0_rtx;
3733   else
3734     operands[3] = GEN_INT (start + size);
3735   return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
3736 }"
3737   [(set_attr "type" "delayed_compare")
3738    (set_attr "length" "4,8")])
3739
3740 (define_split
3741   [(set (match_operand:CC 0 "cc_reg_not_cr0_operand" "")
3742         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3743                          (match_operand:SI 2 "const_int_operand" "")
3744                          (match_operand:SI 3 "const_int_operand" ""))
3745                     (const_int 0)))
3746    (clobber (match_scratch:SI 4 ""))]
3747   "reload_completed"
3748   [(set (match_dup 4)
3749         (zero_extract:SI (match_dup 1) (match_dup 2)
3750                          (match_dup 3)))
3751    (set (match_dup 0)
3752         (compare:CC (match_dup 4)
3753                     (const_int 0)))]
3754   "")
3755
3756 (define_insn "*extzvsi_internal2"
3757   [(set (match_operand:CC 4 "cc_reg_operand" "=x,?y")
3758         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
3759                          (match_operand:SI 2 "const_int_operand" "i,i")
3760                          (match_operand:SI 3 "const_int_operand" "i,i"))
3761                     (const_int 0)))
3762    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
3763         (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
3764   ""
3765   "*
3766 {
3767   int start = INTVAL (operands[3]) & 31;
3768   int size = INTVAL (operands[2]) & 31;
3769
3770   /* Force split for non-cc0 compare.  */
3771   if (which_alternative == 1)
3772      return \"#\";
3773
3774   /* Since we are using the output value, we can't ignore any need for
3775      a shift.  The bit-field must end at the LSB.  */
3776   if (start >= 16 && start + size == 32)
3777     {
3778       operands[3] = GEN_INT ((1 << size) - 1);
3779       return \"{andil.|andi.} %0,%1,%3\";
3780     }
3781
3782   if (start + size >= 32)
3783     operands[3] = const0_rtx;
3784   else
3785     operands[3] = GEN_INT (start + size);
3786   return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
3787 }"
3788   [(set_attr "type" "delayed_compare")
3789    (set_attr "length" "4,8")])
3790
3791 (define_split
3792   [(set (match_operand:CC 4 "cc_reg_not_cr0_operand" "")
3793         (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "")
3794                          (match_operand:SI 2 "const_int_operand" "")
3795                          (match_operand:SI 3 "const_int