OSDN Git Service

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