OSDN Git Service

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