OSDN Git Service

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