OSDN Git Service

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