OSDN Git Service

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