OSDN Git Service

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