OSDN Git Service

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